Merge docs/features: Vorstellung des Funktionsumfangs

docs: FEATURES.md - Vorstellung des Funktionsumfangs
Dokumentiert alle implementierten Features als "Was kann die Speisekarte?"-Vorstellung: oeffentliche Speisekarte, Kantinen-Bereich, Admin-Bereich, Anmeldung/Sicherheit, Mehrsprachigkeit, Betrieb sowie eine kompakte Versionstabelle. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-08-16 00:04:31 +02:00 · 2026-08-16 00:04:24 +02:00 · 2026-07-20 12:52:16 +02:00 · 2026-07-20 12:52:01 +02:00 · 2026-07-20 12:49:46 +02:00 · 2026-07-20 12:49:04 +02:00
18 changed files with 935 additions and 98 deletions
@@ -4,6 +4,37 @@ Alle nennenswerten Änderungen an diesem Projekt werden hier dokumentiert.
 Format angelehnt an [Keep a Changelog](https://keepachangelog.com/de/1.1.0/),
 Versionierung nach [Semantic Versioning](https://semver.org/lang/de/).

+## [1.12.1] – 2026-07-20
+
+### Geändert
+- Bedienung geschlossener Tage im Wochenplan überarbeitet: Statt eines
+  Text-Links am Datum markiert jetzt ein Schloss-Symbol (🔓 zum
+  Schließen, 🔒 zeigt „geschlossen" an und öffnet per Klick wieder) den
+  Tag. Ein geschlossener Tag zeigt sowohl im Wochenplan als auch auf
+  der öffentlichen Speisekarte (Desktop-Tabelle) einen einzigen, über
+  alle Essenszeiten-Zeilen durchgehenden „Geschlossen"-Hinweis statt
+  einer Wiederholung in jeder einzelnen Zeile.
+
+## [1.12.0] – 2026-07-20
+
+### Hinzugefügt
+- Einzelne Tage als geschlossen markierbar (z. B. Feiertage,
+  Betriebsausflug) – im Wochenplan lässt sich pro Tag über „Tag
+  schließen" ein optionaler, mehrsprachiger Grund hinterlegen (inkl.
+  automatischer Übersetzung per DeepL, sofern konfiguriert). Ein
+  geschlossener Tag:
+  - blendet in der Gerichte-Verwaltung des Wochenplans „Mahlzeit
+    hinzufügen" für diesen Tag aus (bestehende Einträge lassen sich
+    weiterhin entfernen), lässt sich per „Wieder öffnen" jederzeit
+    rückgängig machen.
+  - zeigt auf der öffentlichen Speisekarte (Desktop-Tabelle und
+    mobile Ansicht) einen „Geschlossen"-Hinweis mit Grund statt der
+    Essenszeiten-Spalten/-Karte für diesen Tag.
+  - erscheint im RSS-Feed als eigener Eintrag mit Schließungsgrund
+    statt eines leeren oder fehlenden Tages.
+  - Neue Tabellen `closed_days`/`closed_day_translations` (Migration
+    `0007_closed_days.sql`).
+
 ## [1.11.1] – 2026-07-20

 ### Behoben
@@ -0,0 +1,305 @@
+# Was kann die Speisekarte?
+
+Vorstellung aller Funktionen der digitalen Kantinen-Speisekarte
+(Stand Version 1.12.1). Technische Details zur Installation stehen in
+[DEPLOYMENT.md](DEPLOYMENT.md), die Änderungen je Version in
+[CHANGELOG.md](CHANGELOG.md).
+
+## In einem Satz
+
+Eine selbst gehostete Web-Anwendung, mit der das Kantinen-Team den
+Wochenplan pflegt und alle Mitarbeiter ihn ohne Login am PC oder Handy
+lesen können – dreisprachig, mit Allergen-Kennzeichnung, RSS-Abo,
+Rezeptvorschlägen und eigenem Branding.
+
+Drei Bereiche mit getrennten Rechten:
+
+| Bereich | Wer | Zweck |
+| --- | --- | --- |
+| Öffentliche Speisekarte (`/`) | alle Mitarbeiter, ohne Login | Wochenplan lesen |
+| Kantinen-Bereich (`/intern`) | Kantinen-Team (`staff`) und Admins | Gerichte und Wochenplan pflegen |
+| Admin-Bereich (`/admin`) | nur Admins | Benutzer, Design, Sprachen |
+
+---
+
+## 1. Für alle Mitarbeiter: die öffentliche Speisekarte
+
+Erreichbar ohne Anmeldung – Link oder QR-Code genügt.
+
+**Wochenplan Montag bis Freitag**
+Tabelle mit einer Spalte je Wochentag und einer Zeile je Essenszeit
+(z. B. Brotzeit, Mittagessen, Mittagessen vegetarisch, Suppe). Pro
+Zelle können mehrere Gerichte stehen. Jedes Gericht wird mit Preis
+angezeigt.
+
+**Navigation**
+Buttons für vorherige Woche, nächste Woche und „Heute". Beliebige
+Wochen lassen sich so vor- und zurückblättern – auch als direkter Link
+(`/?woche=YYYY-MM-DD`), praktisch für Aushänge oder Bookmarks.
+
+**Handy-Ansicht**
+Auf schmalen Bildschirmen erscheint standardmäßig eine Tagesansicht mit
+Tab-Leiste (Mo–Fr) statt der Tabelle; auf Wunsch kann pro Besucher auf
+die Wochenansicht umgeschaltet werden. Die Desktop-Tabelle bleibt davon
+unberührt.
+
+**Allergene und Zusatzstoffe**
+Je Gericht erscheinen die Kürzel (z. B. `A`, `G`) direkt neben dem
+Namen, die vollständige Legende steht unterhalb der Karte. Alternativ
+lässt sich die Kennzeichnung auf einen einzelnen Hinweistext umstellen
+(siehe Abschnitt 2).
+
+**Geschlossene Tage**
+Feiertage, Betriebsausflüge oder Urlaub werden als „Geschlossen"
+angezeigt – ein einziges, über alle Essenszeiten-Zeilen durchgehendes
+Banner mit optionalem Grund („Betriebsferien"), statt leerer Zellen.
+
+**Sprachumschalter**
+Umschalten der kompletten Oberfläche zwischen den freigeschalteten
+Sprachen (ausgeliefert mit Deutsch, Englisch, Polnisch). Die Auswahl
+wird per Cookie gemerkt, die Seite muss dafür nicht neu geladen werden.
+Ist nur eine Sprache aktiv, verschwindet der Umschalter automatisch.
+
+**RSS-Feed zum Abonnieren**
+`/feed.xml` liefert einen Eintrag pro Tag (aktuelle und nächste Woche)
+mit allen Gerichten je Essenszeit inkl. Preis; geschlossene Tage
+erscheinen mit Schließungsgrund. Sichtbares RSS-Icon im Kopfbereich
+plus Autodiscovery im Seiten-`<head>`, damit Outlook, Thunderbird & Co.
+den Feed automatisch finden. Der Inhalt wird zusätzlich als
+`content:encoded` ausgeliefert, damit Reader ihn nicht nach der ersten
+Essenszeit abschneiden.
+
+**Rezept vorschlagen**
+Jeder Besucher kann ohne Login ein fehlendes Gericht vorschlagen (Name
+ optionale Beschreibung). Eingebaut: Dublettenprüfung gegen bestehende
+Gerichte und ein unsichtbares Honeypot-Feld als Spamschutz.
+
+**Eigenes Erscheinungsbild**
+Firmenlogo zentriert über der Karte, eigenes Favicon im Browser-Tab,
+Farben nach Corporate Design – alles vom Admin einstellbar, ohne
+Codeänderung.
+
+---
+
+## 2. Für das Kantinen-Team (`/intern`)
+
+Nach dem Login sichtbar, gemeinsame Navigation für alle Unterseiten,
+auf dem Handy als Hamburger-Menü.
+
+### Wochenplan
+
+- Gerichte per **Suchfeld** einer Zelle (Tag + Essenszeit) zuweisen –
+  keine langen Dropdown-Listen zum Durchscrollen.
+- Mehrere Gerichte pro Zelle, einzeln wieder entfernbar.
+- Wochen-Navigation inkl. „Heute"-Button wie in der öffentlichen Ansicht.
+- **Tag schließen**: Schloss-Symbol am Datum (🔓 schließt, 🔒 öffnet
+  wieder) mit optionalem, mehrsprachigem Grund. Für geschlossene Tage
+  wird „Mahlzeit hinzufügen" ausgeblendet; bereits eingetragene
+  Gerichte bleiben entfernbar.
+- Auf dem Handy Tag-für-Tag-Ansicht mit Tab-Leiste; beide Ansichten
+  teilen denselben Bearbeitungsstand.
+
+### Gerichte
+
+- Anlegen, bearbeiten, löschen – mit Name, Preis, Allergenen und
+  Zusatzstoffen (Chip-Auswahl).
+- **Live-Suche** in der Gerichteliste.
+- **Mehrfachauswahl** zum Löschen vieler Gerichte in einem Schritt.
+- Ein Namensfeld je aktiver Sprache, mit Button **„Automatisch
+  übersetzen"** (DeepL) – das Ergebnis bleibt danach frei korrigierbar.
+- **CSV-Export/-Import**: aktuelle Liste als CSV herunterladen,
+  bearbeiten, wieder hochladen. Spalten
+  `name,name_en,…,price,allergens,additives` (Kürzel semikolongetrennt,
+  z. B. `A;G`), Spaltenreihenfolge und Groß-/Kleinschreibung der
+  Kopfzeile egal. Bestehende Gerichte werden über den Namen erkannt und
+  aktualisiert, neue angelegt. Fehlerhafte Zeilen (Pflichtfeld fehlt,
+  ungültiger Preis, mehrdeutiger Name) werden übersprungen und mit
+  Grund aufgelistet, statt den ganzen Import abzubrechen.
+
+### Essenszeiten
+
+Vollständig verwaltbar statt fest im Code: anlegen, umbenennen (je
+Sprache), Uhrzeit ändern, per Pfeil-Buttons neu anordnen, löschen.
+Beim Löschen werden zugewiesene Gerichte automatisch aus allen
+Wochenplänen entfernt.
+
+### Allergene & Zusatzstoffe
+
+- Globale Listen pflegen (Kürzel + Name je Sprache, Sortierung),
+  ebenfalls mit DeepL-Übersetzung und CSV-Export/-Import.
+- **Zwei Betriebsmodi, umschaltbar:**
+  1. *Detailliert* – Auswahl je Gericht, Kürzel am Gericht, Legende
+     unter der Karte.
+  2. *Hinweistext* – ein einziger, mehrsprachig editierbarer Satz
+     (z. B. „Bei Fragen zu Allergenen und Zusatzstoffen wenden Sie sich
+     bitte an das Kantinen-Team."). Kürzel, Legende und die
+     Allergen-Auswahl in der Gerichteverwaltung verschwinden;
+     zugeordnete Daten bleiben in der Datenbank erhalten und sind beim
+     Zurückschalten wieder da.
+
+### Rezeptvorschläge
+
+Eingereichte Vorschläge sichten, direkt als Gericht **übernehmen** oder
+**ablehnen**. Die Anzahl offener Vorschläge steht als rote Zahl im
+Navigationspunkt „Vorschläge".
+
+### Eigenes Konto
+
+Name, E-Mail und Passwort ändern, Passkeys registrieren und entfernen,
+Passwort-Anmeldung für das eigene Konto abschalten.
+
+---
+
+## 3. Für Admins (`/admin`)
+
+### Benutzerverwaltung
+
+Kantinenmitarbeiter anlegen, bearbeiten und löschen; Rolle vergeben
+(Kantinenmitarbeiter oder Admin); Passwort zurücksetzen – jeweils mit
+Wiederholungsfeld gegen Tippfehler.
+
+### Design
+
+- Acht Farben per Farbwähler einstellbar: Primär, Primär dunkel,
+  Akzent, Kopfzeilentext, Zeilenhintergrund, Zeilenhintergrund
+  alternierend, Hinzufügen-Button, Löschen-Button. Auf Werkszustand
+  zurücksetzbar.
+- Logo und Favicon hochladen oder entfernen. Aus Sicherheitsgründen
+  nur Rasterformate (png/jpg/webp/gif/ico) – SVG ist bewusst nicht
+  erlaubt, da eingebettetes Script auf der eigenen Domain ausgeführt
+  würde.
+
+### Sprachen
+
+Sprachen sind zur Laufzeit verwaltbar, ohne neues Deployment:
+
+- Vorlage der deutschen Oberflächentexte herunterladen, übersetzt
+  wieder hochladen – die neue Sprache ist sofort aktiv.
+- Je Sprache wird **Vollständigkeit in %** angezeigt sowie „N neue
+  Begriffe seit letztem Import", falls eine App-Version zusätzliche
+  Texte mitgebracht hat. Fehlende Begriffe fallen automatisch auf
+  Deutsch zurück, bleiben also nie leer.
+- Neue Sprachen selbst anlegen (Code + Anzeigename). Sobald eine
+  Sprache aktiv ist, erscheint in der Gerichte-, Essenszeiten- und
+  Kennzeichnungsverwaltung automatisch ein Eingabefeld dafür – und im
+  CSV-Export eine zusätzliche Spalte (`name_fr`, …).
+- Sprachen einzeln deaktivieren, bis hinunter auf eine einzige;
+  Deutsch bleibt als garantiert vollständige Basissprache unlöschbar.
+- Der Import prüft die Datei gegen die aktuelle Vorlage: Platzhalter
+  wie `{message}` müssen erhalten bleiben, unbekannte Schlüssel werden
+  ignoriert statt einen Fehler zu werfen.
+
+---
+
+## 4. Anmeldung und Sicherheit
+
+**Drei Anmeldewege, kombinierbar**
+
+1. **E-Mail + Passwort** – Hashing mit `scrypt` aus der
+   Node-Standardbibliothek.
+2. **Passkey** (WebAuthn, z. B. Windows Hello, Face ID, Sicherheits-
+   schlüssel) – im eigenen Konto nach dem ersten Login registrierbar.
+   Die Passwort-Anmeldung lässt sich pro Konto abschalten, sobald
+   mindestens ein Passkey vorhanden ist; das wird serverseitig
+   erzwungen, nicht nur im Browser geprüft.
+3. **SSO per OpenID Connect** (z. B. gegen ein selbst gehostetes
+   Authentik) – Authorization-Code-Flow mit PKCE, Signaturprüfung des
+   ID-Tokens gegen das JWKS des Providers, State/Nonce serverseitig
+   kurzlebig und nur einmal verwendbar. Aktiviert sich über drei
+   Umgebungsvariablen; ohne sie bleibt der SSO-Button unsichtbar.
+   Wichtig: SSO legt **nie** neue Konten an und übernimmt **keine**
+   Rollen aus Claims – nur bereits unter „Benutzer" angelegte
+   E-Mail-Adressen kommen herein, die Rolle bleibt allein in der
+   Benutzerverwaltung steuerbar.
+
+**Sitzungen**
+Opake Tokens, nur als Hash in der Datenbank, Cookie mit
+`httpOnly`/`sameSite=lax`. Laufzeit 30 Tage mit gleitender
+Verlängerung: fällt die Restlaufzeit unter 7 Tage, wird sie beim
+nächsten Aufruf erneuert – statt bei jedem Request zu schreiben.
+
+**Zugriffsschutz**
+`/intern`, `/admin` und `/konto` sind serverseitig geschützt; jede
+API-Route prüft zusätzlich die Rolle. Öffentlich lesbar sind nur
+Speisekarte, Essenszeiten, Kennzeichnungen und Logo/Favicon.
+
+**Weitere Härtung**
+CSRF-Origin-Check, HTTP-Security-Header für alle Routen
+(`X-Frame-Options: DENY`, `frame-ancestors 'none'`, `nosniff`,
+`Referrer-Policy`, restriktive `Permissions-Policy`), Datenbank ohne
+Host-Port (nur im internen Docker-Netz erreichbar), Upload-Whitelist
+für Bildformate.
+
+**Erster Start**
+Ist die Datenbank leer, wird automatisch genau ein Admin mit
+Zufallspasswort angelegt und die Zugangsdaten nach `ZUGANGSDATEN.md`
+geschrieben (nicht im Repository). Klappt das Schreiben nicht, landen
+sie im Container-Log statt verloren zu gehen.
+
+---
+
+## 5. Mehrsprachigkeit im Detail
+
+Zwei Ebenen, beide zur Laufzeit erweiterbar:
+
+| Ebene | Was | Verwaltung |
+| --- | --- | --- |
+| Oberfläche | alle Buttons, Beschriftungen, Meldungen | Admin → Sprachen (Vorlage exportieren/importieren) |
+| Inhalte | Gerichtnamen, Essenszeiten, Allergene, Zusatzstoffe, Schließungsgründe | ein Feld je aktiver Sprache in der jeweiligen Verwaltung |
+
+Beides ist **nicht** auf Deutsch/Englisch/Polnisch begrenzt – eine neu
+angelegte Sprache erscheint automatisch überall. Übersetzungen können
+per DeepL vorbefüllt werden (in alle aktiven, von DeepL unterstützten
+Sprachen gleichzeitig) und bleiben danach manuell korrigierbar. Fehlt
+eine Übersetzung, greift der Deutsch-Fallback; ist Deutsch selbst
+deaktiviert, die erste aktive Sprache.
+
+DeepL ist optional: ohne `DEEPL_API_KEY` verschwindet nur der Button
+„Automatisch übersetzen", alle Felder bleiben von Hand ausfüllbar.
+
+---
+
+## 6. Betrieb
+
+- **Vollständig selbst gehostet.** Einzige optionale externe
+  Abhängigkeit ist DeepL. Keine Cloud-Datenbank, kein
+  Auth-Dienstleister, kein Storage-Anbieter.
+- **Stack:** Next.js 16 (App Router, TypeScript, Tailwind CSS),
+  PostgreSQL über `pg` mit eigenen SQL-Migrationen.
+- **Docker Compose** für Produktion und Entwicklung (Dev-Profil mit
+  Hot-Reload, ohne lokal installiertes Node.js/PostgreSQL).
+- **Migrationen laufen bei jedem Start automatisch** und idempotent –
+  ein Update braucht keinen manuellen Datenbankschritt.
+- **`update.sh`** für Linux-Deployments: Stack stoppen, lokale
+  Änderungen an `docker-compose.yml` sichern, `git pull`, Änderungen
+  zurückspielen, neu bauen und starten. Bricht bei Konflikten
+  kontrolliert ab, statt mit halbem Stand weiterzulaufen.
+- **`npm run db:seed-demo`** spielt einen Beispieldatensatz für Demos
+  ein (Essenszeiten, Kennzeichnungen, Testgerichte, zwei Wochen).
+  Frische Deployments starten bewusst leer.
+- **Versionsnummer im Fußbereich** jeder Seite, Git-Tags markieren die
+  Versionsstände.
+
+---
+
+## 7. Wann kam was
+
+| Version | Kern |
+| --- | --- |
+| 1.0.0 | Öffentliche Speisekarte, Login (Passwort + Passkey), Kantinen- und Admin-Bereich, Docker-Setup |
+| 1.1.0 | Versionsnummer im Fußbereich |
+| 1.2.0 | „Heute"-Button, mobile Tages-/Wochenansicht, Allergen-Chips, Passwort-Wiederholung, Favicon, `SITE_TITLE` |
+| 1.3.0 | Mehrsprachigkeit DE/EN/PL, DeepL, Rezeptvorschläge inkl. Sichtung |
+| 1.4.0 | Essenszeiten frei verwaltbar |
+| 1.5.0 | Supabase komplett entfernt – eigene Datenbank, Auth, Passkeys, Datei-Ablage |
+| 1.6.x | RSS-Feed, Vorschläge-Badge, DEPLOYMENT.md, DB-Port geschlossen, Bugfixes |
+| 1.7.0 | CSV-Import/-Export für Gerichte, Allergene, Zusatzstoffe |
+| 1.8.x | Umschaltbarer Hinweismodus für Kennzeichnungen, `update.sh` |
+| 1.9.0 | SSO per OpenID Connect |
+| 1.9.5 | Interner Bereich für Mobilgeräte nutzbar |
+| 1.10.0 | Sprachen zur Laufzeit verwaltbar (Oberfläche) |
+| 1.11.x | Sprachen zur Laufzeit verwaltbar (Inhalte), Sprach-Fallback-Fix |
+| 1.12.x | Tage als geschlossen markierbar, Schloss-Symbol und durchgehendes Banner |
+
+Ausführlich in [CHANGELOG.md](CHANGELOG.md), der Zeitaufwand je Version
+in [ZEITAUFWAND.md](ZEITAUFWAND.md).
@@ -0,0 +1,54 @@
+# Zeitaufwand
+
+Übersicht, wie lange die Umsetzung der einzelnen Versionen mit Claude
+gedauert hat, zum Vergleich mit der Schätzung für einen erfahrenen
+Entwickler ohne KI-Unterstützung. Wird bei jeder neuen Version
+ergänzt.
+
+## Methodik
+
+- **„Zeit bei Claude"** basiert auf den Git-Commit-Zeitstempeln
+  zwischen zwei Versions-Tags. Das ist kein reiner Rechenzeit-Wert,
+  sondern enthält auch die Zeit, die der Nutzer zum Lesen/Antworten
+  gebraucht hat – aber es ist der einzige objektiv messbare Anhaltspunkt.
+- Große Lücken zwischen zwei Tags (mehrere Stunden bis über einen Tag)
+  markieren eindeutig eine neue Sitzung, kein durchgehendes Arbeiten –
+  diese sind als „neue Sitzung" markiert statt als Zeitangabe.
+- **„Erfahrener Entwickler"** ist eine grobe Schätzung für jemanden,
+  der mit dem Stack (Next.js, PostgreSQL, TypeScript) vertraut, aber
+  neu in diesem Projekt ist, inkl. Testen/Verifikation, exkl. Code-Review
+  durch Dritte.
+
+## Übersicht
+
+| Version | Datum | Kern der Version | Zeit bei Claude | Erfahrener Entwickler |
+|---|---|---|---|---|
+| v1.0.0/v1.1.0 | 17.07. | Grundgerüst: öffentliche Speisekarte, Login (Passwort+Passkey), Kantinen-/Admin-Bereich, Supabase-Schema+RLS, Docker-Setup, lokale PG-Kopie | nicht messbar (erster Commit) | 3–5 Tage (24–40 h) |
+| v1.2.0 | 18.07. | Heute-Button, mobile Tages-/Wochenansicht, Allergen-Chips, Passwort-Wiederholung, Passkey-Pflicht, SITE_TITLE/Favicon, UX-Politur | 56 min | 1–1,5 Tage (8–12 h) |
+| v1.3.0 | 18.07. | Volle Mehrsprachigkeit DE/EN/PL, DeepL-Anbindung, Rezeptvorschläge (öffentlich + Sichtung), 2 Bugfixes | 1 h 23 min | 1,5–2 Tage (12–16 h) |
+| v1.4.0 | 18.07. | Essenszeiten variabel (CRUD + Sortierung), 2 Bugfixes | *(neue Sitzung)* | 0,5–1 Tag (4–8 h) |
+| v1.5.0 | 18.07. | **Supabase komplett entfernt**: eigene DB/Auth/Passkeys/Storage, 2 Sicherheitsfixes (Passkey-Pflicht serverseitig, SVG-XSS) | 3 h 26 min | 2–3 Tage (16–24 h) |
+| v1.6.0 | 18.07. | RSS-Feed, Vorschläge-Badge, DEPLOYMENT.md, Supabase-Doku-Reste entfernt | 33 min | 0,5–1 Tag (4–8 h) |
+| v1.6.1 | 18.07. | DB-Port abgesichert, Troubleshooting-Doku | 1 h 58 min | 1–2 h |
+| v1.6.2 | 18.07. | Bootstrap-Admin-Fehlerbehandlung + Doku-Fix | 22 min | 1–2 h |
+| v1.6.3 | 18.07. | Docker `BRANDING_DIR`-Bugfix | 20 min | 0,5–1 h |
+| v1.7.0 | 19.07. | CSV-Import/-Export (3 Ressourcen), RSS-Fix | *(neue Sitzung)* | 0,5–1 Tag (4–8 h) |
+| v1.8.0 | 19.07. | Umschaltbarer Hinweismodus für Allergene/Zusatzstoffe | 45 min | 0,5–1 Tag (4–6 h) |
+| v1.8.1 | 20.07. | `update.sh` Deployment-Skript | 10 min | 1–2 h |
+| v1.9.0 | 20.07. | SSO-Login per OpenID Connect (PKCE, JWKS-Prüfung) | 26 min | 1–1,5 Tage (8–12 h) |
+| v1.9.5 | 20.07. | Interner Bereich mobil nutzbar (Hamburger-Nav, Tab-Wochenansicht, 5 Komponenten) | 21 min | 1 Tag (6–10 h) |
+| v1.10.0 | 20.07. | Dynamisches Sprachpaket-System (Teil 1 Mehrsprachig-Umbau) | *(neue Sitzung)* | 1–1,5 Tage (8–12 h) |
+| v1.11.0 | 20.07. | Speiseplan-Inhalte variabel (Teil 2, inkl. Produktionsdaten-Migration) | 35 min | 1–1,5 Tage (8–12 h) |
+| v1.11.1 | 20.07. | Sprach-Fallback-Bugfix (deaktiviertes Deutsch) | 12 min | 0,5–1,5 h |
+| v1.12.0 | 20.07. | Tage als geschlossen markierbar (Feiertage o. Ä.), mehrsprachiger Grund, RSS-Integration | 1 h 12 min | 0,5–1 Tag (4–8 h) |
+| v1.12.1 | 20.07. | Schloss-Symbol statt Textlink, durchgehendes Geschlossen-Banner über alle Essenszeiten | 14 min | 2–4 h |
+| **Gesamt** | | | **~12,3 h messbare aktive Zeit** (+ 1 nicht messbarer Grundgerüst-Block) | **~114–187 h ≈ 15–24 Arbeitstage** (real eher 1–2 Monate Kalenderzeit) |
+
+## Warum der Unterschied?
+
+Der Zeitvorteil kommt vor allem daher, dass zwischen Planung,
+Umsetzung und Test keine Wartezeit liegt (Code-Review, Freigaben,
+andere Aufgaben dazwischen) – nicht daher, dass grundsätzlich
+"schneller gedacht" wird. Ein Mensch bräuchte für dieselbe Sorgfalt
+vermutlich nicht weniger Zeit pro Aufgabe, aber deutlich mehr
+Kalenderzeit durch Kontextwechsel.
@@ -0,0 +1,23 @@
+import { NextResponse } from "next/server";
+import { removeClosedDay } from "@/lib/db/closed-days";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function DELETE(
+  request: Request,
+  { params }: { params: Promise<{ date: string }> }
+) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const { date } = await params;
+    await removeClosedDay(date);
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -0,0 +1,34 @@
+import { NextResponse } from "next/server";
+import { listClosedDays, setClosedDay } from "@/lib/db/closed-days";
+import { authErrorResponse, requireRole } from "@/lib/auth/session";
+import { isSameOrigin } from "@/lib/origin";
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const from = searchParams.get("from");
+  const to = searchParams.get("to");
+  if (!from || !to) {
+    return NextResponse.json({ error: "invalid_input" }, { status: 400 });
+  }
+  return NextResponse.json(await listClosedDays(from, to));
+}
+
+export async function POST(request: Request) {
+  if (!isSameOrigin(request)) {
+    return NextResponse.json({ error: "Nicht erlaubt." }, { status: 403 });
+  }
+  try {
+    await requireRole(["staff", "admin"]);
+    const body = (await request.json()) as {
+      closed_date: string;
+      reason: string | null;
+      translations?: Record<string, string | null>;
+    };
+    const closedDay = await setClosedDay(body.closed_date, body.reason, body.translations);
+    return NextResponse.json(closedDay, { status: 201 });
+  } catch (err) {
+    const res = authErrorResponse(err);
+    if (res) return res;
+    throw err;
+  }
+}
@@ -14,6 +14,7 @@ const ALLOWED_TABLES: Record<string, { idColumn: string; translationTable: Trans
  sections: { idColumn: "key", translationTable: "section_translations" },
  allergens: { idColumn: "code", translationTable: "allergen_translations" },
  additives: { idColumn: "code", translationTable: "additive_translations" },
+  closed_days: { idColumn: "closed_date", translationTable: "closed_day_translations" },
 };

 // Unsere Sprachcodes -> DeepL target_lang. Sprachen ohne Eintrag hier sind
@@ -1,5 +1,6 @@
 import { query } from "@/lib/db";
 import { loadMenuEntries } from "@/lib/db/menu-entries";
+import { listClosedDays } from "@/lib/db/closed-days";
 import { addDays, entriesFor, formatPrice, mondayOf, todayISO } from "@/lib/menu";
 import { localized, SITE_TITLE } from "@/lib/types";
 import type { Section } from "@/lib/types";
@@ -45,16 +46,24 @@ export async function GET() {
  // Wochennavigation anzeigt.
  const rangeEnd = addDays(monday, 11);

-  const [sections, entries] = await Promise.all([
+  const [sections, entries, closedDays] = await Promise.all([
    query<Section>("select * from sections order by sort"),
    loadMenuEntries(monday, rangeEnd),
+    listClosedDays(monday, rangeEnd),
  ]);

-  const days = Array.from(new Set(entries.map((e) => e.menu_date))).sort();
+  const days = Array.from(
+    new Set([...entries.map((e) => e.menu_date), ...closedDays.map((c) => c.closed_date)])
+  ).sort();

  const items = days
    .map((iso) => {
-      const dayContent = sections
+      const closed = closedDays.find((c) => c.closed_date === iso);
+      const dayContent = closed
+        ? `<p><strong>Geschlossen</strong>${
+            closed.reason ? ` – ${escapeXml(closed.reason)}` : ""
+          }</p>`
+        : sections
            .map((s) => {
              const dishes = entriesFor(entries, iso, s.key);
              if (dishes.length === 0) return "";
@@ -102,6 +102,10 @@ body {
  font-size: 0.85rem;
 }
 .menu-table tr:nth-child(even) td.cell { background: var(--c-row-bg-alt); }
+.menu-table td.cell.closed-cell {
+  vertical-align: middle;
+  background: #fee2e2;
+}
 .menu-table td.cell .dish { margin-bottom: 0.35rem; }
 .menu-table td.cell .dish sup {
  font-size: 0.6rem;
@@ -7,5 +7,10 @@ export default async function InternPage({
  searchParams: Promise<{ woche?: string }>;
 }) {
  const { woche } = await searchParams;
-  return <WeekEditor monday={mondayOf(woche)} />;
+  return (
+    <WeekEditor
+      monday={mondayOf(woche)}
+      translateEnabled={!!process.env.DEEPL_API_KEY}
+    />
+  );
 }
@@ -2,6 +2,7 @@ import Link from "next/link";
 import { query } from "@/lib/db";
 import { loadMenuEntries } from "@/lib/db/menu-entries";
 import { loadTranslations } from "@/lib/db/translations";
+import { listClosedDays } from "@/lib/db/closed-days";
 import { getSettings } from "@/lib/db/settings";
 import {
  addDays,
@@ -43,6 +44,7 @@ export default async function Home({
    sectionTranslations,
    allergenTranslations,
    additiveTranslations,
+    closedDays,
  ] = await Promise.all([
    query<Omit<Section, "translations">>("select key, label, time_range, sort from sections order by sort"),
    loadMenuEntries(monday, friday),
@@ -52,7 +54,9 @@ export default async function Home({
    loadTranslations("section_translations"),
    loadTranslations("allergen_translations"),
    loadTranslations("additive_translations"),
+    listClosedDays(monday, friday),
  ]);
+  const closedDayFor = (iso: string) => closedDays.find((c) => c.closed_date === iso);

  const sections: Section[] = sectionRows.map((s) => ({
    ...s,
@@ -130,6 +134,7 @@ export default async function Home({
        monday={monday}
        sections={sections}
        entries={entries}
+        closedDays={closedDays}
        showLabeling={labelingDetailed}
      />

@@ -165,13 +170,33 @@ export default async function Home({
              </tr>
            </thead>
            <tbody>
-              {sections.map((s) => (
+              {sections.map((s, sIdx) => (
                <tr key={s.key}>
                  <th className="section-head">
                    <div>{localized(s, locale)}</div>
                    <div className="time">{s.time_range}</div>
                  </th>
-                  {days.map((d) => (
+                  {days.map((d) => {
+                    const closed = closedDayFor(d.iso);
+                    if (closed) {
+                      if (sIdx > 0) return null;
+                      return (
+                        <td key={d.iso} className="cell closed-cell" rowSpan={sections.length}>
+                          <div className="flex flex-col items-center justify-center gap-1 py-4 text-red-700">
+                            <span className="text-2xl" aria-hidden>
+                              🔒
+                            </span>
+                            <span className="font-semibold">{dict.publicMenu.closedLabel}</span>
+                            {localized(closed, locale) && (
+                              <span className="text-sm px-2 text-center">
+                                {localized(closed, locale)}
+                              </span>
+                            )}
+                          </div>
+                        </td>
+                      );
+                    }
+                    return (
                      <td key={d.iso} className="cell">
                        {entriesFor(entries, d.iso, s.key).map((e) => {
                          const codes = dishCodes(e.dish);
@@ -189,7 +214,8 @@ export default async function Home({
                          );
                        })}
                      </td>
-                  ))}
+                    );
+                  })}
                </tr>
              ))}
            </tbody>
@@ -19,7 +19,7 @@ import {
  weekdayIndex,
 } from "@/lib/menu";
 import { localized } from "@/lib/types";
-import type { MenuEntry, Section } from "@/lib/types";
+import type { ClosedDay, MenuEntry, Section } from "@/lib/types";
 import { useDict, useLocale } from "@/components/i18n/LocaleProvider";
 import LanguageSwitcher from "@/components/i18n/LanguageSwitcher";

@@ -27,11 +27,13 @@ export default function PublicMobileMenu({
  monday,
  sections,
  entries,
+  closedDays,
  showLabeling,
 }: {
  monday: string;
  sections: Section[];
  entries: MenuEntry[];
+  closedDays: ClosedDay[];
  showLabeling: boolean;
 }) {
  const router = useRouter();
@@ -60,11 +62,19 @@ export default function PublicMobileMenu({
  }

  function renderDay(day: { weekday: string; iso: string }) {
+    const closed = closedDays.find((c) => c.closed_date === day.iso);
    return (
      <div key={day.iso} className="mb-4 last:mb-0">
        <h3 className="font-bold text-[var(--c-primary)] mb-2">
          {day.weekday} · {formatDateLong(day.iso, dict.dateLocale)}
        </h3>
+        {closed ? (
+          <div className="rounded-md border border-red-200 bg-red-50 px-3 py-3 text-sm text-red-700 text-center">
+            <span aria-hidden>🔒</span>{" "}
+            <span className="font-semibold">{dict.publicMenu.closedLabel}</span>
+            {localized(closed, locale) && <span> – {localized(closed, locale)}</span>}
+          </div>
+        ) : (
          <div className="space-y-3">
            {sections.map((s) => {
              const items = entriesFor(entries, day.iso, s.key);
@@ -101,6 +111,7 @@ export default function PublicMobileMenu({
              );
            })}
          </div>
+        )}
      </div>
    );
  }
@@ -14,12 +14,19 @@ import {
 } from "@/lib/menu";
 import { formatMessage } from "@/lib/i18n/shared";
 import { localized } from "@/lib/types";
-import type { Dish, MenuEntry, Section } from "@/lib/types";
-import { useDict, useLocale } from "@/components/i18n/LocaleProvider";
+import type { ClosedDay, Dish, MenuEntry, Section } from "@/lib/types";
+import { useDict, useLanguages, useLocale } from "@/components/i18n/LocaleProvider";

-export default function WeekEditor({ monday }: { monday: string }) {
+export default function WeekEditor({
+  monday,
+  translateEnabled,
+}: {
+  monday: string;
+  translateEnabled: boolean;
+}) {
  const dict = useDict();
  const locale = useLocale();
+  const languages = useLanguages().filter((l) => l.code !== "de");
  const friday = addDays(monday, 4);
  const days = dict.weekdays.long.map((weekday, i) => ({
    weekday,
@@ -32,6 +39,7 @@ export default function WeekEditor({ monday }: { monday: string }) {
  const [sections, setSections] = useState<Section[]>([]);
  const [dishes, setDishes] = useState<Dish[]>([]);
  const [entries, setEntries] = useState<MenuEntry[]>([]);
+  const [closedDays, setClosedDays] = useState<ClosedDay[]>([]);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);
  // Zelle, in der gerade ein Gericht hinzugefügt wird
@@ -43,6 +51,19 @@ export default function WeekEditor({ monday }: { monday: string }) {
  // Mobil: ein Tag auf einmal statt aller fünf gleichzeitig
  const [selectedDayIdx, setSelectedDayIdx] = useState(todayIdx >= 0 ? todayIdx : 0);

+  // Tag, für den gerade das Schließen-Formular offen ist
+  const [closingIso, setClosingIso] = useState<string | null>(null);
+  const [closeReason, setCloseReason] = useState("");
+  const [closeTranslations, setCloseTranslations] = useState<Record<string, string>>({});
+  const [closeTranslateState, setCloseTranslateState] = useState<"idle" | "busy" | "done">(
+    "idle"
+  );
+  const [closeBusy, setCloseBusy] = useState(false);
+
+  function closedDayFor(iso: string): ClosedDay | undefined {
+    return closedDays.find((c) => c.closed_date === iso);
+  }
+
  function startAdding(iso: string, section: string) {
    setAdding({ iso, section });
    setSelectedDish("");
@@ -57,17 +78,19 @@ export default function WeekEditor({ monday }: { monday: string }) {

  const load = useCallback(async () => {
    setError(null);
-    const [se, di, en] = await Promise.all([
+    const [se, di, en, cd] = await Promise.all([
      fetch("/api/sections"),
      fetch("/api/dishes"),
      fetch(`/api/menu-entries?from=${monday}&to=${friday}`),
+      fetch(`/api/closed-days?from=${monday}&to=${friday}`),
    ]);
-    if (!se.ok || !di.ok || !en.ok) {
+    if (!se.ok || !di.ok || !en.ok || !cd.ok) {
      setError(formatMessage(dict.weekEditor.loadError, { message: "load failed" }));
    } else {
      setSections(await se.json());
      setDishes(await di.json());
      setEntries(await en.json());
+      setClosedDays(await cd.json());
    }
    setLoading(false);
  }, [monday, friday, dict]);
@@ -107,6 +130,77 @@ export default function WeekEditor({ monday }: { monday: string }) {
    await load();
  }

+  function startClosing(iso: string) {
+    const existing = closedDayFor(iso);
+    setClosingIso(iso);
+    setCloseReason(existing?.reason ?? "");
+    setCloseTranslations({ ...(existing?.translations ?? {}) });
+    setCloseTranslateState("idle");
+  }
+
+  function cancelClosing() {
+    setClosingIso(null);
+  }
+
+  async function saveClosing() {
+    if (!closingIso) return;
+    setCloseBusy(true);
+    setError(null);
+    const res = await fetch("/api/closed-days", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        closed_date: closingIso,
+        reason: closeReason.trim() || null,
+        translations: closeTranslations,
+      }),
+    });
+    setCloseBusy(false);
+    if (!res.ok) {
+      setError(formatMessage(dict.weekEditor.saveError, { message: String(res.status) }));
+      return;
+    }
+    setClosingIso(null);
+    await load();
+  }
+
+  async function reopenDay(iso: string) {
+    setCloseBusy(true);
+    setError(null);
+    const res = await fetch(`/api/closed-days/${iso}`, { method: "DELETE" });
+    setCloseBusy(false);
+    if (!res.ok) {
+      setError(formatMessage(dict.weekEditor.deleteError, { message: String(res.status) }));
+      return;
+    }
+    if (closingIso === iso) setClosingIso(null);
+    await load();
+  }
+
+  async function autoTranslateClosing() {
+    if (!closingIso || !closeReason.trim()) return;
+    setCloseTranslateState("busy");
+    setError(null);
+    try {
+      const res = await fetch("/api/translate", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          table: "closed_days",
+          id: closedDayFor(closingIso) ? closingIso : null,
+          text: closeReason.trim(),
+        }),
+      });
+      const data = await res.json();
+      if (!res.ok) throw new Error(data?.error ?? `Fehler (${res.status})`);
+      setCloseTranslations((prev) => ({ ...prev, ...(data.translations ?? {}) }));
+      setCloseTranslateState("done");
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+      setCloseTranslateState("idle");
+    }
+  }
+
  const [hintBefore, hintAfter] = dict.weekEditor.newDishesHint.split("{link}");
  const selectedDishObj = dishes.find((d) => d.id === selectedDish) ?? null;
  const query = dishSearch.trim().toLowerCase();
@@ -114,6 +208,132 @@ export default function WeekEditor({ monday }: { monday: string }) {
    ? dishes.filter((d) => localized(d, locale).toLowerCase().includes(query))
    : dishes;

+  // Kleines Schloss-Symbol neben dem Tagesdatum: 🔓 zum Schließen
+  // anklicken, 🔒 zeigt einen geschlossenen Tag und öffnet ihn per Klick
+  // wieder – der Zustand des Symbols selbst ist die Beschriftung.
+  function renderClosureToggle(iso: string) {
+    const closed = Boolean(closedDayFor(iso));
+    return (
+      <button
+        type="button"
+        className="mt-0.5 text-base leading-none align-middle opacity-70 hover:opacity-100 disabled:opacity-40"
+        onClick={() => (closed ? reopenDay(iso) : startClosing(iso))}
+        disabled={closeBusy}
+        title={closed ? dict.weekEditor.reopenDay : dict.weekEditor.closeDay}
+        aria-label={closed ? dict.weekEditor.reopenDay : dict.weekEditor.closeDay}
+      >
+        {closed ? "🔒" : "🔓"}
+      </button>
+    );
+  }
+
+  // Banner, das bei einem geschlossenen Tag alle Essenszeiten-Zellen
+  // dieses Tages ersetzt (Desktop: eine über rowSpan verbundene Zelle,
+  // Mobil: anstelle der Essenszeiten-Karten) – "Bearbeiten" öffnet das
+  // Formular erneut, um nur den Grund anzupassen, ohne den Tag über das
+  // Symbol im Header erst wieder öffnen zu müssen.
+  function renderClosedBanner(iso: string, closed: ClosedDay) {
+    return (
+      <div className="flex flex-col items-center justify-center gap-1 py-4 text-red-700">
+        <span className="text-2xl" aria-hidden>
+          🔒
+        </span>
+        <span className="font-semibold">{dict.weekEditor.closedLabel}</span>
+        {closed.reason && <span className="text-sm px-2 text-center">{closed.reason}</span>}
+        <button
+          type="button"
+          className="mt-1 text-xs text-gray-500 hover:text-[var(--c-primary)] underline"
+          onClick={() => startClosing(iso)}
+        >
+          {dict.common.edit}
+        </button>
+      </div>
+    );
+  }
+
+  // Formular zum Schließen/Bearbeiten eines Tages – ein gemeinsames
+  // Formular für Desktop-Tabelle und mobile Tagesansicht, da immer nur
+  // ein Tag gleichzeitig bearbeitet werden kann.
+  function renderClosingForm() {
+    if (!closingIso) return null;
+    const day = days.find((d) => d.iso === closingIso);
+    return (
+      <form
+        onSubmit={(e) => {
+          e.preventDefault();
+          saveClosing();
+        }}
+        className="card mb-4 space-y-3"
+      >
+        <h2 className="font-semibold">
+          {dict.weekEditor.closeDay}: {day?.weekday} ·{" "}
+          {formatDateLong(closingIso, dict.dateLocale)}
+        </h2>
+        <div>
+          <label className="label" htmlFor="closed-reason">
+            {dict.weekEditor.closedReasonLabel}
+          </label>
+          <input
+            id="closed-reason"
+            className="input"
+            placeholder={dict.weekEditor.closedReasonPlaceholder}
+            value={closeReason}
+            onChange={(e) => setCloseReason(e.target.value)}
+          />
+        </div>
+        {languages.length > 0 && (
+          <div className="grid gap-3 sm:grid-cols-2">
+            {languages.map((lang) => (
+              <div key={lang.code}>
+                <label className="label" htmlFor={`closed-reason-${lang.code}`}>
+                  {lang.label}
+                </label>
+                <input
+                  id={`closed-reason-${lang.code}`}
+                  className="input"
+                  value={closeTranslations[lang.code] ?? ""}
+                  onChange={(e) =>
+                    setCloseTranslations({
+                      ...closeTranslations,
+                      [lang.code]: e.target.value,
+                    })
+                  }
+                />
+              </div>
+            ))}
+          </div>
+        )}
+        {translateEnabled && languages.length > 0 && (
+          <div>
+            <button
+              type="button"
+              className="btn btn-neutral"
+              onClick={autoTranslateClosing}
+              disabled={closeTranslateState === "busy" || !closeReason.trim()}
+            >
+              {closeTranslateState === "busy"
+                ? dict.dishManager.translating
+                : dict.dishManager.autoTranslate}
+            </button>
+            {closeTranslateState === "done" && (
+              <span className="ml-2 text-sm text-green-700">
+                {dict.dishManager.translated}
+              </span>
+            )}
+          </div>
+        )}
+        <div className="flex gap-2">
+          <button type="submit" className="btn btn-add" disabled={closeBusy}>
+            {dict.common.save}
+          </button>
+          <button type="button" className="btn btn-neutral" onClick={cancelClosing}>
+            {dict.common.cancel}
+          </button>
+        </div>
+      </form>
+    );
+  }
+
  // Inhalt einer Tag/Essenszeit-Zelle: Eintragsliste + "hinzufügen"-Flow.
  // Identisches Fragment für Desktop-Tabelle und Mobile-Karten, damit der
  // Bearbeitungs-Zustand (adding/selectedDish/dishSearch) nicht dupliziert
@@ -250,6 +470,7 @@ export default function WeekEditor({ monday }: { monday: string }) {
          {error}
        </p>
      )}
+      {renderClosingForm()}
      {loading ? (
        <p className="text-gray-500">{dict.weekEditor.loading}</p>
      ) : (
@@ -272,9 +493,20 @@ export default function WeekEditor({ monday }: { monday: string }) {
                </button>
              ))}
            </div>
-            <h2 className="font-bold text-[var(--c-primary)] mb-2">
-              {selectedDay.weekday} · {formatDateLong(selectedDay.iso, dict.dateLocale)}
+            <h2 className="font-bold text-[var(--c-primary)] mb-1">
+              {selectedDay.weekday} · {formatDateLong(selectedDay.iso, dict.dateLocale)}{" "}
+              {renderClosureToggle(selectedDay.iso)}
            </h2>
+            {(() => {
+              const closed = closedDayFor(selectedDay.iso);
+              if (closed) {
+                return (
+                  <div className="rounded-md border border-red-200 bg-red-50">
+                    {renderClosedBanner(selectedDay.iso, closed)}
+                  </div>
+                );
+              }
+              return (
                <div className="space-y-3">
                  {sections.map((s) => (
                    <div key={s.key} className="rounded-md border border-gray-200 overflow-hidden">
@@ -288,6 +520,8 @@ export default function WeekEditor({ monday }: { monday: string }) {
                    </div>
                  ))}
                </div>
+              );
+            })()}
          </div>

          {/* Ab "sm": klassische Wochentabelle */}
@@ -300,23 +534,38 @@ export default function WeekEditor({ monday }: { monday: string }) {
                    <th key={d.iso} className="day-head">
                      <span className="font-bold">{d.weekday}</span>
                      <br />
-                      {formatDateLong(d.iso, dict.dateLocale)}
+                      {formatDateLong(d.iso, dict.dateLocale)} {renderClosureToggle(d.iso)}
                    </th>
                  ))}
                </tr>
              </thead>
              <tbody>
-                {sections.map((s) => (
+                {sections.map((s, sIdx) => (
                  <tr key={s.key}>
                    <th className="section-head">
                      <div>{localized(s, locale)}</div>
                      <div className="time">{s.time_range}</div>
                    </th>
-                    {days.map((d) => (
+                    {days.map((d) => {
+                      const closed = closedDayFor(d.iso);
+                      if (closed) {
+                        if (sIdx > 0) return null;
+                        return (
+                          <td
+                            key={d.iso}
+                            className="cell closed-cell"
+                            rowSpan={sections.length}
+                          >
+                            {renderClosedBanner(d.iso, closed)}
+                          </td>
+                        );
+                      }
+                      return (
                        <td key={d.iso} className="cell">
                          {renderCell(d.iso, s.key)}
                        </td>
-                    ))}
+                      );
+                    })}
                  </tr>
                ))}
              </tbody>
@@ -0,0 +1,18 @@
+-- Kantine an einzelnen Tagen als geschlossen markieren (Feiertage o. Ä.),
+-- mit optionalem, mehrsprachigem Grund. Ein Tag ohne Zeile hier gilt als
+-- regulär geöffnet.
+create table closed_days (
+  closed_date date primary key,
+  reason      text,
+  created_at  timestamptz not null default now()
+);
+
+-- Wert-Spalte heißt bewusst "name" (nicht "reason"), damit die generische
+-- Zugriffsschicht in lib/db/translations.ts unverändert funktioniert –
+-- dieselbe Konvention wie bei section_translations.name für sections.label.
+create table closed_day_translations (
+  closed_date   date not null references closed_days(closed_date) on delete cascade,
+  language_code text not null references languages(code) on delete cascade,
+  name          text not null,
+  primary key (closed_date, language_code)
+);
@@ -0,0 +1,50 @@
+import "server-only";
+import { query, queryOne } from "@/lib/db";
+import { loadTranslationsFor, replaceTranslations } from "./translations";
+import type { ClosedDay } from "@/lib/types";
+
+interface ClosedDayRow {
+  closed_date: string;
+  reason: string | null;
+}
+
+/** Geschlossene Tage in einem Zeitraum (für Wochenplan/öffentliche Speisekarte/RSS). */
+export async function listClosedDays(fromISO: string, toISO: string): Promise<ClosedDay[]> {
+  const rows = await query<ClosedDayRow>(
+    "select closed_date, reason from closed_days where closed_date between $1 and $2",
+    [fromISO, toISO]
+  );
+  if (rows.length === 0) return [];
+  const translations = await loadTranslationsFor(
+    "closed_day_translations",
+    rows.map((r) => r.closed_date)
+  );
+  return rows.map((r) => ({
+    ...r,
+    translations: translations.get(r.closed_date) ?? {},
+  }));
+}
+
+/** Tag als geschlossen markieren (oder bestehenden Grund aktualisieren). */
+export async function setClosedDay(
+  date: string,
+  reason: string | null,
+  translations?: Record<string, string | null>
+): Promise<ClosedDay> {
+  const row = (await queryOne<ClosedDayRow>(
+    `insert into closed_days (closed_date, reason) values ($1, $2)
+     on conflict (closed_date) do update set reason = excluded.reason
+     returning closed_date, reason`,
+    [date, reason]
+  ))!;
+  if (translations) {
+    await replaceTranslations("closed_day_translations", row.closed_date, translations);
+  }
+  const loaded = await loadTranslationsFor("closed_day_translations", [row.closed_date]);
+  return { ...row, translations: loaded.get(row.closed_date) ?? {} };
+}
+
+/** Tag wieder öffnen (löscht auch alle Übersetzungen des Grunds per Cascade). */
+export async function removeClosedDay(date: string): Promise<void> {
+  await query("delete from closed_days where closed_date = $1", [date]);
+}
@@ -11,13 +11,15 @@ export type TranslationTable =
  | "dish_translations"
  | "section_translations"
  | "allergen_translations"
-  | "additive_translations";
+  | "additive_translations"
+  | "closed_day_translations";

 const ID_COLUMN: Record<TranslationTable, string> = {
  dish_translations: "dish_id",
  section_translations: "section_key",
  allergen_translations: "allergen_code",
  additive_translations: "additive_code",
+  closed_day_translations: "closed_date",
 };

 /** Alle Übersetzungen einer Tabelle, gruppiert nach Eltern-ID. */
@@ -75,6 +75,7 @@ const de = {
    suggestDish: "Rezept vorschlagen",
    noEntry: "–",
    rssFeed: "RSS-Feed abonnieren",
+    closedLabel: "Geschlossen",
  },
  weekEditor: {
    title: "Wochenplan",
@@ -87,6 +88,11 @@ const de = {
    duplicateEntry: "Dieses Gericht ist an diesem Tag bereits zugewiesen.",
    saveError: "Speichern fehlgeschlagen: {message}",
    deleteError: "Löschen fehlgeschlagen: {message}",
+    closeDay: "Tag schließen",
+    reopenDay: "Wieder öffnen",
+    closedLabel: "Geschlossen",
+    closedReasonLabel: "Grund (optional)",
+    closedReasonPlaceholder: "z. B. Weihnachtsfeiertage",
  },
  dishManager: {
    title: "Gerichte",
@@ -50,11 +50,20 @@ export interface DishSuggestion {
  created_at: string;
 }

+export interface ClosedDay {
+  closed_date: string;
+  reason: string | null;
+  translations: Record<string, string>;
+}
+
 /** Übersetzten Namen für die aktuelle Sprache liefern, sonst Deutsch als Fallback. */
 export function localized(
  item: {
    name?: string;
    label?: string;
+    // Grund eines geschlossenen Tages (s. ClosedDay) – optional, anders
+    // als name/label bei den übrigen Inhaltstypen.
+    reason?: string | null;
    // Neue, dynamische Form (Gerichte/Essenszeiten/Allergene/
    // Zusatzstoffe, s. lib/db/translations.ts) – Sprachcode -> Text.
    translations?: Record<string, string>;
@@ -68,7 +77,7 @@ export function localized(
  },
  locale: string
 ): string {
-  const de = item.name ?? item.label ?? "";
+  const de = item.name ?? item.label ?? item.reason ?? "";
  if (locale === "de") return de;
  if (item.translations) return item.translations[locale] || de;
  if (locale === "en") return item.name_en || item.label_en || de;
@@ -1,6 +1,6 @@
 {
  "name": "canteen-menu",
-  "version": "1.11.1",
+  "version": "1.12.1",
  "private": true,
  "scripts": {
    "predev": "node --env-file-if-exists=.env.local db/migrate.mjs && node --env-file-if-exists=.env.local scripts/bootstrap-admin.mjs",
Author	SHA1	Message	Date
florian.wilde	dca4af2a0b	Merge docs/features: Vorstellung des Funktionsumfangs	2026-08-16 00:04:31 +02:00
florian.wildeandClaude Opus 5	c168d3cca3	docs: FEATURES.md - Vorstellung des Funktionsumfangs Dokumentiert alle implementierten Features als "Was kann die Speisekarte?"-Vorstellung: oeffentliche Speisekarte, Kantinen-Bereich, Admin-Bereich, Anmeldung/Sicherheit, Mehrsprachigkeit, Betrieb sowie eine kompakte Versionstabelle. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-08-16 00:04:24 +02:00
florian.wilde	10be022180	Merge docs/zeitaufwand: Zeitübersicht je Version	2026-07-20 12:52:16 +02:00
florian.wilde	1096993120	docs: ZEITAUFWAND.md - Zeitübersicht je Version Vergleich der Umsetzungszeit mit Claude gegen eine grobe Schätzung für einen erfahrenen Entwickler ohne KI-Unterstützung, je Version seit v1.0.0. Wird bei jeder neuen Version ergänzt.	2026-07-20 12:52:01 +02:00
florian.wilde	8b3921c50e	Merge fix/closed-day-icon-and-banner: Schloss-Symbol + durchgehendes Geschlossen-Banner	2026-07-20 12:49:46 +02:00
florian.wilde	63870ba2e6	fix: Schloss-Symbol statt Text + durchgehendes Geschlossen-Banner Ersetzt den "Tag schließen"-Textlink durch ein Schloss-Symbol (🔓/🔒) und lässt den "Geschlossen"-Hinweis eines geschlossenen Tages über alle Essenszeiten-Zeilen durchlaufen (per rowSpan), statt ihn in jeder Zeile einzeln zu wiederholen – sowohl im Wochenplan als auch auf der öffentlichen Speisekarte.	2026-07-20 12:49:04 +02:00
florian.wilde	e9d4b51fce	Merge feature/v1.12.0: Tage als geschlossen markierbar (Feiertage o. Ä.)	2026-07-20 12:35:31 +02:00
florian.wilde	2a2c5affd5	feat: Tage als geschlossen markierbar (Feiertage o. Ä.) Im Wochenplan lässt sich pro Tag ein optionaler, mehrsprachiger Schließungsgrund hinterlegen. Geschlossene Tage werden auf der öffentlichen Speisekarte (Desktop + mobil) und im RSS-Feed als "Geschlossen" statt mit Essenszeiten angezeigt, im Wochenplan bleibt "Mahlzeit hinzufügen" für diesen Tag deaktiviert.	2026-07-20 12:35:00 +02:00