Compare commits
@@ -74,6 +74,52 @@ GRAPH_TENANT_ID=organizations
|
||||
GOOGLE_CLIENT_ID=
|
||||
GOOGLE_CLIENT_SECRET=
|
||||
|
||||
# --- Benachrichtigungen ----------------------------------------------------
|
||||
# Beides ist freiwillig. Fehlt es, laeuft der Planer ohne Benachrichtigungen
|
||||
# weiter und sagt es in den Einstellungen.
|
||||
|
||||
# Web-Push. Schluesselpaar einmalig erzeugen mit:
|
||||
# npx web-push generate-vapid-keys
|
||||
# Der oeffentliche Schluessel geht an den Browser, der private bleibt hier.
|
||||
# Wird das Paar getauscht, muessen sich alle Geraete neu anmelden.
|
||||
VAPID_OEFFENTLICH=
|
||||
VAPID_PRIVAT=
|
||||
# Kontakt fuer den Push-Dienst, als mailto: oder https:-Adresse.
|
||||
VAPID_KONTAKT=
|
||||
|
||||
# E-Mail. Push braucht SMTP nicht und umgekehrt.
|
||||
SMTP_HOST=
|
||||
SMTP_PORT=587
|
||||
SMTP_BENUTZER=
|
||||
SMTP_PASSWORT=
|
||||
# Absender, z. B. "Planer <planer@example.de>".
|
||||
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
|
||||
|
||||
@@ -8,3 +8,4 @@ test-results
|
||||
playwright-report
|
||||
coverage
|
||||
devlog/zeiten.csv
|
||||
public/sw.js
|
||||
|
||||
+161
@@ -6,6 +6,167 @@ die Versionierung [Semantic Versioning](https://semver.org/lang/de/).
|
||||
|
||||
## [Unveröffentlicht]
|
||||
|
||||
## [0.8.0] – 2026-09-13
|
||||
|
||||
### Hinzugefügt
|
||||
|
||||
- **MCP-Server** unter `/api/mcp` mit sechs Werkzeugen: Aufgaben suchen,
|
||||
Woche ansehen, Kalender auflisten, Aufgabe anlegen, abhaken und einplanen.
|
||||
Beschreibung in [docs/MCP.md](docs/MCP.md).
|
||||
- Die Werkzeugliste richtet sich nach den Rechten des Tokens — was ein Token
|
||||
nicht darf, sieht das Modell gar nicht erst.
|
||||
|
||||
### Geändert
|
||||
|
||||
- Das Einplanen liegt jetzt an einer Stelle, die sowohl die Oberfläche als
|
||||
auch der MCP-Server benutzen. Ein über MCP angelegter Zeitblock verhält
|
||||
sich damit genau wie ein von Hand gezogener.
|
||||
|
||||
### Sicherheit
|
||||
|
||||
- MCP benutzt dieselben Tokens und dieselben Rechte wie die Schnittstelle.
|
||||
Ein Sprachmodell bekommt keinen eigenen Zugang.
|
||||
- Jede schreibende Nutzung steht im Protokoll, mit dem Vermerk, dass sie
|
||||
über MCP kam.
|
||||
- Der Server kann weder löschen noch Bereiche, Projekte, Kalenderkonten,
|
||||
Einstellungen oder Tokens anfassen.
|
||||
|
||||
## [0.7.0] – 2026-09-13
|
||||
|
||||
### Hinzugefügt
|
||||
|
||||
- **Schnellerfassung vom Handy** unter _Erfassen_: ein Feld, ein Knopf. Was
|
||||
ohne Netz erfasst wird, bleibt im Gerät und geht hinaus, sobald wieder eine
|
||||
Verbindung da ist — mit einer Kennung je Erfassung, damit eine doppelt
|
||||
zugestellte Nachricht keine zweite Aufgabe ergibt.
|
||||
- Der Planer lässt sich als **App auf dem Startbildschirm ablegen**
|
||||
(Manifest, eigenes Symbol, eigener Startpunkt).
|
||||
- **Öffentliche Schnittstelle** unter `/api/v1`: Aufgaben lesen, anlegen,
|
||||
ändern und abhaken. Beschreibung in [docs/API.md](docs/API.md).
|
||||
- **Tokens je Anwendung** mit Rechten je Token, wahlweise mit Ablauf,
|
||||
verwaltbar unter _API_.
|
||||
- Handbuchseite zur Schnellerfassung.
|
||||
|
||||
### Sicherheit
|
||||
|
||||
- Von einem Token liegt nur der Fingerabdruck in der Datenbank. Der Wert
|
||||
erscheint genau einmal — beim Anlegen.
|
||||
- Die drei Rechte schließen einander nicht ein: Ein Dienst, der nur erfasst,
|
||||
kann den Bestand nicht lesen.
|
||||
- Jeder Fehlschlag beim Ausweisen sieht gleich aus. Ob ein Token unbekannt,
|
||||
abgelaufen oder zurückgezogen ist, verrät die Schnittstelle nicht.
|
||||
- Jede schreibende Nutzung steht im Protokoll, mitsamt dem Token — auch jeder
|
||||
abgewiesene Zugriff.
|
||||
- Die Schnittstelle kann weder löschen noch Bereiche, Projekte, Zeitblöcke
|
||||
oder Kalender anfassen.
|
||||
|
||||
## [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
|
||||
|
||||
- **Benachrichtigungen** per Web-Push und E-Mail, je Benutzer einstellbar.
|
||||
Vier Anlässe: Tagesüberblick am Morgen, fällige Aufgaben, Vorlauf vor einem
|
||||
Zeitblock und ein Kalender, der sich nicht abgleichen lässt.
|
||||
- **Ruhezeit** von 20:00 bis 07:00 ab Werk, über Mitternacht hinweg; wahlweise
|
||||
das ganze Wochenende. Der Tagesüberblick kommt trotzdem zu seiner Zeit — er
|
||||
käme sonst nie, wenn jemand früh aufsteht.
|
||||
- Anmeldung eines Browsers für Push, Liste der angemeldeten Geräte und ein
|
||||
Knopf, der eine Probemeldung über alle eingeschalteten Wege schickt.
|
||||
- Ein Lauf alle zehn Minuten prüft, ob etwas zu melden ist; die nächtliche
|
||||
Aufräumrunde entfernt Nachweise, die älter als 30 Tage sind.
|
||||
- Handbuchseite zu Benachrichtigungen.
|
||||
|
||||
### Geändert
|
||||
|
||||
- Der Kalenderabgleich zählt Fehlversuche in Folge mit und meldet erst ab dem
|
||||
dritten. Ein Netz hustet, ein Anbieter hat Wartung — das ist noch keine
|
||||
Nachricht wert.
|
||||
- Ab Werk meldet der Planer gar nichts: kein Weg ist eingeschaltet. Wer beim
|
||||
ersten Start mit Meldungen überschüttet wird, schaltet alles ab — und dann
|
||||
auch das Nützliche.
|
||||
|
||||
### Sicherheit
|
||||
|
||||
- Die Push-Schlüssel eines Geräts liegen verschlüsselt in der Datenbank.
|
||||
Weder Endpunkt noch Schlüssel noch Mailinhalte landen im Protokoll.
|
||||
- Ein Gerät, das der Push-Dienst mit 404 oder 410 ablehnt, wird sofort
|
||||
entfernt; andere Fehler führen nach fünf Versuchen zum selben Ergebnis.
|
||||
- Der Nachweis einer Meldung wird **vor** dem Senden geschrieben: lieber eine
|
||||
verpasste Nachricht als eine, die im Minutentakt erneut versucht wird.
|
||||
|
||||
## [0.4.0] – 2026-09-11
|
||||
|
||||
### Hinzugefügt
|
||||
|
||||
- **Wochenansicht** mit Ziehen und Ablegen: Aufgaben aus der linken Spalte in
|
||||
ein Zeitfenster ziehen legt einen Zeitblock an und schreibt ihn in den
|
||||
Kalender. Die Dauer kommt aus dem geschätzten Aufwand der Aufgabe.
|
||||
- Zeitblöcke verschieben und ausplanen; der Kalendertermin zieht mit.
|
||||
- **Rückweg**: Wird ein Zeitblock im Kalender verschoben, übernimmt der Planer
|
||||
das beim nächsten Abgleich. Wird er dort gelöscht, verschwindet auch der
|
||||
Zeitblock — die Aufgabe bleibt und fällt zurück auf offen.
|
||||
- Kapazität und Belegung je Wochentag über jeder Spalte; überbuchte Tage
|
||||
werden rot, sperren aber nichts.
|
||||
- Eine eingeplante Aufgabe wechselt selbsttätig von _Offen_ auf _Geplant_ und
|
||||
wieder zurück, wenn nichts mehr für sie geplant ist.
|
||||
- Handbuchseite zur Wochenplanung.
|
||||
|
||||
### Sicherheit
|
||||
|
||||
- **Schleifenschutz** über `hash = sha256(startISO|endeISO)`: Der Planer
|
||||
schreibt nur bei eigener Änderung und übernimmt aus dem Kalender nur, wenn
|
||||
der Fingerabdruck abweicht. Ohne das würden App und Kalender einander
|
||||
endlos hinterherschreiben.
|
||||
- Jeder Schreibzugriff auf einen bestehenden Termin geht mit `If-Match`
|
||||
heraus. Bei HTTP 412 **gewinnt der Kalender**: der Planer schreibt nicht,
|
||||
verwirft seinen Fingerabdruck und überlässt dem nächsten Abgleich, den
|
||||
fremden Stand zu holen.
|
||||
- Zeitblöcke gehören dem Benutzer über sein Kalenderkonto; die Kennung geht
|
||||
in jede where-Bedingung, nicht in einen nachträglichen Vergleich.
|
||||
|
||||
## [0.3.0] – 2026-09-10
|
||||
|
||||
### Hinzugefügt
|
||||
|
||||
@@ -7,9 +7,10 @@ lesen und Aufgaben per Ziehen und Ablegen als Zeitblöcke direkt in diese
|
||||
Kalender schreiben — inklusive Rückweg, wenn ein Block im Kalender verschoben
|
||||
wird.
|
||||
|
||||
> **Stand:** Meilenstein 3 von 8. Aufgaben, Projekte und das Lesen der
|
||||
> Kalender stehen: der Planer weiß jetzt, wann überhaupt Platz ist. Das
|
||||
> Schreiben der Zeitblöcke per Ziehen und Ablegen kommt mit M4. Der
|
||||
> **Stand:** Meilenstein 4 von 8. Die Kernidee steht: Aufgaben lassen sich
|
||||
> per Ziehen und Ablegen als Zeitblöcke in den Kalender schreiben, und
|
||||
> Verschiebungen von dort kommen zurück. Es folgen Benachrichtigungen,
|
||||
> Integrationen, Schnellerfassung vom Handy und ein MCP-Server. Der
|
||||
> [Fahrplan](ROADMAP.md) sagt, was wann folgt.
|
||||
|
||||
- **[Schnellstart](docs/SCHNELLSTART.md)** – in zehn Minuten von `git clone`
|
||||
@@ -30,6 +31,20 @@ wird.
|
||||
- **Projekte** mit Arbeitspaketen, Meilensteinen und Fortschritt
|
||||
- **Kalender lesen** aus Microsoft 365 und Google; die Startseite zeigt je
|
||||
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, 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
|
||||
- **Schnellerfassung vom Handy**, die auch im Funkloch nichts verliert; der
|
||||
Planer lässt sich als App auf dem Startbildschirm ablegen
|
||||
- **Öffentliche Schnittstelle** mit Tokens je Anwendung, Rechten je Token und
|
||||
jeder schreibenden Nutzung im Protokoll ([Beschreibung](docs/API.md))
|
||||
- **MCP-Server** für Sprachmodelle — dieselben Tokens, dieselben Rechte
|
||||
([Beschreibung](docs/MCP.md))
|
||||
- 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
|
||||
@@ -38,25 +53,27 @@ wird.
|
||||
- Hell und Dunkel, Oberfläche durchgehend auf Deutsch
|
||||
- Betrieb über Docker Compose, mit Sicherung, Aktualisierung und Healthcheck
|
||||
|
||||
### Geplant
|
||||
### Was noch kommen könnte
|
||||
|
||||
Zeitblöcke in den Kalender schreiben, Wochenplanung per Ziehen und Ablegen,
|
||||
Benachrichtigungen, Integrationen, Schnellerfassung vom Handy und ein
|
||||
MCP-Server. Siehe [ROADMAP.md](ROADMAP.md).
|
||||
Der [Fahrplan](ROADMAP.md) ist abgearbeitet. Was danach denkbar wäre, steht
|
||||
dort unter „Ideen für später" — und was bewusst nicht kommt, gleich darunter.
|
||||
|
||||
## Bildergalerie
|
||||
|
||||
| | Hell | Dunkel |
|
||||
| ------------- | ------------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
|
||||
| ------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
|
||||
| Anmelden |  |  |
|
||||
| Start |  |  |
|
||||
| Inbox |  |  |
|
||||
| Woche |  |  |
|
||||
| Aufgaben |  |  |
|
||||
| Projekte |  |  |
|
||||
| Ideen |  |  |
|
||||
| Kalender |  |  |
|
||||
| Bereiche |  |  |
|
||||
| Einstellungen |  |  |
|
||||
| Meldungen |  |  |
|
||||
| Integrationen |  |  |
|
||||
| Protokoll |  |  |
|
||||
|
||||
Alle Bilder entstehen mit `npm run screenshots` in einer Wegwerf-Instanz mit
|
||||
@@ -133,6 +150,76 @@ Rückleit-URI beim Anbieter lautet `<APP_URL>/api/auth/callback/oidc`.
|
||||
Ein Anbieter erscheint erst, wenn Kennung **und** Geheimnis gesetzt sind —
|
||||
und nur, wenn die Instanz ihn erlaubt (Google nur `daheim`).
|
||||
|
||||
### Benachrichtigungen
|
||||
|
||||
Beides ist freiwillig. Fehlt ein Satz, bleibt der Weg in den Einstellungen
|
||||
ausgegraut, und der Planer läuft ohne ihn weiter.
|
||||
|
||||
| Variable | Standard | Bedeutung |
|
||||
| ------------------- | -------- | --------------------------------------------------------- |
|
||||
| `VAPID_OEFFENTLICH` | _(leer)_ | Öffentlicher Push-Schlüssel, geht an den Browser |
|
||||
| `VAPID_PRIVAT` | _(leer)_ | Privater Push-Schlüssel, bleibt auf dem Server |
|
||||
| `VAPID_KONTAKT` | _(leer)_ | Kontakt für den Push-Dienst, `mailto:` oder `https:` |
|
||||
| `SMTP_HOST` | _(leer)_ | Mailserver. Ohne ihn kein Mailversand |
|
||||
| `SMTP_PORT` | `587` | Port des Mailservers |
|
||||
| `SMTP_BENUTZER` | _(leer)_ | Anmeldename. Leer lassen für einen Server ohne Anmeldung |
|
||||
| `SMTP_PASSWORT` | _(leer)_ | Passwort dazu |
|
||||
| `SMTP_ABSENDER` | _(leer)_ | Absenderadresse, z. B. `Planer <planer@example.de>` |
|
||||
| `SMTP_TLS` | `false` | `true` bei Port 465 (SMTPS), `false` bei 587 mit STARTTLS |
|
||||
|
||||
Push braucht **alle drei** VAPID-Werte, Mail mindestens `SMTP_HOST` und
|
||||
`SMTP_ABSENDER`. Die Schlüssel entstehen einmalig mit:
|
||||
|
||||
```bash
|
||||
npx web-push generate-vapid-keys
|
||||
```
|
||||
|
||||
Wird das Schlüsselpaar später getauscht, müssen sich alle Geräte neu
|
||||
anmelden — die alten Abos sind dann wertlos. Push setzt außerdem HTTPS
|
||||
voraus; `http://localhost` gilt dem Browser als sicher, jede andere
|
||||
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 |
|
||||
|
||||
+83
-25
@@ -8,11 +8,11 @@ grünen Prüfungen, aktueller Dokumentation und einem Eintrag im DEVLOG.
|
||||
| [M1](#m1--fundament) | Fundament | erledigt |
|
||||
| [M2](#m2--aufgaben-und-projekte) | Aufgaben und Projekte | erledigt |
|
||||
| [M3](#m3--kalender-lesen) | Kalender lesen | erledigt |
|
||||
| [M4](#m4--wochenplanung-und-zeitblöcke) | Wochenplanung und Zeitblöcke | geplant |
|
||||
| [M5](#m5--benachrichtigungen) | Benachrichtigungen | geplant |
|
||||
| [M6](#m6--integrationen) | Integrationen | geplant |
|
||||
| [M7](#m7--schnellerfassung-und-api) | Schnellerfassung und API | geplant |
|
||||
| [M8](#m8--mcp) | MCP | geplant |
|
||||
| [M4](#m4--wochenplanung-und-zeitblöcke) | Wochenplanung und Zeitblöcke | erledigt |
|
||||
| [M5](#m5--benachrichtigungen) | Benachrichtigungen | erledigt |
|
||||
| [M6](#m6--integrationen) | Integrationen | erledigt |
|
||||
| [M7](#m7--schnellerfassung-und-api) | Schnellerfassung und API | erledigt |
|
||||
| [M8](#m8--mcp) | MCP | erledigt |
|
||||
|
||||
---
|
||||
|
||||
@@ -76,41 +76,99 @@ später" und wartet darauf, ob es im Alltag wirklich fehlt.
|
||||
|
||||
## M4 – Wochenplanung und Zeitblöcke
|
||||
|
||||
**Erledigt am 11.09.2026 mit Version 0.4.0.**
|
||||
|
||||
**Ziel:** Aufgaben per Ziehen und Ablegen in den Kalender schreiben — und
|
||||
Verschiebungen von dort zurückholen.
|
||||
|
||||
- [ ] `Zeitblock` an genau einer Aufgabe und einem Kalenderkonto
|
||||
- [ ] Wochenansicht mit `@dnd-kit/core`
|
||||
- [ ] Schreiben in den Kalender, Rückweg beim Verschieben
|
||||
- [ ] Schleifenschutz über `hash = sha256(startISO|endeISO)`
|
||||
- [ ] Konflikte: der Kalender gewinnt (HTTP 412 auf If-Match)
|
||||
- [ ] Belegung gegen die Tageskapazität des Bereichs
|
||||
- [x] `Zeitblock` an genau einer Aufgabe und einem Kalenderkonto
|
||||
- [x] Wochenansicht mit `@dnd-kit/core`
|
||||
- [x] Schreiben in den Kalender, Rückweg beim Verschieben
|
||||
- [x] Schleifenschutz über `hash = sha256(startISO|endeISO)`
|
||||
- [x] Konflikte: der Kalender gewinnt (HTTP 412 auf If-Match)
|
||||
- [x] Belegung gegen die Tageskapazität des Bereichs
|
||||
|
||||
**Bewusst offen gelassen:** Die Dauer lässt sich nicht am Balken ziehen, und
|
||||
ein Zeitblock landet immer im ersten verbundenen Kalender. Beides steht unter
|
||||
"Ideen für später" — erst zeigt der Alltag, ob es wirklich fehlt.
|
||||
|
||||
## M5 – Benachrichtigungen
|
||||
|
||||
- [ ] Web-Push mit `web-push`
|
||||
- [ ] Tagesüberblick per E-Mail über nodemailer
|
||||
- [ ] Erinnerungen an Fälligkeiten, Jobs über node-cron
|
||||
- [ ] Je Benutzer einstellbar, mit Ruhezeiten
|
||||
**Erledigt am 11.09.2026 mit Version 0.5.0.**
|
||||
|
||||
**Ziel:** Sagen, was ansteht — und dabei so selten stören, dass niemand auf
|
||||
die Idee kommt, alles abzuschalten.
|
||||
|
||||
- [x] Web-Push mit `web-push`, Anmeldung je Browser
|
||||
- [x] Tagesüberblick per E-Mail über nodemailer
|
||||
- [x] Erinnerungen an Fälligkeiten und vor Zeitblöcken, Jobs über node-cron
|
||||
- [x] Je Benutzer einstellbar, mit Ruhezeiten über Mitternacht
|
||||
- [x] Wiederholungssperre je Anlass, Sache und Tag
|
||||
- [x] Abgleichfehler erst nach mehreren Versuchen hintereinander
|
||||
|
||||
**Bewusst offen gelassen:** Keine Sammelmeldung mehrerer Anlässe in einer
|
||||
Nachricht und kein Nachholen dessen, was in die Ruhezeit fiel. Eine
|
||||
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
|
||||
|
||||
- [ ] Erfassung vom Handy, auch offline
|
||||
- [ ] Öffentliche API mit Token je Anwendung
|
||||
- [ ] Rechte je Token, jede Nutzung im Protokoll
|
||||
**Erledigt am 12.09.2026 mit Version 0.7.0.**
|
||||
|
||||
**Ziel:** Etwas festhalten können, wo man gerade steht — und andere
|
||||
Anwendungen hereinlassen, ohne ihnen die Schlüssel zum ganzen Haus zu geben.
|
||||
|
||||
- [x] Erfassung vom Handy, auch offline
|
||||
- [x] Öffentliche API mit Token je Anwendung
|
||||
- [x] Rechte je Token, jede schreibende Nutzung im Protokoll
|
||||
- [x] Als App ablegbar (Manifest, eigenes Symbol)
|
||||
|
||||
**Offen geblieben:** Die Bilder der Erfassungsseite im Handbuch zeigen noch
|
||||
eine falsche Inbox-Zahl; der Fehler selbst ist behoben, nur der Bildlauf
|
||||
kam danach nicht mehr durch.
|
||||
|
||||
**Bewusst offen gelassen:** Die Schnittstelle kann keine Bereiche, Projekte
|
||||
oder Zeitblöcke anfassen und nichts löschen. Was von außen kommt, landet in
|
||||
der Inbox; die Einordnung bleibt bei dem, der plant. Auch eine Begrenzung der
|
||||
Aufrufzahl gibt es nicht — bei einer Handvoll eigener Tokens wäre sie mehr
|
||||
Zeremonie als Schutz.
|
||||
|
||||
## M8 – MCP
|
||||
|
||||
- [ ] MCP-Server über `@modelcontextprotocol/sdk`
|
||||
- [ ] Lesen und Anlegen von Aufgaben und Zeitblöcken
|
||||
- [ ] Rechte wie bei der API, jede Nutzung im Protokoll
|
||||
**Erledigt am 13.09.2026 mit Version 0.8.0.**
|
||||
|
||||
**Ziel:** Ein Sprachmodell soll den Alltag erleichtern können — ohne einen
|
||||
eigenen, weicheren Zugang zu bekommen als jede andere fremde Anwendung.
|
||||
|
||||
- [x] MCP-Server über `@modelcontextprotocol/sdk`
|
||||
- [x] Lesen und Anlegen von Aufgaben und Zeitblöcken
|
||||
- [x] Rechte wie bei der API, jede schreibende Nutzung im Protokoll
|
||||
- [x] Werkzeugliste richtet sich nach den Rechten des Tokens
|
||||
|
||||
**Bewusst offen gelassen:** Der Server kann nichts löschen, keine Bereiche
|
||||
oder Projekte anlegen und keine Einstellungen anfassen. Ein Modell soll den
|
||||
Alltag erleichtern, nicht die Ordnung umbauen.
|
||||
|
||||
---
|
||||
|
||||
|
||||
+455
-2
@@ -6,11 +6,464 @@ 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 |
|
||||
| **Gesamt** | | **246** | **4,10** |
|
||||
| M4 | claude | 167 | 2,78 |
|
||||
| M5 | claude | 420 | 7,00 |
|
||||
| M6 | claude | 733 | 12,22 |
|
||||
| M7 | claude | 886 | 14,77 |
|
||||
| M8 | claude | 69 | 1,15 |
|
||||
| **Gesamt** | | **2521** | **42,02** |
|
||||
|
||||
---
|
||||
|
||||
## 2026-09-13 – M8: MCP
|
||||
|
||||
**Dauer:** 69 Minuten (14:10–15:19), Art `claude`.
|
||||
|
||||
> Der kürzeste Meilenstein — weil das Fundament schon stand. Tokens, Rechte
|
||||
> und Protokoll kamen mit M7, der Kalenderschreibweg mit M4. Übrig blieb das
|
||||
> Zusammenstecken.
|
||||
|
||||
**Ziel der Sitzung:** Ein Sprachmodell soll den Alltag erleichtern können —
|
||||
ohne einen eigenen, weicheren Zugang zu bekommen als jede andere fremde
|
||||
Anwendung.
|
||||
|
||||
### Erledigt
|
||||
|
||||
- MCP-Server unter `/api/mcp` über `@modelcontextprotocol/sdk`
|
||||
- Sechs Werkzeuge: suchen, Woche ansehen, Kalender auflisten, anlegen,
|
||||
abhaken, einplanen
|
||||
- Das Einplanen aus der Serveraktion herausgelöst, damit Oberfläche und MCP
|
||||
dieselbe Stelle benutzen
|
||||
- 6 neue E2E-Tests, Beschreibung in `docs/MCP.md`
|
||||
|
||||
### Entscheidungen mit Begründung
|
||||
|
||||
**Dieselben Tokens, dieselben Rechte wie die Schnittstelle.** Ein
|
||||
Sprachmodell ist aus Sicht des Planers eine fremde Anwendung wie jede andere.
|
||||
Ein eigener Zugangsweg wäre ein zweiter Satz Regeln — und der zweite Satz ist
|
||||
immer der, den man vergisst zu pflegen.
|
||||
|
||||
**Die Werkzeugliste richtet sich nach den Rechten.** Was ein Token nicht
|
||||
darf, taucht gar nicht erst auf. Ein Modell soll nicht gegen eine Tür laufen,
|
||||
die für es verschlossen ist; und eine Fehlermeldung als Antwort auf einen
|
||||
Werkzeugaufruf ist verschwendeter Kontext.
|
||||
|
||||
**Wenige, grob geschnittene Werkzeuge.** Ein Modell, das zwischen zwanzig
|
||||
fast gleichen wählen muss, wählt falsch. Jedes weitere Werkzeug ist zudem
|
||||
eine zusätzliche Möglichkeit, versehentlich etwas zu ändern.
|
||||
|
||||
**Der Server kann nichts löschen.** Abhaken ja, wegräumen nein. Auch keine
|
||||
Bereiche, Projekte oder Einstellungen anfassen. Ein Modell soll den Alltag
|
||||
erleichtern, nicht die Ordnung umbauen.
|
||||
|
||||
**Das Einplanen liegt jetzt an einer gemeinsamen Stelle** — und die liegt
|
||||
bewusst **nicht** in einer Datei mit `'use server'`. Dort wird jede
|
||||
exportierte Funktion zu einem Endpunkt, den der Browser aufrufen kann; eine
|
||||
Funktion, die den Akteur als Parameter nimmt, wäre dann ein offenes Tor.
|
||||
|
||||
**Zustandslos.** Der Planer hat keine langlaufenden Vorgänge, und eine
|
||||
Sitzungsverwaltung wäre Zustand, den mehrere Container nicht teilen könnten.
|
||||
|
||||
### Probleme und Lösungen
|
||||
|
||||
| Problem | Lösung |
|
||||
| --------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| Der SDK-Transport erwartet Node-Streams, Next liefert `Request` | Das SDK bringt seit 1.30 `WebStandardStreamableHTTPServerTransport` mit — `handleRequest(Request): Promise<Response>` passt direkt. |
|
||||
| ESLint beanstandete das Auslesen der Formularfelder | `FormData.get` kann auch eine Datei liefern; die würde beim Stringify zu `[object Object]`. Ein Helfer nimmt jetzt nur Text. |
|
||||
|
||||
### Offene Punkte
|
||||
|
||||
- Der Server ist gegen die eigenen Tests geprüft, nicht gegen einen echten
|
||||
Client. Ein Lauf mit Claude Code gegen die laufende Instanz wäre der
|
||||
Beweis, dass Handschlag und Werkzeugbeschreibungen auch dort taugen.
|
||||
- Die Handbuchbilder sind unverändert aus M7 — der MCP-Server hat keine
|
||||
Oberfläche, es gibt nichts abzubilden.
|
||||
|
||||
### Commits
|
||||
|
||||
- 5f45dff refactor: Einplanen aus der Serveraktion herauslösen
|
||||
- bdc4260 feat: MCP-Server über denselben Token wie die API
|
||||
- (docs) MCP beschreiben, Fahrplan abschließen
|
||||
|
||||
---
|
||||
|
||||
## 2026-09-13 – M7: Schnellerfassung und API
|
||||
|
||||
**Dauer:** 886 Minuten (10:15–01:01), Art `claude`.
|
||||
|
||||
> Wie schon bei M6 sagt die Zahl mehr über den Rechner als über die Arbeit:
|
||||
> Fünf hängende Docker-Bauten, einer davon mit einem einzelnen Schritt über
|
||||
> drei Stunden. Die Bildaufnahme musste achtmal angestoßen werden.
|
||||
|
||||
**Ziel der Sitzung:** Etwas festhalten können, wo man gerade steht — und
|
||||
andere Anwendungen hereinlassen, ohne ihnen die Schlüssel zum ganzen Haus zu
|
||||
geben.
|
||||
|
||||
### Erledigt
|
||||
|
||||
- Regeln der Schnittstelle als reine Logik: Rechte, Tokenaufbau, Eingaben
|
||||
(30 Tests)
|
||||
- `/api/v1`: Aufgaben lesen, anlegen, ändern, abhaken
|
||||
- Tokens mit Rechten und wahlweise Ablauf, verwaltbar in der Anwendung
|
||||
- Schnellerfassung fürs Handy mit Warteschlange in IndexedDB
|
||||
- Manifest und Symbol: der Planer lässt sich als App ablegen
|
||||
- 10 neue E2E-Tests, 6 neue Integrationsprüfungen, Handbuchseite, API-Doku
|
||||
|
||||
### Entscheidungen mit Begründung
|
||||
|
||||
**Von einem Token liegt nur der Hash in der Datenbank.** Ein Token ist ein
|
||||
Passwort; es gibt keinen Grund, es zurücklesen zu können, und jeden Grund,
|
||||
es nicht zu können. SHA-256 ohne Salz ist hier richtig — der Wert hat 32
|
||||
Byte Zufall, gegen so etwas hilft kein Wörterbuch, und die Prüfung muss bei
|
||||
jeder Anfrage schnell sein.
|
||||
|
||||
**Kein Recht schließt ein anderes ein.** „Erfassen" darf nicht lesen. Ein
|
||||
Dienst, der nur meldet „hier ist etwas Neues", braucht den Bestand nicht zu
|
||||
sehen — und das ist der häufigste Fall.
|
||||
|
||||
**Der sichtbare Anfang heißt `planer_`.** Wer so einen Wert versehentlich in
|
||||
ein öffentliches Verzeichnis schiebt, soll ihn beim Durchsehen erkennen.
|
||||
|
||||
**`/selbst` braucht kein Recht.** Sonst müsste man beim Einrichten raten, ob
|
||||
der Token falsch ist oder nur zu wenig darf.
|
||||
|
||||
**Die Schnittstelle kann Bereich und Projekt nicht setzen.** Was von außen
|
||||
kommt, landet in der Inbox. Die Einordnung ist Sache dessen, der plant,
|
||||
nicht dessen, der meldet. Löschen kann sie auch nicht: Ein Fehler im fremden
|
||||
Skript soll keine Planung vernichten.
|
||||
|
||||
**Erst anstellen, dann senden.** Die Schnellerfassung schreibt zuerst in die
|
||||
Warteschlange des Geräts und versucht dann zu senden. Andersherum wäre der
|
||||
Eintrag weg, wenn der Browser mitten im Senden geschlossen wird.
|
||||
|
||||
**IndexedDB statt localStorage.** Das sind echte Daten des Benutzers. Ein
|
||||
Eintrag, der beim Aufräumen des Speichers verschwindet, ist eine verlorene
|
||||
Aufgabe — genau das, was der Planer verhindern soll.
|
||||
|
||||
**Der Dienstarbeiter hält genau eine Seite vor.** Ein halb veralteter Planer
|
||||
wäre schlimmer als gar keiner; ein leeres Eingabefeld dagegen veraltet
|
||||
nicht. Und ohne die Seite nützte die Warteschlange niemandem: Man käme gar
|
||||
nicht erst hin.
|
||||
|
||||
**Die Navigation wurde geteilt statt weiter gedehnt.** Nach M6 hatte ich die
|
||||
Leiste verbreitert; mit dem dreizehnten Eintrag verschluckte sie erneut
|
||||
Punkte. Das war die falsche Antwort: Das Problem ist nicht die Breite,
|
||||
sondern die Vermischung. Alltag steht in der Leiste, Einrichtung und
|
||||
Verwaltung liegen hinter „Mehr".
|
||||
|
||||
### Probleme und Lösungen
|
||||
|
||||
| Problem | Lösung |
|
||||
| -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| Die Erfassungsseite zählte die Inbox anders als die Kopfleiste | Sie zählte Ideen mit. Jetzt benutzt sie dieselbe Abfrage. Derselbe Fehlertyp wie in M2 — und wieder nur im Bild aufgefallen, im Code sah jede Seite für sich richtig aus. |
|
||||
| Die Leiste verschluckte mit dem dreizehnten Eintrag wieder Punkte | Aufgeteilt statt verbreitert, siehe oben. Zwei E2E-Tests greifen den neuen Weg über „Mehr" auf. |
|
||||
| Ein E2E-Test brach mit `ERR_ABORTED` ab | Die Erfolgsmeldung kommt, bevor das Neuladen der Liste fertig ist; wer dann navigiert, bricht es ab. Der Test wartet jetzt darauf. |
|
||||
| `exactOptionalPropertyTypes` und Prismas Update-Typen vertragen kein `undefined` | Das Datenobjekt wird Feld für Feld gebaut statt per Spread. Ein gesetztes `undefined` ist etwas anderes als ein fehlendes Feld. |
|
||||
| Ein Devanagari-Zeichen war in ein Token-Präfix der Demo-Daten geraten | Entfernt. Beim Schreiben über die Shell passiert so etwas; die Datei danach durchsucht. |
|
||||
| Fünf hängende Docker-Bauten, einer über drei Stunden | Kein Codeproblem: Nach Abbruch und Neustart lief derselbe Bau in Minuten durch. Zweimal scheiterte zusätzlich das Anlegen des Compose-Netzes. |
|
||||
|
||||
### Offene Punkte
|
||||
|
||||
- **Die Bilder der Erfassungsseite zeigen die alte Inbox-Zahl.** Der Bildlauf
|
||||
ließ sich nach der Korrektur nicht mehr durchbringen. Ein Lauf, wenn Docker
|
||||
wieder mitspielt, räumt das auf.
|
||||
- Keine Begrenzung der Aufrufzahl je Token. Bei einer Handvoll eigener
|
||||
Tokens wäre sie mehr Zeremonie als Schutz — bei einem Token, der außer
|
||||
Haus geht, sähe das anders aus.
|
||||
- Die Warteschlange kennt keinen Abbruch: Ein Eintrag, der dauerhaft
|
||||
scheitert, wird ewig erneut versucht. Bisher gibt es keinen Fall, in dem
|
||||
das passieren könnte, ohne dass gleichzeitig die Anmeldung fehlt.
|
||||
|
||||
### Commits
|
||||
|
||||
- d5c7974 feat: Datenmodell und Regeln für die öffentliche Schnittstelle
|
||||
- 6d3ebd0 feat: API v1 für Aufgaben
|
||||
- b17c42a feat: Tokens verwalten
|
||||
- 9565b9a feat: Schnellerfassung vom Handy, auch ohne Netz
|
||||
- 10b49cf test: Die Tür der Schnittstelle scharf prüfen
|
||||
- 2e57713 docs: Handbuchseite zum Erfassen und Beschreibung der Schnittstelle
|
||||
- 7919149 fix: Navigation aufteilen, statt sie weiter zu dehnen
|
||||
- f9a616e docs: Handbuchbilder für M7 aufnehmen
|
||||
|
||||
---
|
||||
|
||||
## 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
|
||||
|
||||
---
|
||||
|
||||
## 2026-09-11 – M5: Benachrichtigungen
|
||||
|
||||
**Dauer:** 420 Minuten (06:35–13:35), Art `claude`.
|
||||
|
||||
**Ziel der Sitzung:** Sagen, was ansteht — und dabei so selten stören, dass
|
||||
niemand auf die Idee kommt, alles abzuschalten.
|
||||
|
||||
### Erledigt
|
||||
|
||||
- Regeln als reine Logik: Anlässe, Ruhezeit, Wiederholungssperre (30 Tests)
|
||||
- Web-Push über VAPID samt Service Worker, An- und Abmeldung je Browser
|
||||
- Mailversand über nodemailer, als Text und als HTML
|
||||
- Vier Anlässe: Tagesüberblick, Fälligkeit, Vorlauf vor einem Zeitblock,
|
||||
Abgleichfehler
|
||||
- Bedienung in den Einstellungen mit Probemeldung und Geräteliste
|
||||
- Ein Lauf alle zehn Minuten, Nachweise räumt die Nachtrunde weg
|
||||
- 2 neue E2E-Tests, 7 neue Integrationsprüfungen, Handbuchseite
|
||||
|
||||
### Entscheidungen mit Begründung
|
||||
|
||||
**Ab Werk meldet der Planer gar nichts.** Kein Weg ist eingeschaltet. Wer
|
||||
beim ersten Start mit Meldungen überschüttet wird, schaltet alles ab — und
|
||||
dann auch das Nützliche. Die Einrichtung ist ein bewusster Handgriff, und
|
||||
das ist der Preis dafür, dass die Meldungen später ernst genommen werden.
|
||||
|
||||
**Der Tagesüberblick ist von der Ruhezeit ausgenommen.** Sonst bekäme ihn
|
||||
nie, wer ihn auf 06:00 stellt — die voreingestellte Ruhezeit läuft bis
|
||||
07:00. Die Ruhezeit schützt vor Störungen, nicht vor der Nachricht, um die
|
||||
ausdrücklich gebeten wurde.
|
||||
|
||||
**Der Nachweis wird vor dem Senden geschrieben, nicht danach.** Bricht der
|
||||
Versand mittendrin ab, gilt die Meldung als zugestellt und kommt nicht
|
||||
wieder. Andersherum würde ein hängender Mailserver dieselbe Nachricht alle
|
||||
zehn Minuten erneut versuchen. Lieber eine verpasste Nachricht als eine,
|
||||
die im Minutentakt klopft.
|
||||
|
||||
**Was in die Ruhezeit fällt, wird nicht nachgeholt.** Eine Erinnerung an
|
||||
einen Zeitblock, der längst begonnen hat, ist nur der Beweis, dass die
|
||||
Anwendung zu spät kommt.
|
||||
|
||||
**Abgleichfehler erst ab dem dritten Versuch in Folge.** Ein Netz hustet,
|
||||
ein Anbieter hat Wartung. Beim ersten Fehlschlag zu melden hieße, für
|
||||
Dinge zu wecken, die sich von selbst erledigen. Nach dem dritten Mal ist es
|
||||
dagegen dringend — solange steht die Wochenansicht auf altem Stand.
|
||||
|
||||
**Der Tagesüberblick entfällt, wenn es nichts zu sagen gibt.** „Heute steht
|
||||
nichts an" ist keine Information, sondern Lärm.
|
||||
|
||||
**Tote Abos putzen sich selbst weg.** 404 und 410 heißen endgültig, das
|
||||
Gerät verschwindet sofort; andere Fehler zählen hoch und führen nach fünf
|
||||
Versuchen zum selben Ergebnis. Eine Liste, die von Hand gepflegt werden
|
||||
muss, wird nicht gepflegt.
|
||||
|
||||
**Push-Schlüssel liegen verschlüsselt, Endpunkte nie im Protokoll.** Ein
|
||||
Endpunkt genügt, um jemandem Nachrichten zu schicken — er gehört damit in
|
||||
dieselbe Klasse wie ein Token.
|
||||
|
||||
### Probleme und Lösungen
|
||||
|
||||
| Problem | Lösung |
|
||||
| --------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| `pushManager.subscribe` lehnte den VAPID-Schlüssel als `Uint8Array<ArrayBufferLike>` ab | Der Puffer wird jetzt ausdrücklich als `ArrayBuffer` angelegt; ein geteilter Puffer ist dort nicht erlaubt. |
|
||||
| Der Integrationstest brach mit einem Fremdschlüsselfehler ab | Die neuen Prüfungen standen hinter dem Löschen des Testbenutzers. Jetzt davor — und danach wird geprüft, dass Geräte und Nachweise mit ihm verschwinden. |
|
||||
| E2E-Läufe scheiterten unter Last immer wieder beim Anmelden | Ein Klick, der vor der Hydratation ankommt, verpufft folgenlos. Der Anmeldehelfer liegt jetzt einmal in `e2e/hilfe.ts` und fasst nach, bis die Startseite da ist. |
|
||||
| Die Karte meldete gleichzeitig „Browser blockiert" und „Server nicht eingerichtet" | Zwei Aussagen, von denen nur eine zählt. Der Serverzustand geht jetzt vor. Gefunden nur durch das Ansehen des aufgenommenen Bildes. |
|
||||
| Das erfundene Push-Gerät in den Demo-Daten wäre beim ersten Versandlauf gelöscht worden | Seine Schlüssel lagen als Klartext-Platzhalter, und unlesbare Schlüssel führen zum Entfernen. Die Demo-Daten enthalten jetzt kein Gerät mehr — die Bilder zeigen den Zustand davor. |
|
||||
| Im Bild meldet der Browser „blockiert", obwohl die Erlaubnis erteilt wurde | Chromium im Kopflosbetrieb antwortet auf `Notification.permission` immer mit `denied`; `grantPermissions` ändert daran nichts. Das Handbuch schreibt es jetzt unter das Bild. |
|
||||
| Ein Docker-Bau brauchte 14 Minuten, ein E2E-Lauf 18 | Systemlast, kein Codeproblem: dieselben Läufe danach in 1,5 beziehungsweise 0,4 Minuten. Ein vergessener Testserver auf Port 3100 hat kräftig mitgeholfen. |
|
||||
|
||||
### Offene Punkte
|
||||
|
||||
- Der Versandweg ist gegen die Logik geprüft, nicht gegen echte Dienste:
|
||||
ohne VAPID-Schlüssel und SMTP-Zugang geht lokal nichts hinaus. Das braucht
|
||||
einen Lauf auf dem Server.
|
||||
- Mehrere Anlässe erscheinen als mehrere Nachrichten. Ob eine Sammelmeldung
|
||||
fehlt, zeigt erst der Alltag.
|
||||
|
||||
### Commits
|
||||
|
||||
- 24f613d feat: Datenmodell und Umgebung für Benachrichtigungen
|
||||
- ddb13d7 feat: Regeln für Benachrichtigungen als reine Logik
|
||||
- e0e11c8 feat: Versand per Web-Push und E-Mail
|
||||
- b622c1b feat: Benachrichtigungen in den Einstellungen bedienen
|
||||
- 047a4a1 feat: Meldungen alle zehn Minuten prüfen und verschicken
|
||||
- 5bbbdd5 chore: Demo-Daten und Bildaufnahme für Benachrichtigungen
|
||||
- f03ea73 docs: Handbuchseite und README-Abschnitt zu Benachrichtigungen
|
||||
- 6e1f279 test: Benachrichtigungen end-to-end und in der Datenbank absichern
|
||||
- 7bef435 fix: Serverzustand geht der Browsermeldung vor
|
||||
- 35ecb2f chore: Screenshot-Instanz mit eingerichteten Meldewegen
|
||||
- bb7b189 docs: Handbuchbilder für M5 neu aufnehmen
|
||||
|
||||
---
|
||||
|
||||
## 2026-09-10 – M4: Wochenplanung und Zeitblöcke
|
||||
|
||||
**Dauer:** 167 Minuten (20:42–23:29), Art `claude`.
|
||||
|
||||
**Ziel der Sitzung:** Die Kernidee des Projekts — Aufgaben per Ziehen und
|
||||
Ablegen in echte Kalendertermine verwandeln, mit Rückweg.
|
||||
|
||||
### Erledigt
|
||||
|
||||
- `Zeitblock` samt Migration und Schleifenschutz (30 Tests)
|
||||
- Schreibweg zu Graph und Google mit `If-Match`, Rückweg im Abgleich
|
||||
- Rasterlogik für die Wochenansicht (21 Tests)
|
||||
- Wochenansicht mit `@dnd-kit/core`: einplanen, verschieben, ausplanen
|
||||
- Kapazität und Belegung je Wochentag
|
||||
- 3 neue E2E-Tests, Handbuchseite
|
||||
|
||||
### Entscheidungen mit Begründung
|
||||
|
||||
**Der Fingerabdruck geht nur über Beginn und Ende.** Titel und Beschreibung
|
||||
ändern sich auch aus harmlosen Gründen — etwa weil der Aufgabentitel
|
||||
bearbeitet wurde. Für die Planung zählt allein, wann der Block liegt; alles
|
||||
andere in den Fingerabdruck zu nehmen hieße, den Anbieter grundlos zu
|
||||
behelligen.
|
||||
|
||||
**Der Kalender gewinnt, ausnahmslos.** Wer im Kalender etwas verschiebt,
|
||||
meint es so. Säße der Planer am längeren Hebel, zöge er dem Benutzer den
|
||||
Termin wieder weg — und der wüsste nicht, warum. Bei HTTP 412 verwirft der
|
||||
Planer sogar seinen eigenen Fingerabdruck, damit der nächste Abgleich die
|
||||
fremde Änderung sicher als solche erkennt.
|
||||
|
||||
**Scheitert das Schreiben, überlebt die Planung.** Der Zeitblock bleibt mit
|
||||
vermerktem Fehler stehen. Ihn zu verwerfen hieße, die Planung des Benutzers
|
||||
wegen eines Netzproblems zu vergessen; das nächste Verschieben trägt ihn
|
||||
nach. Beim Löschen ist es umgekehrt: Da verschwindet der Zeitblock auch bei
|
||||
unerreichbarem Kalender, sonst wäre die Planung blockiert.
|
||||
|
||||
**Die Dauer kommt aus dem geschätzten Aufwand.** Wer schätzt, bekommt die
|
||||
passende Blockgröße geschenkt. Das belohnt genau die Gewohnheit, die die
|
||||
Planung überhaupt erst tragfähig macht.
|
||||
|
||||
**Ziehen beginnt erst nach acht Pixeln.** Ohne diese Schwelle löst jeder
|
||||
Klick einen Zug aus und die Knöpfe im Block wären nicht mehr bedienbar.
|
||||
|
||||
**Überbuchte Tage werden rot, aber nicht gesperrt.** Der Planer ist ein
|
||||
Werkzeug, kein Aufpasser. Manchmal muss ein Tag überbucht sein.
|
||||
|
||||
### Probleme und Lösungen
|
||||
|
||||
| Problem | Lösung |
|
||||
| --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
|
||||
| Ein Zeitblock steht auch im Terminspiegel und erschien doppelt — einmal als eigene Planung, einmal als fremder Termin | Die Wochenabfrage filtert Termine heraus, deren `extId` zu einem Zeitblock gehört. |
|
||||
| Ein Build lief 32 Minuten statt Sekunden | Systemlast durch einen gleichzeitigen Docker-Bau. Ein sauberer Neubau danach: 46 Sekunden. Kein Codeproblem. |
|
||||
| Sich überschneidende Termine lagen unsichtbar übereinander | `spurenVerteilen` legt sie nebeneinander und gibt eine Spur wieder frei, sobald sie zu Ende ist. |
|
||||
|
||||
### Offene Punkte
|
||||
|
||||
- **Der Schreibweg ist nicht gegen die echten APIs geprüft.** Wie in M3
|
||||
fehlen die Zugangsdaten. Die Logik ist getestet, der erste echte Schreib-
|
||||
und Rückweg ist Florians.
|
||||
- Die Dauer lässt sich nicht am Balken ziehen; wer eine andere will, ändert
|
||||
den Aufwand der Aufgabe.
|
||||
- Ein Zeitblock landet immer im ersten verbundenen Kalender. Das
|
||||
Standard-Kalenderkonto je Bereich ist im Datenmodell vorbereitet, aber
|
||||
noch nicht in der Oberfläche.
|
||||
|
||||
### Commits
|
||||
|
||||
- 5791047 feat(zeitbloecke): Datenmodell und Schleifenschutz
|
||||
- 9c1c916 feat(zeitbloecke): Schreibweg in den Kalender und Rückweg zurück
|
||||
- bcb4b8e feat(woche): Rasterlogik für die Wochenansicht
|
||||
- fada445 feat(woche): Wochenansicht mit Ziehen und Ablegen
|
||||
- 5b1e998 test: Wochenansicht und Ausplanen absichern
|
||||
- 0974695 docs: Handbuchseite zur Wochenplanung
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -2,3 +2,8 @@ datum;start;ende;minuten;meilenstein;art;notiz
|
||||
2026-09-10;12:06;14:47;161;M1;claude;M1 Fundament fertiggestellt
|
||||
2026-09-10;15:57;16:41;44;M2;claude;M2 Aufgaben und Projekte fertig
|
||||
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
|
||||
2026-09-12;10:15;01:01;886;M7;claude;M7 Schnellerfassung und API fertig
|
||||
2026-09-13;14:10;15:19;69;M8;claude;M8 MCP fertig
|
||||
|
||||
|
@@ -57,5 +57,21 @@ services:
|
||||
WEBAUTHN_RP_NAME: Planer
|
||||
WEBAUTHN_ORIGIN: http://127.0.0.1:${SCREENSHOT_APP_PORT:-3200}
|
||||
DEMO_MODUS: 'true'
|
||||
# Damit die Karte "Benachrichtigungen" den Normalfall zeigt und nicht
|
||||
# den Hinweis, dass nichts eingerichtet ist. Das Schluesselpaar erzeugt
|
||||
# scripts/screenshots.ts fuer jeden Lauf neu – es steht bewusst nirgends
|
||||
# im Verzeichnis.
|
||||
VAPID_OEFFENTLICH: ${SCREENSHOT_VAPID_OEFFENTLICH:-}
|
||||
VAPID_PRIVAT: ${SCREENSHOT_VAPID_PRIVAT:-}
|
||||
VAPID_KONTAKT: mailto:planer@planer.invalid
|
||||
# Ein Host, den es nie geben wird: die Oberflaeche zeigt E-Mail als
|
||||
# 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'
|
||||
|
||||
+158
@@ -0,0 +1,158 @@
|
||||
# Öffentliche Schnittstelle
|
||||
|
||||
Für fremde Anwendungen, Skripte und Automaten. Wer den Planer selbst bedient,
|
||||
braucht sie nicht.
|
||||
|
||||
Basisadresse: `<APP_URL>/api/v1`
|
||||
|
||||
## Ausweisen
|
||||
|
||||
Jede Anfrage trägt einen Token:
|
||||
|
||||
```bash
|
||||
curl -H "Authorization: Bearer planer_ab12cd34_…" \
|
||||
https://planer.example.de/api/v1/selbst
|
||||
```
|
||||
|
||||
Alternativ `X-Planer-Token: planer_…`, falls das Werkzeug keine
|
||||
Authorization-Kopfzeile kann.
|
||||
|
||||
Tokens legst du in der Anwendung unter **API** an (nur Verwaltung). Der Wert
|
||||
erscheint **einmal**; danach liegt in der Datenbank nur sein Fingerabdruck.
|
||||
Wer ihn verliert, legt einen neuen an.
|
||||
|
||||
## Rechte
|
||||
|
||||
Drei Stück, und **keines schließt ein anderes ein**:
|
||||
|
||||
| Recht | Was damit geht |
|
||||
| ----------- | -------------------------------------- |
|
||||
| `lesen` | Aufgaben abfragen |
|
||||
| `erfassen` | Neue Aufgaben anlegen — mehr nicht |
|
||||
| `schreiben` | Bestehende Aufgaben ändern und abhaken |
|
||||
|
||||
Ein Dienst, der nur meldet „hier ist etwas Neues", bekommt `erfassen` und
|
||||
sonst nichts. Das ist der häufigste Fall und der, bei dem ein mitgelesener
|
||||
Token am wenigsten anrichtet.
|
||||
|
||||
## Fehler
|
||||
|
||||
| Status | Bedeutung |
|
||||
| ------ | ----------------------------------------------------------- |
|
||||
| 400 | Die Anfrage war fehlerhaft (Feldliste steht in der Antwort) |
|
||||
| 401 | Kein gültiger Token |
|
||||
| 403 | Dieser Token darf das nicht |
|
||||
| 404 | Gibt es nicht |
|
||||
|
||||
401 sieht immer gleich aus — ob ein Token unbekannt, abgelaufen oder
|
||||
zurückgezogen ist, verrät die Schnittstelle nicht. Von außen soll sich nicht
|
||||
abfragen lassen, welche Tokens es gibt.
|
||||
|
||||
## Endpunkte
|
||||
|
||||
### `GET /selbst`
|
||||
|
||||
Wer bin ich, was darf ich? Braucht **kein** Recht — sonst müsste man raten,
|
||||
ob der Token falsch ist oder nur zu wenig darf.
|
||||
|
||||
```json
|
||||
{ "name": "Wartungsplaner-Import", "rechte": ["erfassen"] }
|
||||
```
|
||||
|
||||
### `GET /aufgaben` · Recht `lesen`
|
||||
|
||||
| Parameter | Standard | Bedeutung |
|
||||
| --------- | -------- | ------------------- |
|
||||
| `grenze` | 25 | Höchstens 100 |
|
||||
| `versatz` | 0 | Zum Blättern |
|
||||
| `offen` | — | `true` oder `false` |
|
||||
|
||||
```json
|
||||
{
|
||||
"aufgaben": [
|
||||
{
|
||||
"id": "clx…",
|
||||
"titel": "#4711 Drucker klemmt",
|
||||
"notiz": null,
|
||||
"status": "OFFEN",
|
||||
"prioritaet": 3,
|
||||
"aufwandMinuten": null,
|
||||
"faelligAm": null,
|
||||
"quelle": "API",
|
||||
"ref": "ticket-4711",
|
||||
"url": "https://…",
|
||||
"erstelltAm": "2026-03-17T08:20:00.000Z",
|
||||
"bereich": null,
|
||||
"projekt": null
|
||||
}
|
||||
],
|
||||
"gesamt": 42,
|
||||
"grenze": 25,
|
||||
"versatz": 0
|
||||
}
|
||||
```
|
||||
|
||||
### `POST /aufgaben` · Recht `erfassen`
|
||||
|
||||
```bash
|
||||
curl -X POST https://planer.example.de/api/v1/aufgaben \
|
||||
-H "Authorization: Bearer planer_…" \
|
||||
-H "Content-Type: application/json" \
|
||||
-d '{"titel":"Drucker klemmt","ref":"ticket-4711"}'
|
||||
```
|
||||
|
||||
| Feld | Pflicht | Bemerkung |
|
||||
| ---------------- | ------- | ----------------------------------- |
|
||||
| `titel` | ja | bis 200 Zeichen |
|
||||
| `notiz` | nein | bis 4000 Zeichen |
|
||||
| `ref` | nein | Kennung beim Aufrufer — siehe unten |
|
||||
| `url` | nein | Verweis ins Ursprungssystem |
|
||||
| `faelligAm` | nein | `JJJJ-MM-TT` |
|
||||
| `prioritaet` | nein | 1 (dringend) bis 5 (irgendwann) |
|
||||
| `aufwandMinuten` | nein | 1 bis 1440 |
|
||||
|
||||
Antwort: `201` mit der angelegten Aufgabe.
|
||||
|
||||
**`ref` macht den Aufruf wiederholbar.** Zweimal dieselbe Kennung ergibt
|
||||
**eine** Aufgabe, nicht zwei — der zweite Aufruf frischt Titel, Notiz und
|
||||
Verweis auf. Ohne `ref` entsteht jedes Mal eine neue Aufgabe; dann hast du es
|
||||
so gewollt.
|
||||
|
||||
Benutze `ref`, wann immer es drüben eine stabile Kennung gibt. Das ist der
|
||||
Unterschied zwischen einer Schnittstelle, die man nach einem Netzhänger
|
||||
gefahrlos wiederholen kann, und einer, die dabei Karteileichen anlegt.
|
||||
|
||||
### `GET /aufgaben/<id>` · Recht `lesen`
|
||||
|
||||
### `PATCH /aufgaben/<id>` · Recht `schreiben`
|
||||
|
||||
```bash
|
||||
curl -X PATCH https://planer.example.de/api/v1/aufgaben/clx… \
|
||||
-H "Authorization: Bearer planer_…" \
|
||||
-H "Content-Type: application/json" \
|
||||
-d '{"erledigt":true}'
|
||||
```
|
||||
|
||||
Änderbar sind `titel`, `notiz`, `faelligAm`, `prioritaet`, `aufwandMinuten`
|
||||
und `erledigt`. Mindestens ein Feld muss dabei sein.
|
||||
|
||||
## Was die Schnittstelle bewusst **nicht** kann
|
||||
|
||||
- **Bereich und Projekt setzen.** Was von außen kommt, landet in der Inbox.
|
||||
Die Einordnung ist Sache dessen, der plant, nicht dessen, der meldet —
|
||||
sonst räumt ein fremder Dienst die eigene Ordnung um.
|
||||
- **Aufgaben löschen.** Abhaken ja, löschen nein. Ein Fehler im fremden
|
||||
Skript soll keine Planung vernichten.
|
||||
- **Zeitblöcke, Bereiche, Projekte oder Kalender anfassen.**
|
||||
|
||||
Fehlt dir etwas davon, ist das eine Entscheidung und kein Versehen — sag
|
||||
Bescheid, dann wird darüber geredet.
|
||||
|
||||
## Protokoll
|
||||
|
||||
Jede **schreibende** Nutzung landet im Protokoll, mit dem Token, über den sie
|
||||
kam. Lesen nicht: Ein Dienst, der im Minutentakt abfragt, würde das Protokoll
|
||||
unbrauchbar machen.
|
||||
|
||||
Auch ein abgewiesener Zugriff wird vermerkt. Ein Dienst, der immer wieder an
|
||||
dieselbe Wand läuft, ist entweder falsch eingerichtet oder versucht etwas.
|
||||
+83
@@ -0,0 +1,83 @@
|
||||
# MCP-Server
|
||||
|
||||
Der Planer spricht das Model Context Protocol. Damit kann ein Sprachmodell
|
||||
Aufgaben suchen, anlegen, abhaken und einplanen — mit denselben Tokens und
|
||||
denselben Rechten wie die [Schnittstelle](API.md).
|
||||
|
||||
Adresse: `<APP_URL>/api/mcp`
|
||||
|
||||
## Einrichten
|
||||
|
||||
1. In der Anwendung unter **API** einen Token anlegen. Gib ihm nur, was das
|
||||
Modell wirklich braucht.
|
||||
2. Den Client auf die Adresse zeigen lassen, mit dem Token als Bearer.
|
||||
|
||||
Für Claude Code:
|
||||
|
||||
```bash
|
||||
claude mcp add planer --transport http https://planer.example.de/api/mcp \
|
||||
--header "Authorization: Bearer planer_…"
|
||||
```
|
||||
|
||||
Für Clients, die nur stdio können, dazwischen `mcp-remote` setzen:
|
||||
|
||||
```json
|
||||
{
|
||||
"mcpServers": {
|
||||
"planer": {
|
||||
"command": "npx",
|
||||
"args": [
|
||||
"-y",
|
||||
"mcp-remote",
|
||||
"https://planer.example.de/api/mcp",
|
||||
"--header",
|
||||
"Authorization: Bearer planer_…"
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Werkzeuge
|
||||
|
||||
Welche ein Modell zu sehen bekommt, hängt am Token. Was nicht erlaubt ist,
|
||||
taucht gar nicht erst in der Liste auf — ein Modell soll nicht gegen eine Tür
|
||||
laufen, die für es verschlossen ist.
|
||||
|
||||
| Werkzeug | Recht | Was es tut |
|
||||
| -------------------- | ----------- | ----------------------------------------------- |
|
||||
| `aufgaben_suchen` | `lesen` | Aufgaben auflisten, optional gefiltert |
|
||||
| `woche_ansehen` | `lesen` | Zeitblöcke einer Woche mit Summe |
|
||||
| `kalender_auflisten` | `lesen` | Verbundene Kalender samt Kennung |
|
||||
| `aufgabe_anlegen` | `erfassen` | Neue Aufgabe in der Inbox |
|
||||
| `aufgabe_abhaken` | `schreiben` | Aufgabe auf erledigt setzen |
|
||||
| `zeitblock_anlegen` | `schreiben` | Aufgabe einplanen und in den Kalender schreiben |
|
||||
|
||||
Zum Einplanen braucht es die Kennung eines Kalenderkontos — daher erst
|
||||
`kalender_auflisten`, dann `zeitblock_anlegen`.
|
||||
|
||||
`zeitblock_anlegen` geht durch dieselbe Stelle wie das Ziehen in der
|
||||
Wochenansicht: Rasterprüfung, Kalenderschreibweg, Schleifenschutz, Protokoll.
|
||||
Ein über MCP angelegter Zeitblock verhält sich also genau wie ein von Hand
|
||||
gezogener.
|
||||
|
||||
## Was der Server bewusst **nicht** kann
|
||||
|
||||
- **Löschen.** Weder Aufgaben noch Zeitblöcke. Abhaken ja, wegräumen nein.
|
||||
- **Bereich oder Projekt setzen.** Was hier entsteht, landet in der Inbox.
|
||||
- **Bereiche, Projekte oder Kalenderkonten anlegen und ändern.**
|
||||
- **Einstellungen oder Tokens anfassen.**
|
||||
|
||||
Ein Modell soll den Alltag erleichtern, nicht die Ordnung umbauen.
|
||||
|
||||
## Protokoll
|
||||
|
||||
Jede schreibende Nutzung landet im Protokoll — mit dem Vermerk, dass sie über
|
||||
MCP kam, und mit dem Token. Ein Modell, das Aufgaben anlegt, muss genauso
|
||||
nachvollziehbar sein wie ein Mensch. Eher noch mehr.
|
||||
|
||||
## Ohne Sitzungen
|
||||
|
||||
Der Server ist zustandslos: Jede Anfrage steht für sich. Der Planer hat keine
|
||||
langlaufenden Vorgänge, und eine Sitzungsverwaltung wäre Zustand, den mehrere
|
||||
Container nicht teilen könnten.
|
||||
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.
|
After Width: | Height: | Size: 125 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 144 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 128 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 146 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 264 KiB After Width: | Height: | Size: 266 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 279 KiB After Width: | Height: | Size: 278 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 269 KiB After Width: | Height: | Size: 271 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 286 KiB After Width: | Height: | Size: 285 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 176 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 164 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 180 KiB |
Binary file not shown.
|
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: 232 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: 236 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 100 KiB After Width: | Height: | Size: 277 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 120 KiB After Width: | Height: | Size: 288 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 103 KiB After Width: | Height: | Size: 286 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 123 KiB After Width: | Height: | Size: 295 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 48 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 70 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 48 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 70 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 111 KiB After Width: | Height: | Size: 110 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 132 KiB After Width: | Height: | Size: 128 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 113 KiB After Width: | Height: | Size: 112 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 134 KiB After Width: | Height: | Size: 131 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 101 KiB After Width: | Height: | Size: 100 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 122 KiB After Width: | Height: | Size: 118 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 103 KiB After Width: | Height: | Size: 102 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 124 KiB After Width: | Height: | Size: 121 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 203 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 209 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 210 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 215 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: 148 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 139 KiB After Width: | Height: | Size: 138 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 155 KiB After Width: | Height: | Size: 152 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: 94 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: 96 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: 119 KiB After Width: | Height: | Size: 116 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 69 KiB After Width: | Height: | Size: 68 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 121 KiB After Width: | Height: | Size: 118 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 225 KiB After Width: | Height: | Size: 228 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: 231 KiB After Width: | Height: | Size: 234 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 240 KiB After Width: | Height: | Size: 240 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 291 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 350 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 288 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 350 KiB |
+14
-18
@@ -13,31 +13,27 @@ Anleitung für den Alltag mit dem Planer. Eine Seite je Thema.
|
||||
|
||||
3. **[Aufgaben erfassen und wiederfinden](aufgaben.md)** – Schnellerfassung,
|
||||
Inbox leeren, Filter, Status und Fälligkeit
|
||||
4. **[Ideen](ideen.md)** – festhalten, was noch keine Aufgabe ist
|
||||
5. **[Projekte](projekte.md)** – mehrere Aufgaben unter einem Ziel, mit
|
||||
4. **[Schnellerfassung vom Handy](erfassen.md)** – als App ablegen, auch
|
||||
ohne Netz erfassen
|
||||
5. **[Ideen](ideen.md)** – festhalten, was noch keine Aufgabe ist
|
||||
6. **[Projekte](projekte.md)** – mehrere Aufgaben unter einem Ziel, mit
|
||||
Fortschritt
|
||||
6. **[Kalenderkonten](kalenderkonten.md)** – Microsoft 365 und Google
|
||||
7. **[Kalenderkonten](kalenderkonten.md)** – Microsoft 365 und Google
|
||||
verbinden, Belegung verstehen
|
||||
8. **[Wochenplanung](woche.md)** – Aufgaben per Ziehen und Ablegen in den
|
||||
Kalender legen
|
||||
9. **[Benachrichtigungen](benachrichtigungen.md)** – Push, E-Mail und
|
||||
Telegram einrichten, Ruhezeiten setzen
|
||||
10. **[Integrationen](integrationen.md)** – Zammad, Telegram und der Spiegel
|
||||
zwischen Firma und Daheim
|
||||
|
||||
## Verwaltung
|
||||
|
||||
7. **[Protokoll](protokoll.md)** – nachsehen, wer wann was geändert hat
|
||||
|
||||
## Was noch kommt
|
||||
|
||||
Diese Seiten entstehen mit den nächsten Meilensteinen:
|
||||
|
||||
| Thema | Meilenstein |
|
||||
| ------------------------------- | ----------- |
|
||||
| Wochenplanung und Zeitblöcke | M4 |
|
||||
| Benachrichtigungen | M5 |
|
||||
| Integrationen | M6 |
|
||||
| Schnellerfassung vom Handy, API | M7 |
|
||||
| MCP | M8 |
|
||||
|
||||
Der [Fahrplan](../../ROADMAP.md) sagt, was in welchem Meilenstein steckt.
|
||||
11. **[Protokoll](protokoll.md)** – nachsehen, wer wann was geändert hat
|
||||
|
||||
---
|
||||
|
||||
Für fremde Anwendungen und Skripte: [Schnittstelle](../API.md).
|
||||
Für Sprachmodelle: [MCP-Server](../MCP.md).
|
||||
Zur Einrichtung einer neuen Instanz: [Schnellstart](../SCHNELLSTART.md).
|
||||
Für Betrieb, Sicherung und alle Umgebungsvariablen: [README](../../README.md).
|
||||
|
||||
@@ -0,0 +1,108 @@
|
||||
# Benachrichtigungen
|
||||
|
||||
Ab Werk meldet der Planer **gar nichts**. Das ist Absicht: Eine Anwendung,
|
||||
die zu oft meldet, wird stummgeschaltet — und dann verpasst du auch das
|
||||
Wichtige. Was du hier einschaltest, kommt. Alles andere nicht.
|
||||
|
||||
|
||||
|
||||
_Der Browser auf dem Bild hat Benachrichtigungen blockiert — so sieht die
|
||||
Karte aus, wenn die Erlaubnis fehlt. Wie du sie erteilst, steht weiter unten._
|
||||
|
||||
Du findest die Einstellung unter **Einstellungen → Benachrichtigungen**.
|
||||
|
||||
## Die zwei Wege
|
||||
|
||||
| | Web-Push | E-Mail |
|
||||
| --------- | ---------------------------------------- | ---------------------------------------- |
|
||||
| Kommt an | als Systemmeldung auf dem Gerät | im Postfach |
|
||||
| Braucht | Erlaubnis des Browsers, je Gerät einzeln | nichts weiter |
|
||||
| Gut für | „gleich beginnt ein Zeitblock" | den Tagesüberblick am Morgen |
|
||||
| Fällt aus | wenn der Browser die Erlaubnis entzieht | wenn der Mailserver nicht erreichbar ist |
|
||||
|
||||
Beide Wege lassen sich gleichzeitig einschalten. Dann kommt jede Meldung
|
||||
über beide — der Planer verschickt sie trotzdem nur **einmal je Anlass**.
|
||||
|
||||
Ist ein Weg auf dem Server nicht eingerichtet, steht das direkt daneben.
|
||||
Was dafür nötig ist, steht im [README](../../README.md), Abschnitt
|
||||
_Benachrichtigungen_.
|
||||
|
||||
## Push auf einem Gerät einschalten
|
||||
|
||||
1. Auf **Anmelden** klicken.
|
||||
2. Der Browser fragt nach Erlaubnis — **Zulassen**.
|
||||
3. Das Gerät erscheint in der Liste darunter.
|
||||
|
||||
Das gilt **je Gerät und je Browser**. Der Rechner im Büro und das Handy
|
||||
sind zwei Anmeldungen; Firefox und Chrome auf demselben Rechner ebenfalls.
|
||||
|
||||
> **Der Knopf fehlt oder ist grau?** Push braucht HTTPS. Unter
|
||||
> `http://localhost` geht es zum Entwickeln, unter jeder anderen
|
||||
> Klartextadresse nicht. Hat der Browser Benachrichtigungen einmal
|
||||
> blockiert, lässt sich das nur in seinen eigenen Einstellungen
|
||||
> zurücknehmen — die Anwendung darf dann nicht mehr fragen.
|
||||
|
||||
Ein Gerät, das der Push-Dienst dauerhaft ablehnt, entfernt der Planer von
|
||||
selbst aus der Liste. Du musst nichts aufräumen.
|
||||
|
||||
## Was gemeldet wird
|
||||
|
||||
| Anlass | Wann |
|
||||
| ---------------------------------------- | ------------------------------------------------------------------------ |
|
||||
| **Tagesüberblick** | einmal morgens zur eingestellten Zeit |
|
||||
| **Fällige Aufgaben** | wenn eine Aufgabe an diesem Tag fällig wird, höchstens einmal je Aufgabe |
|
||||
| **Gleich beginnt ein Zeitblock** | kurz vor dem Beginn, Vorlauf einstellbar |
|
||||
| **Kalender lässt sich nicht abgleichen** | erst nach dem dritten Fehlversuch hintereinander |
|
||||
|
||||
Eingeschaltet sind anfangs nur Tagesüberblick und fällige Aufgaben — und
|
||||
selbst die kommen erst, wenn du einen Weg (Push oder E-Mail) aktiviert hast.
|
||||
|
||||
Der **Tagesüberblick** entfällt an Tagen, an denen es nichts zu sagen gibt.
|
||||
Eine Meldung „heute steht nichts an" ist keine Information, sondern Lärm.
|
||||
|
||||
Der **Abgleichfehler** kommt bewusst spät: Ein Netz hustet, ein Anbieter hat
|
||||
Wartung. Erst wenn es dreimal hintereinander nicht klappt, ist es eine
|
||||
Nachricht wert — dann allerdings dringend, denn solange bleibt deine
|
||||
Wochenansicht auf einem alten Stand.
|
||||
|
||||
## Ruhezeit
|
||||
|
||||
Voreingestellt ist **20:00 bis 07:00**. In diesem Fenster kommt nichts.
|
||||
|
||||
- Die Ruhezeit läuft über Mitternacht hinweg — das ist der Normalfall.
|
||||
- Gleiche Start- und Endzeit heißt: **keine** Ruhezeit.
|
||||
- **Am Wochenende still** legt Samstag und Sonntag komplett still.
|
||||
|
||||
Eine Ausnahme: Der **Tagesüberblick** kommt zu seiner festen Zeit, auch wenn
|
||||
die noch in der Ruhezeit liegt. Wer ihn auf 06:00 stellt, steht um 06:00 auf
|
||||
und will ihn dann auch haben.
|
||||
|
||||
Was in der Ruhezeit anfällt, wird **nicht nachgeholt**. Eine Erinnerung an
|
||||
einen Zeitblock, der längst begonnen hat, hilft niemandem.
|
||||
|
||||
## Ausprobieren
|
||||
|
||||
Der Knopf **Probe senden** schickt eine Testmeldung über alle
|
||||
eingeschalteten Wege — er umgeht Ruhezeit und Wiederholungssperre. Wer
|
||||
darauf drückt, will jetzt wissen, ob es ankommt.
|
||||
|
||||
Die Rückmeldung sagt, was passiert ist: an wie viele Geräte der Push ging,
|
||||
ob die Mail hinausging. Kommt „kein Gerät für Push angemeldet", fehlt die
|
||||
Anmeldung dieses Browsers.
|
||||
|
||||
## Wenn nichts ankommt
|
||||
|
||||
| Symptom | Ursache |
|
||||
| ----------------------------------------- | ----------------------------------------------------------------- |
|
||||
| Probe sagt „verschickt", nichts kommt an | Betriebssystem blendet Browsermeldungen aus (Fokus, Nicht stören) |
|
||||
| Gerät verschwindet immer wieder | Der Push-Dienst lehnt das Abo ab — neu anmelden |
|
||||
| Gar nichts, seit der Server umgezogen ist | Neues Schlüsselpaar auf dem Server. Alle Geräte neu anmelden |
|
||||
| Mail fehlt, Push kommt | SMTP prüfen; Fehler stehen im Serverprotokoll |
|
||||
|
||||
Der Planer prüft alle zehn Minuten, ob etwas zu melden ist. Eine Erinnerung
|
||||
kann also ein paar Minuten vor der eingestellten Zeit kommen — nie danach.
|
||||
|
||||
---
|
||||
|
||||
Weiter zur [Wochenplanung](woche.md) oder zurück zum
|
||||
[Handbuch](README.md).
|
||||
@@ -0,0 +1,61 @@
|
||||
# Schnellerfassung vom Handy
|
||||
|
||||
Die Seite **Erfassen** ist für den Moment gemacht, in dem dir etwas einfällt
|
||||
und du keine Zeit hast, es einzusortieren: ein Feld, ein Knopf, fertig.
|
||||
|
||||
|
||||
|
||||
Alles, was hier hereinkommt, landet in der **Inbox** — ohne Bereich, ohne
|
||||
Termin. Das Einsortieren passiert später am Rechner, wenn Ruhe dafür ist.
|
||||
|
||||
## Als Anwendung ablegen
|
||||
|
||||
Der Planer lässt sich auf dem Startbildschirm ablegen und verhält sich dann
|
||||
wie eine App: eigenes Symbol, kein Browserrahmen, direkt auf dieser Seite.
|
||||
|
||||
| Gerät | Weg |
|
||||
| --------------------- | -------------------------------------------- |
|
||||
| Android (Chrome) | Menü ⋮ → **App installieren** |
|
||||
| iPhone (Safari) | Teilen-Symbol → **Zum Home-Bildschirm** |
|
||||
| Rechner (Chrome/Edge) | Symbol in der Adresszeile → **Installieren** |
|
||||
|
||||
## Ohne Netz
|
||||
|
||||
**Das ist der eigentliche Punkt dieser Seite.** Im Keller, im Aufzug, im Zug
|
||||
zwischen zwei Funkzellen: Erfasst wird trotzdem.
|
||||
|
||||
Was passiert:
|
||||
|
||||
1. Das Erfasste wird **zuerst im Gerät gemerkt**, dann verschickt. Nicht
|
||||
andersherum — sonst wäre es weg, wenn du den Browser mitten im Senden
|
||||
schließt.
|
||||
2. Ohne Netz bleibt es liegen und steht unter dem Feld als „wartet".
|
||||
3. Sobald wieder Netz da ist, geht es von selbst hinaus. Du bekommst eine
|
||||
kurze Rückmeldung.
|
||||
|
||||
Der Knopf **Jetzt versuchen** stößt das von Hand an, wenn du nicht warten
|
||||
magst.
|
||||
|
||||
> **Geht dabei etwas verloren?** Nein. Jede Erfassung bekommt eine eigene
|
||||
> Kennung, die mitgeschickt wird. Kommt dieselbe Nachricht zweimal an — weil
|
||||
> die Verbindung beim ersten Versuch abbrach, die Anfrage aber trotzdem
|
||||
> durchging —, entsteht trotzdem nur **eine** Aufgabe.
|
||||
|
||||
Die Warteschlange liegt in der Datenbank des Browsers, nicht im flüchtigen
|
||||
Speicher. Sie übersteht das Schließen des Tabs und einen Neustart des
|
||||
Geräts.
|
||||
|
||||
Damit die Seite ohne Netz überhaupt aufgeht, hält der Planer genau **diese
|
||||
eine Seite** vor. Alle anderen Seiten holt er immer frisch: Ein halb
|
||||
veralteter Planer wäre schlimmer als gar keiner — ein leeres Eingabefeld
|
||||
dagegen veraltet nicht.
|
||||
|
||||
## Warum nicht die Erfassung auf der Startseite?
|
||||
|
||||
Die gibt es weiterhin, und sie ist am Rechner meist der kürzere Weg. Der
|
||||
Unterschied ist die Verlässlichkeit: Die Schnellerfassung ist die einzige
|
||||
Stelle, die ohne Netz nichts verliert.
|
||||
|
||||
---
|
||||
|
||||
Weiter zur [Inbox](aufgaben.md) oder zurück zum [Handbuch](README.md).
|
||||
@@ -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).
|
||||
@@ -0,0 +1,106 @@
|
||||
# Wochenplanung und Zeitblöcke
|
||||
|
||||
Hier wird aus einer Aufgabe ein Termin. Du ziehst sie in ein Zeitfenster, und
|
||||
der Planer legt sie als **Zeitblock** in deinen echten Kalender.
|
||||
|
||||
|
||||
|
||||
## Der Aufbau
|
||||
|
||||
| Wo | Was |
|
||||
| --------------------- | ------------------------------------------------------------------------------------------------------------- |
|
||||
| **Links** | Alles, was noch eingeplant werden kann — offen, geplant oder wartend. Ideen bleiben draußen |
|
||||
| **Rechts** | Sieben Tage im Viertelstundenraster |
|
||||
| **Über jeder Spalte** | Belegte Zeit gegen die Kapazität dieses Tages |
|
||||
| **Graue Balken** | Termine aus deinem Kalender. Sie gehören dem Kalender, nicht dem Planer — hier lassen sie sich nicht anfassen |
|
||||
| **Farbige Balken** | Deine Zeitblöcke, in der Farbe ihres Bereichs |
|
||||
|
||||
Das sichtbare Stundenfenster ergibt sich aus den Arbeitsfenstern **aller**
|
||||
Bereiche, mit einer Stunde Luft nach oben und unten.
|
||||
|
||||
## Eine Aufgabe einplanen
|
||||
|
||||
Aufgabe links am Griff packen und in ein Zeitfenster ziehen. Fertig — der
|
||||
Zeitblock steht sofort im Raster und wenige Augenblicke später in deinem
|
||||
Kalender.
|
||||
|
||||
> **Die Dauer kommt aus dem geschätzten Aufwand.** Wer bei der Aufgabe
|
||||
> „90 Minuten" einträgt, bekommt einen 90-Minuten-Block. Ohne Schätzung sind
|
||||
> es 60 Minuten, die du danach anpassen kannst.
|
||||
|
||||
Eine eingeplante Aufgabe wechselt automatisch von _Offen_ auf _Geplant_.
|
||||
|
||||
## Verschieben
|
||||
|
||||
Am Griff im Block packen und woandershin ziehen. Der Planer zieht den
|
||||
Kalendertermin nach.
|
||||
|
||||
## Ausplanen
|
||||
|
||||
Das Kreuz im Block. Der Termin verschwindet aus dem Kalender; die Aufgabe
|
||||
bleibt und fällt zurück auf _Offen_, wenn nichts anderes mehr für sie geplant
|
||||
ist.
|
||||
|
||||
## Wenn du im Kalender verschiebst
|
||||
|
||||
Das darfst du — und der Planer zieht nach. Beim nächsten Abgleich (spätestens
|
||||
nach 15 Minuten) steht der Block dort, wo du ihn im Kalender hingelegt hast.
|
||||
|
||||
> **Der Kalender gewinnt.** Immer. Wer dort etwas verschiebt, meint es so;
|
||||
> säße der Planer am längeren Hebel, würde er dir den Termin wieder wegziehen
|
||||
> und du wüsstest nicht, warum.
|
||||
>
|
||||
> Löschst du den Termin im Kalender, verschwindet auch der Zeitblock. Die
|
||||
> Aufgabe selbst bleibt.
|
||||
|
||||
### Warum sich das nicht aufschaukelt
|
||||
|
||||
Der Planer merkt sich zu jedem Zeitblock einen Fingerabdruck des Zeitraums,
|
||||
den er zuletzt geschrieben hat. Findet er beim Abgleich genau diesen
|
||||
Fingerabdruck wieder, war es seine eigene Änderung — er tut nichts. Weicht er
|
||||
ab, hat jemand anderes verschoben.
|
||||
|
||||
Ohne diesen Kniff würden App und Kalender einander endlos hinterherschreiben.
|
||||
|
||||
## Das Warnzeichen im Block
|
||||
|
||||
Ein kleines Dreieck heißt: **noch nicht im Kalender**. Meist war der Anbieter
|
||||
gerade nicht erreichbar.
|
||||
|
||||
Der Zeitblock bleibt trotzdem stehen — deine Planung soll nicht verlorengehen,
|
||||
bloß weil ein Server hustet. Verschiebe den Block einmal, dann trägt der
|
||||
Planer ihn nach.
|
||||
|
||||
## Die Zahl über der Spalte
|
||||
|
||||
`3 h / 6 h` heißt: sechs Stunden Kapazität an diesem Tag, drei davon schon
|
||||
belegt. Gezählt werden Kalendertermine **und** deine Zeitblöcke.
|
||||
|
||||
Wird die Zahl rot, ist der Tag überbucht. Das ist keine Sperre — der Planer
|
||||
lässt dich weiterplanen. Es ist ein Hinweis, dass der Tag nicht aufgeht.
|
||||
|
||||
Ganztägige Termine zählen nicht mit. Ein Urlaubstag im Kalender blockiert
|
||||
sonst rechnerisch den ganzen Tag, obwohl er gar keine Arbeitszeit kostet.
|
||||
|
||||
## Blättern
|
||||
|
||||
**Zurück**, **Diese Woche** und **Weiter**. Die Woche steht in der Adresse —
|
||||
eine bestimmte Woche lässt sich also als Lesezeichen ablegen.
|
||||
|
||||
## Wenn es klemmt
|
||||
|
||||
| Was du siehst | Was dahintersteckt |
|
||||
| -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| „Ohne verbundenen Kalender lässt sich nichts einplanen." | Erst unter [Kalender](kalenderkonten.md) ein Konto verbinden |
|
||||
| „Eingeplant, aber nicht in den Kalender geschrieben" | Der Anbieter war nicht erreichbar. Der Block steht, verschiebe ihn einmal zum Nachtragen |
|
||||
| „Der Termin wurde inzwischen im Kalender geändert." | Jemand war schneller. Der Kalender gewinnt; der nächste Abgleich holt den dortigen Stand |
|
||||
| „Zeitblöcke rasten in 15-Minuten-Schritten ein." | Das Raster ist Absicht. Genauer zu planen bringt nichts |
|
||||
| Ein Block ist nicht zu sehen | Er liegt außerhalb des sichtbaren Stundenfensters. Das Fenster folgt den Arbeitsfenstern der Bereiche — siehe [Bereiche](bereiche.md) |
|
||||
|
||||
## Was noch nicht geht
|
||||
|
||||
- **Ein Zeitblock landet immer im ersten verbundenen Kalender.** Die Auswahl
|
||||
je Bereich ist im Datenmodell vorbereitet, aber noch nicht in der
|
||||
Oberfläche.
|
||||
- **Die Dauer lässt sich nicht am Balken ziehen.** Wer eine andere Dauer will,
|
||||
ändert den Aufwand der Aufgabe und plant neu ein.
|
||||
@@ -50,7 +50,11 @@ test.describe('Anmeldung', () => {
|
||||
await page.getByRole('button', { name: 'Mit Passwort anmelden' }).click()
|
||||
|
||||
await expect(page.getByRole('heading', { name: /Guten Tag/ })).toBeVisible()
|
||||
// exact, weil die Startseite zusätzlich einen Link "Bereiche verwalten" hat.
|
||||
// Alltagspunkte stehen in der Leiste, Einrichtung liegt hinter "Mehr".
|
||||
await expect(page.getByRole('link', { name: 'Aufgaben', exact: true })).toBeVisible()
|
||||
await expect(page.getByRole('link', { name: 'Bereiche', exact: true })).toBeHidden()
|
||||
|
||||
await page.getByText('Mehr', { exact: true }).click()
|
||||
await expect(page.getByRole('link', { name: 'Bereiche', exact: true })).toBeVisible()
|
||||
|
||||
await page.getByTitle('Abmelden').click()
|
||||
@@ -64,6 +68,8 @@ test.describe('Anmeldung', () => {
|
||||
await page.getByRole('button', { name: 'Mit Passwort anmelden' }).click()
|
||||
await expect(page.getByRole('heading', { name: /Guten Tag/ })).toBeVisible()
|
||||
|
||||
// Das Protokoll liegt hinter "Mehr" – aufklappen, dann hin.
|
||||
await page.getByText('Mehr', { exact: true }).click()
|
||||
await page.getByRole('link', { name: 'Protokoll' }).click()
|
||||
await expect(page.getByRole('heading', { name: 'Protokoll' })).toBeVisible()
|
||||
})
|
||||
|
||||
+187
@@ -0,0 +1,187 @@
|
||||
import { createHash, randomBytes } from 'node:crypto'
|
||||
import { PrismaPg } from '@prisma/adapter-pg'
|
||||
import { expect, test } from '@playwright/test'
|
||||
import { PrismaClient } from '../src/generated/prisma/client.js'
|
||||
import { EMAIL, VERBINDUNG } from './hilfe'
|
||||
|
||||
/**
|
||||
* Die öffentliche Schnittstelle.
|
||||
*
|
||||
* Geprüft wird vor allem, was **nicht** geht: ohne Token, mit falschem
|
||||
* Token, mit zu wenig Rechten, mit abgelaufenem oder zurückgezogenem Token.
|
||||
* Der gute Fall ist schnell erzählt — die Tür ist das Interessante.
|
||||
*/
|
||||
|
||||
const db = new PrismaClient({ adapter: new PrismaPg({ connectionString: VERBINDUNG }) })
|
||||
const PRAEFIX = `E2E-API-${Date.now()}`
|
||||
|
||||
/** Legt einen Token direkt in der Datenbank an und gibt den Klartext zurück. */
|
||||
async function tokenBauen(
|
||||
benutzerId: string,
|
||||
rechte: string,
|
||||
zusatz: { gueltigBis?: Date; widerrufenAm?: Date } = {},
|
||||
): Promise<string> {
|
||||
const praefix = randomBytes(4).toString('hex')
|
||||
const klartext = `planer_${praefix}_${randomBytes(32).toString('base64url')}`
|
||||
await db.apiToken.create({
|
||||
data: {
|
||||
benutzerId,
|
||||
name: `${PRAEFIX} ${rechte}`,
|
||||
praefix,
|
||||
hash: createHash('sha256').update(klartext, 'utf8').digest('hex'),
|
||||
rechte,
|
||||
...zusatz,
|
||||
},
|
||||
})
|
||||
return klartext
|
||||
}
|
||||
|
||||
test.describe('API v1', () => {
|
||||
test.skip(!EMAIL || !VERBINDUNG, 'Ohne ADMIN_EMAIL und DATABASE_URL kein Testkonto.')
|
||||
|
||||
let benutzerId = ''
|
||||
|
||||
test.beforeAll(async () => {
|
||||
const benutzer = await db.benutzer.findUniqueOrThrow({ where: { email: EMAIL } })
|
||||
benutzerId = benutzer.id
|
||||
})
|
||||
|
||||
test.afterAll(async () => {
|
||||
await db.aufgabe.deleteMany({ where: { titel: { startsWith: PRAEFIX } } })
|
||||
await db.aufgabe.deleteMany({ where: { quelleRef: { startsWith: PRAEFIX } } })
|
||||
await db.apiToken.deleteMany({ where: { name: { startsWith: PRAEFIX } } })
|
||||
await db.auditEintrag.deleteMany({ where: { aktion: { startsWith: 'api.' } } })
|
||||
await db.$disconnect()
|
||||
})
|
||||
|
||||
test('weist eine Anfrage ohne Token ab', async ({ request }) => {
|
||||
const antwort = await request.get('/api/v1/aufgaben')
|
||||
expect(antwort.status()).toBe(401)
|
||||
// Sagt Werkzeugen, wie sie sich ausweisen sollen.
|
||||
expect(antwort.headers()['www-authenticate']).toBe('Bearer')
|
||||
})
|
||||
|
||||
test('weist einen erfundenen Token ab', async ({ request }) => {
|
||||
const antwort = await request.get('/api/v1/aufgaben', {
|
||||
headers: { Authorization: `Bearer planer_abcdefgh_${'x'.repeat(43)}` },
|
||||
})
|
||||
expect(antwort.status()).toBe(401)
|
||||
})
|
||||
|
||||
test('sagt einem gültigen Token, was er darf', async ({ request }) => {
|
||||
const token = await tokenBauen(benutzerId, 'lesen,erfassen')
|
||||
const antwort = await request.get('/api/v1/selbst', {
|
||||
headers: { Authorization: `Bearer ${token}` },
|
||||
})
|
||||
expect(antwort.ok()).toBe(true)
|
||||
expect(await antwort.json()).toMatchObject({ rechte: ['lesen', 'erfassen'] })
|
||||
})
|
||||
|
||||
test('lässt einen Nur-Lesen-Token nicht erfassen', async ({ request }) => {
|
||||
const token = await tokenBauen(benutzerId, 'lesen')
|
||||
const antwort = await request.post('/api/v1/aufgaben', {
|
||||
headers: { Authorization: `Bearer ${token}` },
|
||||
data: { titel: `${PRAEFIX} darf nicht` },
|
||||
})
|
||||
expect(antwort.status()).toBe(403)
|
||||
expect(await db.aufgabe.count({ where: { titel: `${PRAEFIX} darf nicht` } })).toBe(0)
|
||||
})
|
||||
|
||||
test('lässt einen Nur-Erfassen-Token nicht lesen', async ({ request }) => {
|
||||
// Erfassen schließt Lesen ausdrücklich nicht ein.
|
||||
const token = await tokenBauen(benutzerId, 'erfassen')
|
||||
const antwort = await request.get('/api/v1/aufgaben', {
|
||||
headers: { Authorization: `Bearer ${token}` },
|
||||
})
|
||||
expect(antwort.status()).toBe(403)
|
||||
})
|
||||
|
||||
test('weist einen abgelaufenen Token ab', async ({ request }) => {
|
||||
const token = await tokenBauen(benutzerId, 'lesen', {
|
||||
gueltigBis: new Date(Date.now() - 60_000),
|
||||
})
|
||||
const antwort = await request.get('/api/v1/aufgaben', {
|
||||
headers: { Authorization: `Bearer ${token}` },
|
||||
})
|
||||
expect(antwort.status()).toBe(401)
|
||||
})
|
||||
|
||||
test('weist einen zurückgezogenen Token ab', async ({ request }) => {
|
||||
const token = await tokenBauen(benutzerId, 'lesen', { widerrufenAm: new Date() })
|
||||
const antwort = await request.get('/api/v1/aufgaben', {
|
||||
headers: { Authorization: `Bearer ${token}` },
|
||||
})
|
||||
expect(antwort.status()).toBe(401)
|
||||
})
|
||||
|
||||
test('erfasst, wiederholt sich nicht und ändert', async ({ request }) => {
|
||||
const token = await tokenBauen(benutzerId, 'lesen,erfassen,schreiben')
|
||||
const kopf = { Authorization: `Bearer ${token}` }
|
||||
const ref = `${PRAEFIX}-ref`
|
||||
|
||||
const erste = await request.post('/api/v1/aufgaben', {
|
||||
headers: kopf,
|
||||
data: { titel: `${PRAEFIX} Angebot schreiben`, ref },
|
||||
})
|
||||
expect(erste.status()).toBe(201)
|
||||
const angelegt = (await erste.json()) as { id: string; titel: string }
|
||||
|
||||
// Dasselbe noch einmal: eine Aufgabe, nicht zwei.
|
||||
const zweite = await request.post('/api/v1/aufgaben', {
|
||||
headers: kopf,
|
||||
data: { titel: `${PRAEFIX} Angebot schreiben`, ref },
|
||||
})
|
||||
expect(zweite.ok()).toBe(true)
|
||||
expect(await db.aufgabe.count({ where: { quelle: 'API', quelleRef: ref } })).toBe(1)
|
||||
|
||||
// Abhaken über die Schnittstelle.
|
||||
const geaendert = await request.patch(`/api/v1/aufgaben/${angelegt.id}`, {
|
||||
headers: kopf,
|
||||
data: { erledigt: true },
|
||||
})
|
||||
expect(geaendert.ok()).toBe(true)
|
||||
expect((await geaendert.json()) as { status: string }).toMatchObject({
|
||||
status: 'ERLEDIGT',
|
||||
})
|
||||
|
||||
// Und im Protokoll steht, dass es über die Schnittstelle kam.
|
||||
const protokoll = await db.auditEintrag.findFirst({
|
||||
where: { aktion: 'api.geaendert', objektId: angelegt.id },
|
||||
select: { details: true },
|
||||
})
|
||||
expect(protokoll).not.toBeNull()
|
||||
expect(JSON.stringify(protokoll?.details)).toContain('api')
|
||||
})
|
||||
|
||||
test('lehnt eine Aufgabe ohne Titel ab', async ({ request }) => {
|
||||
const token = await tokenBauen(benutzerId, 'erfassen')
|
||||
const antwort = await request.post('/api/v1/aufgaben', {
|
||||
headers: { Authorization: `Bearer ${token}` },
|
||||
data: { titel: ' ' },
|
||||
})
|
||||
expect(antwort.status()).toBe(400)
|
||||
})
|
||||
|
||||
test('setzt weder Status noch Bereich aus der Anfrage', async ({ request }) => {
|
||||
const token = await tokenBauen(benutzerId, 'erfassen')
|
||||
const bereich = await db.bereich.findFirst({ select: { id: true } })
|
||||
|
||||
const antwort = await request.post('/api/v1/aufgaben', {
|
||||
headers: { Authorization: `Bearer ${token}` },
|
||||
data: {
|
||||
titel: `${PRAEFIX} Einordnung bleibt hier`,
|
||||
status: 'ERLEDIGT',
|
||||
bereichId: bereich?.id ?? null,
|
||||
},
|
||||
})
|
||||
expect(antwort.status()).toBe(201)
|
||||
|
||||
const angelegt = await db.aufgabe.findFirstOrThrow({
|
||||
where: { titel: `${PRAEFIX} Einordnung bleibt hier` },
|
||||
select: { status: true, bereichId: true },
|
||||
})
|
||||
// Was von außen kommt, landet offen in der Inbox.
|
||||
expect(angelegt.status).toBe('OFFEN')
|
||||
expect(angelegt.bereichId).toBeNull()
|
||||
})
|
||||
})
|
||||
+8
-14
@@ -1,6 +1,7 @@
|
||||
import { PrismaPg } from '@prisma/adapter-pg'
|
||||
import { expect, test, type Page } from '@playwright/test'
|
||||
import { expect, test } from '@playwright/test'
|
||||
import { PrismaClient } from '../src/generated/prisma/client.js'
|
||||
import { anmelden, EMAIL, PASSWORT, VERBINDUNG } from './hilfe'
|
||||
|
||||
/**
|
||||
* Der Weg, der in M2 wirklich zählt: erfassen, einsortieren, abhaken.
|
||||
@@ -9,16 +10,13 @@ import { PrismaClient } from '../src/generated/prisma/client.js'
|
||||
* damit die Entwicklungsdatenbank hinterher aussieht wie vorher.
|
||||
*/
|
||||
|
||||
const EMAIL = process.env.ADMIN_EMAIL ?? ''
|
||||
const PASSWORT = process.env.ADMIN_PASSWORT ?? ''
|
||||
const PRAEFIX = `E2E-${Date.now()}`
|
||||
|
||||
const verbindung = process.env.DATABASE_URL ?? ''
|
||||
const db = new PrismaClient({ adapter: new PrismaPg({ connectionString: verbindung }) })
|
||||
const db = new PrismaClient({ adapter: new PrismaPg({ connectionString: VERBINDUNG }) })
|
||||
|
||||
test.describe('Aufgaben', () => {
|
||||
test.skip(
|
||||
!EMAIL || !PASSWORT || !verbindung,
|
||||
!EMAIL || !PASSWORT || !VERBINDUNG,
|
||||
'Ohne ADMIN_EMAIL, ADMIN_PASSWORT und DATABASE_URL gibt es kein Testkonto.',
|
||||
)
|
||||
|
||||
@@ -29,14 +27,6 @@ test.describe('Aufgaben', () => {
|
||||
await db.$disconnect()
|
||||
})
|
||||
|
||||
async function anmelden(seite: Page): Promise<void> {
|
||||
await seite.goto('/anmelden')
|
||||
await seite.getByLabel('E-Mail-Adresse').fill(EMAIL)
|
||||
await seite.getByLabel('Passwort').fill(PASSWORT)
|
||||
await seite.getByRole('button', { name: 'Mit Passwort anmelden' }).click()
|
||||
await expect(seite.getByRole('heading', { name: /Guten Tag/ })).toBeVisible()
|
||||
}
|
||||
|
||||
test('erfasst schnell, sortiert ein und hakt ab', async ({ page }) => {
|
||||
const titel = `${PRAEFIX} Angebot schreiben`
|
||||
await anmelden(page)
|
||||
@@ -62,6 +52,10 @@ test.describe('Aufgaben', () => {
|
||||
await zeile.getByLabel('Einsortieren nach').selectOption(bereich!.id)
|
||||
await expect(page.getByText(`liegt jetzt in ${bereich!.name}`)).toBeVisible()
|
||||
|
||||
// Die Meldung kommt, bevor das Neuladen der Liste fertig ist. Wer jetzt
|
||||
// navigiert, bricht es ab — und Chromium meldet ERR_ABORTED.
|
||||
await page.waitForLoadState('networkidle')
|
||||
|
||||
// Aus der Inbox ist sie damit verschwunden.
|
||||
await page.goto('/inbox')
|
||||
await expect(page.locator('li').filter({ hasText: titel })).toHaveCount(0)
|
||||
|
||||
@@ -0,0 +1,91 @@
|
||||
import { PrismaPg } from '@prisma/adapter-pg'
|
||||
import { expect, test } from '@playwright/test'
|
||||
import { PrismaClient } from '../src/generated/prisma/client.js'
|
||||
import { anmelden, EMAIL, PASSWORT, VERBINDUNG } from './hilfe'
|
||||
|
||||
/**
|
||||
* Was in M5 wirklich zählt: die Einstellung hält, und ohne eingeschalteten
|
||||
* Weg geht nichts hinaus.
|
||||
*
|
||||
* Der Test rührt nur an der Einstellung des Testkontos und stellt sie am
|
||||
* Ende wieder her.
|
||||
*/
|
||||
|
||||
const db = new PrismaClient({ adapter: new PrismaPg({ connectionString: VERBINDUNG }) })
|
||||
|
||||
test.describe('Benachrichtigungen', () => {
|
||||
test.skip(
|
||||
!EMAIL || !PASSWORT || !VERBINDUNG,
|
||||
'Ohne ADMIN_EMAIL, ADMIN_PASSWORT und DATABASE_URL gibt es kein Testkonto.',
|
||||
)
|
||||
|
||||
test.afterAll(async () => {
|
||||
const benutzer = await db.benutzer.findUnique({
|
||||
where: { email: EMAIL },
|
||||
select: { id: true },
|
||||
})
|
||||
if (benutzer) {
|
||||
await db.benachrichtigungseinstellung.deleteMany({
|
||||
where: { benutzerId: benutzer.id },
|
||||
})
|
||||
await db.meldungsnachweis.deleteMany({ where: { benutzerId: benutzer.id } })
|
||||
}
|
||||
await db.auditEintrag.deleteMany({
|
||||
where: { aktion: { startsWith: 'benachrichtigung.' } },
|
||||
})
|
||||
await db.$disconnect()
|
||||
})
|
||||
|
||||
test('speichert die Einstellung und hält sie', async ({ page }) => {
|
||||
await anmelden(page)
|
||||
await page.goto('/einstellungen')
|
||||
|
||||
const karte = page.locator('[data-bild="benachrichtigungen"]')
|
||||
await expect(karte).toBeVisible()
|
||||
|
||||
// --- Ab Werk ist nichts eingeschaltet ---------------------------------
|
||||
await expect(karte.locator('input[name="perPush"]')).not.toBeChecked()
|
||||
await expect(karte.locator('input[name="perMail"]')).not.toBeChecked()
|
||||
|
||||
// --- Ohne Weg keine Probe ---------------------------------------------
|
||||
await karte.getByRole('button', { name: 'Probe schicken' }).click()
|
||||
await expect(page.getByText('Erst einen Weg einschalten')).toBeVisible()
|
||||
|
||||
// --- Ändern und speichern ---------------------------------------------
|
||||
await karte.locator('input[name="perMail"]').check()
|
||||
await karte.locator('input[value="zeitblock"]').check()
|
||||
await karte.getByLabel('Tagesüberblick um').fill('06:30')
|
||||
await karte.getByLabel('Vorlauf vor einem Zeitblock (Minuten)').fill('20')
|
||||
await karte.getByLabel('Am Wochenende gar nichts melden').check()
|
||||
await karte.getByRole('button', { name: 'Speichern' }).click()
|
||||
await expect(page.getByText('Einstellungen gespeichert.')).toBeVisible()
|
||||
|
||||
// --- Nach dem Neuladen steht alles noch da ----------------------------
|
||||
await page.reload()
|
||||
await expect(karte.locator('input[name="perMail"]')).toBeChecked()
|
||||
await expect(karte.locator('input[value="zeitblock"]')).toBeChecked()
|
||||
await expect(karte.getByLabel('Tagesüberblick um')).toHaveValue('06:30')
|
||||
await expect(karte.getByLabel('Vorlauf vor einem Zeitblock (Minuten)')).toHaveValue(
|
||||
'20',
|
||||
)
|
||||
await expect(karte.getByLabel('Am Wochenende gar nichts melden')).toBeChecked()
|
||||
})
|
||||
|
||||
test('weist eine unsinnige Vorlaufzeit zurück', async ({ page }) => {
|
||||
await anmelden(page)
|
||||
await page.goto('/einstellungen')
|
||||
|
||||
const karte = page.locator('[data-bild="benachrichtigungen"]')
|
||||
const vorlauf = karte.getByLabel('Vorlauf vor einem Zeitblock (Minuten)')
|
||||
// Das Zahlenfeld begrenzt auf 120; der Server darf sich darauf nicht
|
||||
// verlassen, deshalb kommt der Wert an der Oberfläche vorbei.
|
||||
await vorlauf.evaluate((feld: HTMLInputElement) => {
|
||||
feld.max = '600'
|
||||
feld.value = '300'
|
||||
})
|
||||
await karte.getByRole('button', { name: 'Speichern' }).click()
|
||||
|
||||
await expect(page.getByText('Bitte die markierten Felder prüfen.')).toBeVisible()
|
||||
await expect(karte.getByText('Mehr als zwei Stunden Vorlauf')).toBeVisible()
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,45 @@
|
||||
import { expect, type Page } from '@playwright/test'
|
||||
|
||||
/** Gemeinsames für alle E2E-Tests. */
|
||||
|
||||
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.
|
||||
*
|
||||
* Der Knopf gehört zu einem Client-Formular. Ein Klick, der vor der
|
||||
* Hydratation ankommt, verpufft folgenlos — die Seite bleibt einfach stehen.
|
||||
* Deshalb wird so lange nachgefasst, bis die Startseite da ist; hat der erste
|
||||
* Klick schon gewirkt, wird nicht noch einmal geklickt.
|
||||
*/
|
||||
export async function anmelden(
|
||||
seite: Page,
|
||||
email: string = EMAIL,
|
||||
passwort: string = PASSWORT,
|
||||
): Promise<void> {
|
||||
await seite.goto('/anmelden')
|
||||
await seite.getByLabel('E-Mail-Adresse').fill(email)
|
||||
await seite.getByLabel('Passwort').fill(passwort)
|
||||
|
||||
const knopf = seite.getByRole('button', { name: 'Mit Passwort anmelden' })
|
||||
const begruessung = seite.getByRole('heading', { name: /Guten Tag/ })
|
||||
|
||||
await expect(async () => {
|
||||
if (new URL(seite.url()).pathname === '/anmelden') {
|
||||
await knopf.click({ timeout: 5_000 })
|
||||
}
|
||||
await expect(begruessung).toBeVisible({ timeout: 5_000 })
|
||||
}).toPass({ timeout: 45_000 })
|
||||
}
|
||||
+173
@@ -0,0 +1,173 @@
|
||||
import { createHash, randomBytes } from 'node:crypto'
|
||||
import { PrismaPg } from '@prisma/adapter-pg'
|
||||
import { expect, test, type APIRequestContext } from '@playwright/test'
|
||||
import { PrismaClient } from '../src/generated/prisma/client.js'
|
||||
import { EMAIL, VERBINDUNG } from './hilfe'
|
||||
|
||||
/**
|
||||
* Der MCP-Endpunkt.
|
||||
*
|
||||
* Er spricht JSON-RPC, also wird hier auch JSON-RPC gesprochen — kein
|
||||
* Nachbau der Bibliothek, sondern echte Aufrufe gegen den laufenden Server.
|
||||
*
|
||||
* Der wichtigste Punkt: Die Werkzeugliste hängt an den Rechten des Tokens.
|
||||
* Was ein Token nicht darf, soll ein Modell gar nicht erst sehen.
|
||||
*/
|
||||
|
||||
const db = new PrismaClient({ adapter: new PrismaPg({ connectionString: VERBINDUNG }) })
|
||||
const PRAEFIX = `E2E-MCP-${Date.now()}`
|
||||
|
||||
async function tokenBauen(benutzerId: string, rechte: string): Promise<string> {
|
||||
const praefix = randomBytes(4).toString('hex')
|
||||
const klartext = `planer_${praefix}_${randomBytes(32).toString('base64url')}`
|
||||
await db.apiToken.create({
|
||||
data: {
|
||||
benutzerId,
|
||||
name: `${PRAEFIX} ${rechte}`,
|
||||
praefix,
|
||||
hash: createHash('sha256').update(klartext, 'utf8').digest('hex'),
|
||||
rechte,
|
||||
},
|
||||
})
|
||||
return klartext
|
||||
}
|
||||
|
||||
type Antwort = {
|
||||
result?: { tools?: { name: string }[]; content?: { text: string }[]; isError?: boolean }
|
||||
error?: { message: string }
|
||||
}
|
||||
|
||||
/** Ein JSON-RPC-Aufruf gegen den Endpunkt. */
|
||||
async function rufen(
|
||||
request: APIRequestContext,
|
||||
token: string | null,
|
||||
methode: string,
|
||||
parameter: Record<string, unknown> = {},
|
||||
) {
|
||||
const antwort = await request.post('/api/mcp', {
|
||||
headers: {
|
||||
'Content-Type': 'application/json',
|
||||
// Der Streamable-HTTP-Transport besteht auf beidem.
|
||||
Accept: 'application/json, text/event-stream',
|
||||
...(token ? { Authorization: `Bearer ${token}` } : {}),
|
||||
},
|
||||
data: { jsonrpc: '2.0', id: 1, method: methode, params: parameter },
|
||||
})
|
||||
return antwort
|
||||
}
|
||||
|
||||
/** Der Handschlag, den jede MCP-Verbindung zuerst führt. */
|
||||
const HANDSCHLAG = {
|
||||
protocolVersion: '2025-06-18',
|
||||
capabilities: {},
|
||||
clientInfo: { name: 'e2e', version: '1.0.0' },
|
||||
}
|
||||
|
||||
test.describe('MCP', () => {
|
||||
test.skip(!EMAIL || !VERBINDUNG, 'Ohne ADMIN_EMAIL und DATABASE_URL kein Testkonto.')
|
||||
|
||||
let benutzerId = ''
|
||||
|
||||
test.beforeAll(async () => {
|
||||
const benutzer = await db.benutzer.findUniqueOrThrow({ where: { email: EMAIL } })
|
||||
benutzerId = benutzer.id
|
||||
})
|
||||
|
||||
test.afterAll(async () => {
|
||||
await db.aufgabe.deleteMany({ where: { titel: { startsWith: PRAEFIX } } })
|
||||
await db.apiToken.deleteMany({ where: { name: { startsWith: PRAEFIX } } })
|
||||
await db.auditEintrag.deleteMany({ where: { aktion: { startsWith: 'mcp.' } } })
|
||||
await db.$disconnect()
|
||||
})
|
||||
|
||||
test('weist eine Anfrage ohne Token ab', async ({ request }) => {
|
||||
const antwort = await rufen(request, null, 'initialize', HANDSCHLAG)
|
||||
expect(antwort.status()).toBe(401)
|
||||
})
|
||||
|
||||
test('führt den Handschlag mit gültigem Token', async ({ request }) => {
|
||||
const token = await tokenBauen(benutzerId, 'lesen')
|
||||
const antwort = await rufen(request, token, 'initialize', HANDSCHLAG)
|
||||
|
||||
expect(antwort.ok()).toBe(true)
|
||||
const inhalt = (await antwort.json()) as {
|
||||
result?: { serverInfo?: { name: string } }
|
||||
}
|
||||
expect(inhalt.result?.serverInfo?.name).toBe('planer')
|
||||
})
|
||||
|
||||
test('zeigt nur die Werkzeuge, die der Token erlaubt', async ({ request }) => {
|
||||
const nurLesen = await tokenBauen(benutzerId, 'lesen')
|
||||
await rufen(request, nurLesen, 'initialize', HANDSCHLAG)
|
||||
|
||||
const antwort = await rufen(request, nurLesen, 'tools/list')
|
||||
const namen = (((await antwort.json()) as Antwort).result?.tools ?? []).map(
|
||||
(w) => w.name,
|
||||
)
|
||||
|
||||
expect(namen).toContain('aufgaben_suchen')
|
||||
expect(namen).toContain('woche_ansehen')
|
||||
// Erfassen und Schreiben fehlen dem Token – und damit der Liste.
|
||||
expect(namen).not.toContain('aufgabe_anlegen')
|
||||
expect(namen).not.toContain('aufgabe_abhaken')
|
||||
expect(namen).not.toContain('zeitblock_anlegen')
|
||||
})
|
||||
|
||||
test('zeigt einem Erfassen-Token nur das Anlegen', async ({ request }) => {
|
||||
const token = await tokenBauen(benutzerId, 'erfassen')
|
||||
await rufen(request, token, 'initialize', HANDSCHLAG)
|
||||
|
||||
const antwort = await rufen(request, token, 'tools/list')
|
||||
const namen = (((await antwort.json()) as Antwort).result?.tools ?? []).map(
|
||||
(w) => w.name,
|
||||
)
|
||||
|
||||
expect(namen).toEqual(['aufgabe_anlegen'])
|
||||
})
|
||||
|
||||
test('legt eine Aufgabe an und protokolliert das', async ({ request }) => {
|
||||
const token = await tokenBauen(benutzerId, 'erfassen')
|
||||
await rufen(request, token, 'initialize', HANDSCHLAG)
|
||||
|
||||
const titel = `${PRAEFIX} Angebot schreiben`
|
||||
const antwort = await rufen(request, token, 'tools/call', {
|
||||
name: 'aufgabe_anlegen',
|
||||
arguments: { titel, aufwandMinuten: 45 },
|
||||
})
|
||||
|
||||
expect(antwort.ok()).toBe(true)
|
||||
const inhalt = (await antwort.json()) as Antwort
|
||||
expect(inhalt.result?.content?.[0]?.text).toContain('Angelegt')
|
||||
|
||||
const aufgabe = await db.aufgabe.findFirstOrThrow({
|
||||
where: { titel },
|
||||
select: { quelle: true, bereichId: true, status: true, aufwandMinuten: true },
|
||||
})
|
||||
expect(aufgabe.quelle).toBe('MCP')
|
||||
expect(aufgabe.aufwandMinuten).toBe(45)
|
||||
// Wie über die Schnittstelle: offen und in der Inbox.
|
||||
expect(aufgabe.status).toBe('OFFEN')
|
||||
expect(aufgabe.bereichId).toBeNull()
|
||||
|
||||
const eintrag = await db.auditEintrag.findFirst({
|
||||
where: { aktion: 'mcp.erfasst' },
|
||||
select: { details: true },
|
||||
})
|
||||
expect(JSON.stringify(eintrag?.details)).toContain('mcp')
|
||||
})
|
||||
|
||||
test('lässt ein Werkzeug ohne Recht gar nicht erst aufrufen', async ({ request }) => {
|
||||
const token = await tokenBauen(benutzerId, 'lesen')
|
||||
await rufen(request, token, 'initialize', HANDSCHLAG)
|
||||
|
||||
const antwort = await rufen(request, token, 'tools/call', {
|
||||
name: 'aufgabe_anlegen',
|
||||
arguments: { titel: `${PRAEFIX} darf nicht` },
|
||||
})
|
||||
|
||||
const inhalt = (await antwort.json()) as Antwort
|
||||
// Unbekanntes Werkzeug: Es ist für diesen Token nicht registriert.
|
||||
expect(inhalt.error ?? inhalt.result?.isError).toBeTruthy()
|
||||
expect(await db.aufgabe.count({ where: { titel: `${PRAEFIX} darf nicht` } })).toBe(0)
|
||||
})
|
||||
})
|
||||
+5
-12
@@ -1,7 +1,8 @@
|
||||
import { PrismaPg } from '@prisma/adapter-pg'
|
||||
import { expect, test, type Page } from '@playwright/test'
|
||||
import { expect, test } from '@playwright/test'
|
||||
import bcrypt from 'bcryptjs'
|
||||
import { PrismaClient } from '../src/generated/prisma/client.js'
|
||||
import { anmelden as anmeldenMit } from './hilfe'
|
||||
|
||||
/**
|
||||
* Prüft, dass die Rollentrennung serverseitig hält.
|
||||
@@ -38,23 +39,15 @@ test.describe('Rollentrennung', () => {
|
||||
await db.$disconnect()
|
||||
})
|
||||
|
||||
async function anmelden(seite: Page): Promise<void> {
|
||||
await seite.goto('/anmelden')
|
||||
await seite.getByLabel('E-Mail-Adresse').fill(EMAIL)
|
||||
await seite.getByLabel('Passwort').fill(PASSWORT)
|
||||
await seite.getByRole('button', { name: 'Mit Passwort anmelden' }).click()
|
||||
await expect(seite.getByRole('heading', { name: /Guten Tag/ })).toBeVisible()
|
||||
}
|
||||
|
||||
test('zeigt einem Benutzer den Menüpunkt Protokoll gar nicht', async ({ page }) => {
|
||||
await anmelden(page)
|
||||
await anmeldenMit(page, EMAIL, PASSWORT)
|
||||
await expect(page.getByRole('link', { name: 'Protokoll' })).toHaveCount(0)
|
||||
})
|
||||
|
||||
test('lässt einen Benutzer auch beim direkten Aufruf nicht ins Protokoll', async ({
|
||||
page,
|
||||
}) => {
|
||||
await anmelden(page)
|
||||
await anmeldenMit(page, EMAIL, PASSWORT)
|
||||
await page.goto('/verwaltung/protokoll')
|
||||
|
||||
await expect(page).toHaveURL(/\/keine-berechtigung/)
|
||||
@@ -64,7 +57,7 @@ test.describe('Rollentrennung', () => {
|
||||
})
|
||||
|
||||
test('zeigt einem Benutzer die Bereiche, aber ohne Formulare', async ({ page }) => {
|
||||
await anmelden(page)
|
||||
await anmeldenMit(page, EMAIL, PASSWORT)
|
||||
await page.goto('/bereiche')
|
||||
|
||||
await expect(page.getByRole('heading', { name: 'Bereiche' })).toBeVisible()
|
||||
|
||||
@@ -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)
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,116 @@
|
||||
import { PrismaPg } from '@prisma/adapter-pg'
|
||||
import { expect, test } from '@playwright/test'
|
||||
import { PrismaClient } from '../src/generated/prisma/client.js'
|
||||
import { anmelden, EMAIL, PASSWORT, VERBINDUNG } from './hilfe'
|
||||
|
||||
/**
|
||||
* Wochenansicht und Zeitblöcke.
|
||||
*
|
||||
* Ohne echtes Kalenderkonto lässt sich der Schreibweg zum Anbieter nicht
|
||||
* prüfen — er scheitert dann und der Zeitblock trägt einen Fehler. Genau das
|
||||
* ist aber selbst prüfenswert: Die Planung muss auch dann überleben, wenn der
|
||||
* Kalender nicht erreichbar ist.
|
||||
*/
|
||||
|
||||
const PRAEFIX = `E2E-W-${Date.now()}`
|
||||
|
||||
const db = new PrismaClient({ adapter: new PrismaPg({ connectionString: VERBINDUNG }) })
|
||||
|
||||
test.describe('Woche', () => {
|
||||
test.skip(
|
||||
!EMAIL || !PASSWORT || !VERBINDUNG,
|
||||
'Ohne ADMIN_EMAIL, ADMIN_PASSWORT und DATABASE_URL gibt es kein Testkonto.',
|
||||
)
|
||||
|
||||
test.afterAll(async () => {
|
||||
await db.zeitblock.deleteMany({
|
||||
where: { aufgabe: { titel: { startsWith: PRAEFIX } } },
|
||||
})
|
||||
await db.aufgabe.deleteMany({ where: { titel: { startsWith: PRAEFIX } } })
|
||||
await db.kalenderkonto.deleteMany({ where: { extKontoId: { startsWith: PRAEFIX } } })
|
||||
await db.auditEintrag.deleteMany({ where: { aktion: { startsWith: 'zeitblock.' } } })
|
||||
await db.$disconnect()
|
||||
})
|
||||
|
||||
test('weist ohne verbundenen Kalender darauf hin', async ({ page }) => {
|
||||
await db.kalenderkonto.deleteMany({})
|
||||
await anmelden(page)
|
||||
await page.goto('/woche')
|
||||
|
||||
await expect(page.getByRole('heading', { name: 'Woche' })).toBeVisible()
|
||||
await expect(page.getByText('Noch kein Kalender verbunden')).toBeVisible()
|
||||
await expect(
|
||||
page.getByText('Ohne verbundenen Kalender lässt sich nichts'),
|
||||
).toBeVisible()
|
||||
})
|
||||
|
||||
test('zeigt einen Zeitblock im Raster und plant ihn wieder aus', async ({ page }) => {
|
||||
const benutzer = await db.benutzer.findUniqueOrThrow({ where: { email: EMAIL } })
|
||||
|
||||
// Ein Kalenderkonto ohne gültige Tokens: die Ansicht funktioniert, der
|
||||
// Schreibweg zum Anbieter nicht.
|
||||
const konto = await db.kalenderkonto.create({
|
||||
data: {
|
||||
benutzerId: benutzer.id,
|
||||
anbieter: 'GRAPH',
|
||||
anzeigename: `${PRAEFIX} Testkalender`,
|
||||
extKontoId: `${PRAEFIX}-konto`,
|
||||
},
|
||||
})
|
||||
|
||||
const aufgabe = await db.aufgabe.create({
|
||||
data: { titel: `${PRAEFIX} Angebot schreiben`, aufwandMinuten: 60 },
|
||||
})
|
||||
|
||||
// Zeitblock auf 10:00 Uhr des Montags dieser Woche legen.
|
||||
const jetzt = new Date()
|
||||
const montag = new Date(jetzt)
|
||||
montag.setUTCHours(0, 0, 0, 0)
|
||||
montag.setUTCDate(montag.getUTCDate() - ((montag.getUTCDay() + 6) % 7))
|
||||
const beginn = new Date(montag.getTime() + 10 * 60 * 60 * 1000)
|
||||
|
||||
await db.zeitblock.create({
|
||||
data: {
|
||||
aufgabeId: aufgabe.id,
|
||||
kalenderkontoId: konto.id,
|
||||
beginn,
|
||||
ende: new Date(beginn.getTime() + 60 * 60 * 1000),
|
||||
},
|
||||
})
|
||||
await db.aufgabe.update({
|
||||
where: { id: aufgabe.id },
|
||||
data: { status: 'GEPLANT' },
|
||||
})
|
||||
|
||||
await anmelden(page)
|
||||
await page.goto('/woche')
|
||||
|
||||
const block = page.getByTitle(new RegExp(`${PRAEFIX} Angebot schreiben`))
|
||||
await expect(block).toBeVisible()
|
||||
|
||||
// Ausplanen: der Block verschwindet, die Aufgabe fällt zurück auf offen.
|
||||
await block.getByRole('button', { name: 'Ausplanen' }).click()
|
||||
await expect(page.getByText('ausgeplant')).toBeVisible()
|
||||
|
||||
await expect
|
||||
.poll(async () => db.zeitblock.count({ where: { aufgabeId: aufgabe.id } }))
|
||||
.toBe(0)
|
||||
|
||||
const danach = await db.aufgabe.findUniqueOrThrow({ where: { id: aufgabe.id } })
|
||||
expect(danach.status).toBe('OFFEN')
|
||||
})
|
||||
|
||||
test('lässt sich durch die Wochen blättern', async ({ page }) => {
|
||||
await anmelden(page)
|
||||
await page.goto('/woche')
|
||||
|
||||
await page.getByRole('link', { name: 'Weiter' }).click()
|
||||
await expect(page).toHaveURL(/versatz=1/)
|
||||
|
||||
await page.getByRole('link', { name: 'Zurück' }).click()
|
||||
await expect(page).toHaveURL(/versatz=0/)
|
||||
|
||||
await page.getByRole('link', { name: 'Diese Woche' }).click()
|
||||
await expect(page).toHaveURL(/\/woche$/)
|
||||
})
|
||||
})
|
||||
@@ -16,6 +16,8 @@ export default tseslint.config(
|
||||
// Vom Generator erzeugt, nicht von Hand gepflegt.
|
||||
'src/generated/**',
|
||||
'next-env.d.ts',
|
||||
// Service Worker: laeuft im Browser, nicht in unserer Werkzeugkette.
|
||||
'public/sw.js',
|
||||
],
|
||||
},
|
||||
...naechstesWebVitals,
|
||||
|
||||
Generated
+975
-35
File diff suppressed because it is too large
Load Diff
+6
-1
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "planer",
|
||||
"version": "0.3.0",
|
||||
"version": "0.8.0",
|
||||
"private": true,
|
||||
"description": "Aufgaben, Ideen, Projekte und Zeitblöcke mit Anbindung an Microsoft 365 und Google Kalender",
|
||||
"type": "module",
|
||||
@@ -40,6 +40,9 @@
|
||||
"dependencies": {
|
||||
"@auth/prisma-adapter": "2.11.3",
|
||||
"@date-fns/tz": "1.5.0",
|
||||
"@dnd-kit/core": "6.3.1",
|
||||
"@dnd-kit/utilities": "3.2.2",
|
||||
"@modelcontextprotocol/sdk": "^1.30.0",
|
||||
"@prisma/adapter-pg": "7.10.0",
|
||||
"@prisma/client": "7.10.0",
|
||||
"@radix-ui/react-avatar": "1.2.6",
|
||||
@@ -66,6 +69,7 @@
|
||||
"server-only": "0.0.1",
|
||||
"sonner": "2.0.8",
|
||||
"tailwind-merge": "3.6.0",
|
||||
"web-push": "3.6.7",
|
||||
"zod": "4.6.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
@@ -77,6 +81,7 @@
|
||||
"@types/pg": "8.23.1",
|
||||
"@types/react": "19.3.0",
|
||||
"@types/react-dom": "19.3.0",
|
||||
"@types/web-push": "3.6.4",
|
||||
"@vitejs/plugin-react": "6.1.1",
|
||||
"@vitest/coverage-v8": "5.0.0",
|
||||
"dotenv": "17.4.2",
|
||||
|
||||
@@ -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,
|
||||
},
|
||||
},
|
||||
})
|
||||
|
||||
@@ -373,6 +373,37 @@ async function main(): Promise<void> {
|
||||
},
|
||||
})
|
||||
|
||||
// --- Zeitblöcke: eingeplante Aufgaben im Kalender -------------------------
|
||||
await db.zeitblock.deleteMany({})
|
||||
const einzuplanen = await db.aufgabe.findMany({
|
||||
where: {
|
||||
titel: {
|
||||
in: [
|
||||
'Wochenbericht an die Geschäftsführung',
|
||||
'Angebot Heizungstausch nachfassen',
|
||||
],
|
||||
},
|
||||
},
|
||||
select: { id: true, titel: true, aufwandMinuten: true },
|
||||
})
|
||||
|
||||
let blockStunde = 15
|
||||
for (const aufgabe of einzuplanen) {
|
||||
const beginn = new Date(Date.UTC(2026, 2, 17, blockStunde - 1, 0))
|
||||
await db.zeitblock.create({
|
||||
data: {
|
||||
aufgabeId: aufgabe.id,
|
||||
kalenderkontoId: kalenderkonto.id,
|
||||
beginn,
|
||||
ende: new Date(beginn.getTime() + (aufgabe.aufwandMinuten ?? 60) * 60_000),
|
||||
extId: `demo-block-${aufgabe.id}`,
|
||||
hash: 'demo',
|
||||
},
|
||||
})
|
||||
await db.aufgabe.update({ where: { id: aufgabe.id }, data: { status: 'GEPLANT' } })
|
||||
blockStunde += 2
|
||||
}
|
||||
|
||||
// Eine Aufgabe, die von außen kam – zeigt die Herkunft in der Liste.
|
||||
await db.aufgabe.create({
|
||||
data: {
|
||||
@@ -387,6 +418,115 @@ async function main(): Promise<void> {
|
||||
},
|
||||
})
|
||||
|
||||
// --- Benachrichtigungen ---------------------------------------------------
|
||||
// Für die Bilder eingeschaltet. Eine leere Karte zeigt nichts von dem,
|
||||
// was das Kapitel erklärt.
|
||||
await db.benachrichtigungseinstellung.upsert({
|
||||
where: { benutzerId: benutzer.id },
|
||||
update: {},
|
||||
create: {
|
||||
benutzerId: benutzer.id,
|
||||
anlaesse: 'tagesueberblick,faelligkeit,zeitblock',
|
||||
perPush: true,
|
||||
perMail: true,
|
||||
perTelegram: true,
|
||||
ueberblickUm: 7 * 60,
|
||||
ruheVon: 20 * 60,
|
||||
ruheBis: 7 * 60,
|
||||
ruheAmWochenende: false,
|
||||
zeitblockVorlaufMinuten: 10,
|
||||
},
|
||||
})
|
||||
|
||||
// Kein Push-Gerät in den Demo-Daten: Seine Schlüssel liegen
|
||||
// verschlüsselt, und der Versand entfernt jedes Gerät, dessen Schlüssel er
|
||||
// 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)),
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// --- API-Tokens -----------------------------------------------------------
|
||||
// Erfundene Hashes: Mit diesen Zeilen laesst sich nichts aufrufen, sie
|
||||
// zeigen nur, wie die Liste aussieht.
|
||||
await db.apiToken.deleteMany({})
|
||||
await db.apiToken.create({
|
||||
data: {
|
||||
benutzerId: benutzer.id,
|
||||
name: 'Wartungsplaner-Import',
|
||||
praefix: 'k7m2xq4b',
|
||||
hash: 'demo-1',
|
||||
rechte: 'erfassen',
|
||||
erstelltAm: new Date(Date.UTC(2026, 0, 14, 9, 30)),
|
||||
letzteNutzung: new Date(Date.UTC(2026, 2, 17, 5, 12)),
|
||||
},
|
||||
})
|
||||
await db.apiToken.create({
|
||||
data: {
|
||||
benutzerId: benutzer.id,
|
||||
name: 'Auswertung Homelab',
|
||||
praefix: 'r3wp9dt4',
|
||||
hash: 'demo-2',
|
||||
rechte: 'lesen',
|
||||
gueltigBis: new Date(Date.UTC(2026, 8, 30, 22, 0)),
|
||||
erstelltAm: new Date(Date.UTC(2026, 1, 2, 18, 45)),
|
||||
},
|
||||
})
|
||||
await db.apiToken.create({
|
||||
data: {
|
||||
benutzerId: benutzer.id,
|
||||
name: 'Altes Skript',
|
||||
praefix: 'z8n4vt6c',
|
||||
hash: 'demo-3',
|
||||
rechte: 'lesen,schreiben',
|
||||
erstelltAm: new Date(Date.UTC(2025, 10, 3, 11, 0)),
|
||||
widerrufenAm: new Date(Date.UTC(2026, 1, 20, 8, 15)),
|
||||
},
|
||||
})
|
||||
|
||||
console.log(`Demo-Daten stehen bereit. Anmeldung: ${DEMO_EMAIL}`)
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
-- CreateTable
|
||||
CREATE TABLE "zeitblock" (
|
||||
"id" TEXT NOT NULL,
|
||||
"aufgabeId" TEXT NOT NULL,
|
||||
"kalenderkontoId" TEXT NOT NULL,
|
||||
"beginn" TIMESTAMP(3) NOT NULL,
|
||||
"ende" TIMESTAMP(3) NOT NULL,
|
||||
"extId" TEXT,
|
||||
"etag" TEXT,
|
||||
"hash" TEXT,
|
||||
"letzterFehler" TEXT,
|
||||
"erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"aktualisiertAm" TIMESTAMP(3) NOT NULL,
|
||||
|
||||
CONSTRAINT "zeitblock_pkey" PRIMARY KEY ("id")
|
||||
);
|
||||
|
||||
-- CreateIndex
|
||||
CREATE INDEX "zeitblock_beginn_ende_idx" ON "zeitblock"("beginn", "ende");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE INDEX "zeitblock_aufgabeId_idx" ON "zeitblock"("aufgabeId");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE UNIQUE INDEX "zeitblock_kalenderkontoId_extId_key" ON "zeitblock"("kalenderkontoId", "extId");
|
||||
|
||||
-- AddForeignKey
|
||||
ALTER TABLE "zeitblock" ADD CONSTRAINT "zeitblock_aufgabeId_fkey" FOREIGN KEY ("aufgabeId") REFERENCES "aufgabe"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
|
||||
-- AddForeignKey
|
||||
ALTER TABLE "zeitblock" ADD CONSTRAINT "zeitblock_kalenderkontoId_fkey" FOREIGN KEY ("kalenderkontoId") REFERENCES "kalenderkonto"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
@@ -0,0 +1,66 @@
|
||||
-- CreateTable
|
||||
CREATE TABLE "benachrichtigungseinstellung" (
|
||||
"id" TEXT NOT NULL,
|
||||
"benutzerId" TEXT NOT NULL,
|
||||
"anlaesse" TEXT NOT NULL DEFAULT 'tagesueberblick,faelligkeit',
|
||||
"perPush" BOOLEAN NOT NULL DEFAULT false,
|
||||
"perMail" BOOLEAN NOT NULL DEFAULT false,
|
||||
"ueberblickUm" INTEGER NOT NULL DEFAULT 420,
|
||||
"ruheVon" INTEGER NOT NULL DEFAULT 1200,
|
||||
"ruheBis" INTEGER NOT NULL DEFAULT 420,
|
||||
"ruheAmWochenende" BOOLEAN NOT NULL DEFAULT false,
|
||||
"zeitblockVorlaufMinuten" INTEGER NOT NULL DEFAULT 10,
|
||||
"erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"aktualisiertAm" TIMESTAMP(3) NOT NULL,
|
||||
|
||||
CONSTRAINT "benachrichtigungseinstellung_pkey" PRIMARY KEY ("id")
|
||||
);
|
||||
|
||||
-- CreateTable
|
||||
CREATE TABLE "push_geraet" (
|
||||
"id" TEXT NOT NULL,
|
||||
"benutzerId" TEXT NOT NULL,
|
||||
"endpunkt" TEXT NOT NULL,
|
||||
"p256dh" TEXT NOT NULL,
|
||||
"auth" TEXT NOT NULL,
|
||||
"bezeichnung" TEXT,
|
||||
"erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"zuletztBenutzt" TIMESTAMP(3),
|
||||
"fehlversuche" INTEGER NOT NULL DEFAULT 0,
|
||||
|
||||
CONSTRAINT "push_geraet_pkey" PRIMARY KEY ("id")
|
||||
);
|
||||
|
||||
-- CreateTable
|
||||
CREATE TABLE "meldungsnachweis" (
|
||||
"id" TEXT NOT NULL,
|
||||
"benutzerId" TEXT NOT NULL,
|
||||
"schluessel" TEXT NOT NULL,
|
||||
"gesendetAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
|
||||
CONSTRAINT "meldungsnachweis_pkey" PRIMARY KEY ("id")
|
||||
);
|
||||
|
||||
-- CreateIndex
|
||||
CREATE UNIQUE INDEX "benachrichtigungseinstellung_benutzerId_key" ON "benachrichtigungseinstellung"("benutzerId");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE UNIQUE INDEX "push_geraet_endpunkt_key" ON "push_geraet"("endpunkt");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE INDEX "push_geraet_benutzerId_idx" ON "push_geraet"("benutzerId");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE INDEX "meldungsnachweis_gesendetAm_idx" ON "meldungsnachweis"("gesendetAm");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE UNIQUE INDEX "meldungsnachweis_benutzerId_schluessel_key" ON "meldungsnachweis"("benutzerId", "schluessel");
|
||||
|
||||
-- AddForeignKey
|
||||
ALTER TABLE "benachrichtigungseinstellung" ADD CONSTRAINT "benachrichtigungseinstellung_benutzerId_fkey" FOREIGN KEY ("benutzerId") REFERENCES "benutzer"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
|
||||
-- AddForeignKey
|
||||
ALTER TABLE "push_geraet" ADD CONSTRAINT "push_geraet_benutzerId_fkey" FOREIGN KEY ("benutzerId") REFERENCES "benutzer"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
|
||||
-- AddForeignKey
|
||||
ALTER TABLE "meldungsnachweis" ADD CONSTRAINT "meldungsnachweis_benutzerId_fkey" FOREIGN KEY ("benutzerId") REFERENCES "benutzer"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
@@ -0,0 +1,2 @@
|
||||
-- AlterTable
|
||||
ALTER TABLE "kalenderkonto" ADD COLUMN "fehlversuche" INTEGER NOT NULL DEFAULT 0;
|
||||
@@ -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");
|
||||
@@ -0,0 +1,27 @@
|
||||
-- CreateTable
|
||||
CREATE TABLE "api_token" (
|
||||
"id" TEXT NOT NULL,
|
||||
"benutzerId" TEXT NOT NULL,
|
||||
"name" TEXT NOT NULL,
|
||||
"praefix" TEXT NOT NULL,
|
||||
"hash" TEXT NOT NULL,
|
||||
"rechte" TEXT NOT NULL,
|
||||
"gueltigBis" TIMESTAMP(3),
|
||||
"letzteNutzung" TIMESTAMP(3),
|
||||
"widerrufenAm" TIMESTAMP(3),
|
||||
"erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
|
||||
CONSTRAINT "api_token_pkey" PRIMARY KEY ("id")
|
||||
);
|
||||
|
||||
-- CreateIndex
|
||||
CREATE UNIQUE INDEX "api_token_praefix_key" ON "api_token"("praefix");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE UNIQUE INDEX "api_token_hash_key" ON "api_token"("hash");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE INDEX "api_token_benutzerId_idx" ON "api_token"("benutzerId");
|
||||
|
||||
-- AddForeignKey
|
||||
ALTER TABLE "api_token" ADD CONSTRAINT "api_token_benutzerId_fkey" FOREIGN KEY ("benutzerId") REFERENCES "benutzer"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
@@ -35,6 +35,11 @@ model Benutzer {
|
||||
passkeys Passkey[]
|
||||
audit AuditEintrag[]
|
||||
kalenderkonten Kalenderkonto[]
|
||||
benachrichtigung Benachrichtigungseinstellung?
|
||||
pushGeraete PushGeraet[]
|
||||
meldungen Meldungsnachweis[]
|
||||
telegramChats TelegramChat[]
|
||||
apiTokens ApiToken[]
|
||||
|
||||
@@index([aktiv])
|
||||
@@map("benutzer")
|
||||
@@ -219,11 +224,16 @@ 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
|
||||
|
||||
bereich Bereich? @relation(fields: [bereichId], references: [id], onDelete: SetNull)
|
||||
projekt Projekt? @relation(fields: [projektId], references: [id], onDelete: SetNull)
|
||||
zeitbloecke Zeitblock[]
|
||||
|
||||
/// Integrationen upserten immer ueber diese beiden Felder. Von Hand
|
||||
/// erfasste Aufgaben haben quelleRef = null; PostgreSQL sieht NULL-Werte
|
||||
@@ -299,6 +309,9 @@ model Kalenderkonto {
|
||||
letzterAbgleich DateTime?
|
||||
/// Klartextmeldung des letzten Fehlschlags, ohne Tokens.
|
||||
letzterFehler String?
|
||||
/// Wie oft der Abgleich hintereinander scheiterte. Ein Aussetzer ist keine
|
||||
/// Nachricht wert; gemeldet wird erst ab mehreren.
|
||||
fehlversuche Int @default(0)
|
||||
|
||||
aktiv Boolean @default(true)
|
||||
|
||||
@@ -308,6 +321,7 @@ model Kalenderkonto {
|
||||
benutzer Benutzer @relation(fields: [benutzerId], references: [id], onDelete: Cascade)
|
||||
termine Termin[]
|
||||
standardFuerBereiche Bereich[] @relation("StandardKalenderkonto")
|
||||
zeitblocks Zeitblock[]
|
||||
|
||||
/// Dasselbe Konto und derselbe Kalender nur einmal je Benutzer.
|
||||
@@unique([benutzerId, anbieter, extKontoId, kalenderId])
|
||||
@@ -340,3 +354,219 @@ model Termin {
|
||||
@@index([beginn, ende])
|
||||
@@map("termin")
|
||||
}
|
||||
|
||||
/// Eine Aufgabe, die zu einer bestimmten Zeit in einem Kalender steht.
|
||||
///
|
||||
/// Der Zeitblock lebt an zwei Orten: hier und im Kalender des Anbieters.
|
||||
/// Beide Seiten duerfen ihn verschieben; der Fingerabdruck "hash" verhindert,
|
||||
/// dass sich beide gegenseitig hochschaukeln. Siehe src/lib/zeitblock.ts.
|
||||
model Zeitblock {
|
||||
id String @id @default(cuid())
|
||||
aufgabeId String
|
||||
kalenderkontoId String
|
||||
|
||||
beginn DateTime
|
||||
ende DateTime
|
||||
|
||||
/// Kennung des Termins beim Anbieter; null, solange noch nicht geschrieben.
|
||||
extId String?
|
||||
/// Fuer bedingte Schreibzugriffe (If-Match).
|
||||
etag String?
|
||||
/// sha256(startISO|endeISO) dessen, was zuletzt geschrieben wurde.
|
||||
hash String?
|
||||
|
||||
/// Klartextmeldung des letzten Fehlschlags beim Schreiben, ohne Tokens.
|
||||
letzterFehler String?
|
||||
|
||||
erstelltAm DateTime @default(now())
|
||||
aktualisiertAm DateTime @updatedAt
|
||||
|
||||
aufgabe Aufgabe @relation(fields: [aufgabeId], references: [id], onDelete: Cascade)
|
||||
kalenderkonto Kalenderkonto @relation(fields: [kalenderkontoId], references: [id], onDelete: Cascade)
|
||||
|
||||
/// Ein Termin im Kalender gehoert zu hoechstens einem Zeitblock.
|
||||
@@unique([kalenderkontoId, extId])
|
||||
@@index([beginn, ende])
|
||||
@@index([aufgabeId])
|
||||
@@map("zeitblock")
|
||||
}
|
||||
|
||||
/// Wie und worueber ein Benutzer benachrichtigt werden will.
|
||||
model Benachrichtigungseinstellung {
|
||||
id String @id @default(cuid())
|
||||
benutzerId String @unique
|
||||
|
||||
/// Kommagetrennte Anlaesse, siehe src/lib/benachrichtigung.ts.
|
||||
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)
|
||||
ruheVon Int @default(1200)
|
||||
ruheBis Int @default(420)
|
||||
|
||||
ruheAmWochenende Boolean @default(false)
|
||||
zeitblockVorlaufMinuten Int @default(10)
|
||||
|
||||
erstelltAm DateTime @default(now())
|
||||
aktualisiertAm DateTime @updatedAt
|
||||
|
||||
benutzer Benutzer @relation(fields: [benutzerId], references: [id], onDelete: Cascade)
|
||||
|
||||
@@map("benachrichtigungseinstellung")
|
||||
}
|
||||
|
||||
/// Ein Browser, der Push-Nachrichten empfangen darf.
|
||||
model PushGeraet {
|
||||
id String @id @default(cuid())
|
||||
benutzerId String
|
||||
|
||||
/// Vom Browser vergebene Adresse; eindeutig je Geraet.
|
||||
endpunkt String @unique
|
||||
/// Schluessel aus der Push-Anmeldung, verschluesselt abgelegt.
|
||||
p256dh String
|
||||
auth String
|
||||
|
||||
bezeichnung String?
|
||||
erstelltAm DateTime @default(now())
|
||||
zuletztBenutzt DateTime?
|
||||
/// Wie oft der Versand hintereinander scheiterte; ab einer Grenze weg.
|
||||
fehlversuche Int @default(0)
|
||||
|
||||
benutzer Benutzer @relation(fields: [benutzerId], references: [id], onDelete: Cascade)
|
||||
|
||||
@@index([benutzerId])
|
||||
@@map("push_geraet")
|
||||
}
|
||||
|
||||
/// Nachweis, dass eine Meldung schon hinausging – verhindert Wiederholungen.
|
||||
model Meldungsnachweis {
|
||||
id String @id @default(cuid())
|
||||
benutzerId String
|
||||
/// anlass:sache:tag, siehe meldungsSchluessel().
|
||||
schluessel String
|
||||
gesendetAm DateTime @default(now())
|
||||
|
||||
benutzer Benutzer @relation(fields: [benutzerId], references: [id], onDelete: Cascade)
|
||||
|
||||
@@unique([benutzerId, schluessel])
|
||||
@@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")
|
||||
}
|
||||
|
||||
/// Zugangstoken fuer die oeffentliche Schnittstelle.
|
||||
///
|
||||
/// Gespeichert wird nur der Hash. Der Klartext existiert genau einmal – beim
|
||||
/// Anlegen, auf dem Bildschirm. Ein Token ist ein Passwort; wer es verliert,
|
||||
/// legt ein neues an, statt das alte irgendwo nachzuschlagen.
|
||||
model ApiToken {
|
||||
id String @id @default(cuid())
|
||||
benutzerId String
|
||||
|
||||
name String
|
||||
/// Sichtbarer Anfang, macht die Zeile auffindbar und wiedererkennbar.
|
||||
praefix String @unique
|
||||
/// SHA-256 des vollstaendigen Tokens.
|
||||
hash String @unique
|
||||
|
||||
/// Kommagetrennt, siehe src/lib/api.ts.
|
||||
rechte String
|
||||
|
||||
gueltigBis DateTime?
|
||||
letzteNutzung DateTime?
|
||||
/// Gesetzt heisst: gilt nicht mehr. Die Zeile bleibt fuer das Protokoll.
|
||||
widerrufenAm DateTime?
|
||||
|
||||
erstelltAm DateTime @default(now())
|
||||
|
||||
benutzer Benutzer @relation(fields: [benutzerId], references: [id], onDelete: Cascade)
|
||||
|
||||
@@index([benutzerId])
|
||||
@@map("api_token")
|
||||
}
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
{
|
||||
"name": "Planer",
|
||||
"short_name": "Planer",
|
||||
"description": "Aufgaben, Ideen, Projekte und Zeitblöcke.",
|
||||
"lang": "de",
|
||||
"dir": "ltr",
|
||||
"start_url": "/erfassen",
|
||||
"scope": "/",
|
||||
"display": "standalone",
|
||||
"orientation": "portrait",
|
||||
"background_color": "#f7f8fa",
|
||||
"theme_color": "#f7f8fa",
|
||||
"icons": [
|
||||
{
|
||||
"src": "/symbol.svg",
|
||||
"sizes": "any",
|
||||
"type": "image/svg+xml",
|
||||
"purpose": "any"
|
||||
},
|
||||
{
|
||||
"src": "/symbol-flaeche.svg",
|
||||
"sizes": "any",
|
||||
"type": "image/svg+xml",
|
||||
"purpose": "maskable"
|
||||
}
|
||||
],
|
||||
"shortcuts": [
|
||||
{
|
||||
"name": "Erfassen",
|
||||
"short_name": "Erfassen",
|
||||
"url": "/erfassen"
|
||||
},
|
||||
{
|
||||
"name": "Heute",
|
||||
"short_name": "Heute",
|
||||
"url": "/"
|
||||
}
|
||||
]
|
||||
}
|
||||
+107
@@ -0,0 +1,107 @@
|
||||
/*
|
||||
* Service Worker des Planers.
|
||||
*
|
||||
* Zwei Aufgaben: Push-Nachrichten anzeigen, und die Seite "Erfassen" auch
|
||||
* ohne Netz bereithalten.
|
||||
*
|
||||
* Zwischengespeichert wird **genau diese eine Seite** und sonst nichts. Ein
|
||||
* halb veralteter Planer wäre schlimmer als gar keiner — ein Eingabefeld
|
||||
* dagegen veraltet nicht, und ohne die Seite nützte die Warteschlange im
|
||||
* Gerät niemandem: Man käme gar nicht erst hin.
|
||||
*/
|
||||
|
||||
const LAGER = 'planer-erfassen-v1'
|
||||
const OFFLINE_SEITE = '/erfassen'
|
||||
|
||||
self.addEventListener('install', (ereignis) => {
|
||||
ereignis.waitUntil(
|
||||
caches
|
||||
.open(LAGER)
|
||||
.then((lager) => lager.add(new Request(OFFLINE_SEITE, { cache: 'reload' })))
|
||||
.catch(() => undefined),
|
||||
)
|
||||
// Sofort übernehmen, nicht auf das Schließen aller Tabs warten.
|
||||
self.skipWaiting()
|
||||
})
|
||||
|
||||
self.addEventListener('activate', (ereignis) => {
|
||||
ereignis.waitUntil(
|
||||
caches
|
||||
.keys()
|
||||
.then((namen) =>
|
||||
Promise.all(namen.filter((n) => n !== LAGER).map((n) => caches.delete(n))),
|
||||
)
|
||||
.then(() => self.clients.claim()),
|
||||
)
|
||||
})
|
||||
|
||||
self.addEventListener('fetch', (ereignis) => {
|
||||
const anfrage = ereignis.request
|
||||
if (anfrage.method !== 'GET') return
|
||||
|
||||
const adresse = new URL(anfrage.url)
|
||||
if (adresse.origin !== self.location.origin) return
|
||||
if (adresse.pathname !== OFFLINE_SEITE) return
|
||||
|
||||
// Zuerst das Netz: Wer online ist, bekommt die frische Seite. Erst wenn das
|
||||
// scheitert, kommt die aufgehobene Fassung.
|
||||
ereignis.respondWith(
|
||||
fetch(anfrage)
|
||||
.then((antwort) => {
|
||||
if (antwort.ok) {
|
||||
const kopie = antwort.clone()
|
||||
void caches.open(LAGER).then((lager) => lager.put(OFFLINE_SEITE, kopie))
|
||||
}
|
||||
return antwort
|
||||
})
|
||||
.catch(() =>
|
||||
caches
|
||||
.match(OFFLINE_SEITE)
|
||||
.then(
|
||||
(aufgehoben) =>
|
||||
aufgehoben ??
|
||||
new Response('Offline und nichts aufgehoben.', {
|
||||
status: 503,
|
||||
headers: { 'Content-Type': 'text/plain; charset=utf-8' },
|
||||
}),
|
||||
),
|
||||
),
|
||||
)
|
||||
})
|
||||
|
||||
self.addEventListener('push', (ereignis) => {
|
||||
let daten = { titel: 'Planer', text: '', pfad: '/' }
|
||||
try {
|
||||
if (ereignis.data) daten = { ...daten, ...ereignis.data.json() }
|
||||
} catch {
|
||||
// Kaputte Nutzlast: lieber eine karge Meldung als gar keine.
|
||||
}
|
||||
|
||||
ereignis.waitUntil(
|
||||
self.registration.showNotification(daten.titel, {
|
||||
body: daten.text,
|
||||
lang: 'de',
|
||||
// Gleiche Anlässe überschreiben einander, statt sich zu stapeln.
|
||||
tag: daten.anlass || 'planer',
|
||||
data: { pfad: daten.pfad },
|
||||
}),
|
||||
)
|
||||
})
|
||||
|
||||
self.addEventListener('notificationclick', (ereignis) => {
|
||||
ereignis.notification.close()
|
||||
const pfad = (ereignis.notification.data && ereignis.notification.data.pfad) || '/'
|
||||
|
||||
ereignis.waitUntil(
|
||||
self.clients.matchAll({ type: 'window', includeUncontrolled: true }).then((fenster) => {
|
||||
// Ist der Planer schon offen, dorthin wechseln statt ein zweites
|
||||
// Fenster aufzumachen.
|
||||
for (const f of fenster) {
|
||||
if (f.url.includes(self.location.origin)) {
|
||||
return f.focus().then(() => f.navigate(pfad))
|
||||
}
|
||||
}
|
||||
return self.clients.openWindow(pfad)
|
||||
}),
|
||||
)
|
||||
})
|
||||
@@ -0,0 +1,7 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Planer">
|
||||
<!-- Maskierbare Fassung: Das Motiv sitzt in der sicheren Zone, damit ein
|
||||
Betriebssystem daraus einen Kreis oder ein Quadrat schneiden kann. -->
|
||||
<rect width="64" height="64" fill="#2563eb" />
|
||||
<path d="M20 34l8 8 16-18" fill="none" stroke="#ffffff" stroke-width="6"
|
||||
stroke-linecap="round" stroke-linejoin="round" />
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 435 B |
@@ -0,0 +1,9 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" role="img" aria-label="Planer">
|
||||
<!-- Ein Blatt mit Haken: Liste plus Erledigtes. Bewusst ohne Farbverlauf,
|
||||
damit es auch als kleines Symbol lesbar bleibt. -->
|
||||
<rect x="10" y="6" width="44" height="52" rx="8" fill="#2563eb" />
|
||||
<rect x="20" y="2" width="8" height="10" rx="4" fill="#1e40af" />
|
||||
<rect x="36" y="2" width="8" height="10" rx="4" fill="#1e40af" />
|
||||
<path d="M21 33l8 8 15-16" fill="none" stroke="#ffffff" stroke-width="6"
|
||||
stroke-linecap="round" stroke-linejoin="round" />
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 573 B |
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user