.gitignore

@@ -26,4 +26,3 @@ player/agent/morz-agent
 
 # Git worktrees
 .worktrees/
-.worktrees/

docs/API-ENDPOINTS.md

@@ -587,93 +587,6 @@ Der Scheduler prüft jede Minute, ob die aktuelle Uhrzeit mit `power_on_time` od
 
 ---
 
-### Globaler Override
-
-| Methode | Pfad | Auth | Beschreibung |
-|---------|------|------|--------------|
-| GET | `/api/v1/global-override` | authUser | Aktiven Override abrufen (204 wenn keiner aktiv) |
-| POST | `/api/v1/global-override` | authUser | Override setzen + sofort MQTT an alle Screens |
-| DELETE | `/api/v1/global-override` | authUser | Override aufheben |
-
-**GET /api/v1/global-override**
-
-Ruft den aktuell aktiven globalen Override ab.
-
-**Response:** `200 OK` (wenn aktiv)
-```json
-{"type":"off","until":"2026-04-05T18:00:00+02:00","set_at":"2026-03-27T15:30:00+02:00"}
-```
-
-**Response:** `204 No Content` (wenn kein Override aktiv)
-
----
-
-**POST /api/v1/global-override**
-
-Setzt einen globalen Override und sendet sofort MQTT-Befehle an alle Screens.
-
-**Request-Body:**
-```json
-{"type":"off","until":"2026-04-05T18:00:00+02:00"}
-```
-
-**Response:** `200 OK`
-```json
-{"type":"off","until":"2026-04-05T18:00:00+02:00","set_at":"2026-03-27T15:30:00+02:00"}
-```
-
-**Fehler:**
-- `400 Bad Request` — `type` nicht "on"/"off", oder ungültiges Zeitformat
-- `500 Internal Server Error` — DB-Fehler
-
----
-
-**DELETE /api/v1/global-override**
-
-Hebt den aktuellen globalen Override auf.
-
-**Response:** `204 No Content`
-
-**Fehler:**
-- `500 Internal Server Error` — DB-Fehler
-
----
-
-### Per-Screen Override
-
-| Methode | Pfad | Auth | Beschreibung |
-|---------|------|------|--------------|
-| POST | `/api/v1/screens/{screenSlug}/override` | authScreen | Per-Screen "Einschalten bis" setzen oder löschen |
-
-**POST /api/v1/screens/{screenSlug}/override**
-
-Setzt oder löscht den per-Screen "Einschalten bis"-Override. Mit diesem Override bleibt ein Monitor bis zu
-dem angegebenen Zeitpunkt eingeschaltet, selbst wenn der globale Schedule "aus" vorsieht.
-
-**Auth:** Erforderlich. Screen-Zugriff erforderlich.
-
-**Path-Parameter:**
-- `screenSlug` — Slug des Screens
-
-**Request-Body:**
-```json
-{"on_until":"2026-04-05T18:00:00+02:00"}
-```
-
-Um den Override zu löschen, `on_until` auf `null` setzen:
-```json
-{"on_until":null}
-```
-
-**Response:** `204 No Content`
-
-**Fehler:**
-- `400 Bad Request` — Ungültiges Zeitformat oder ungültiges JSON
-- `404 Not Found` — Screen nicht vorhanden
-- `500 Internal Server Error` — DB-Fehler
-
----
-
 ## Message Wall
 
 ### POST /api/v1/tools/message-wall/resolve

docs/SCHEMA.md

@@ -523,36 +523,6 @@ Regeln:
 - `schedule_enabled = false` bedeutet: Zeitplan vorhanden, aber deaktiviert
 - Leere Zeitfelder bedeuten: kein Einschalt- bzw. kein Ausschaltbefehl
 
-Neue Spalte in `screen_schedules` (Migration `006`):
-- `override_on_until timestamptz` — Einschalten-Override: Monitor bleibt bis zu diesem Zeitpunkt eingeschaltet (null = kein Override)
-
-### `global_override` (Migration 006)
-
-Zweck:
-
-- Speichert den globalen Display-Override (maximal eine Zeile)
-
-Spalten:
-
-```sql
-id        INT         PRIMARY KEY DEFAULT 1
-type      TEXT        NOT NULL         -- "on" oder "off"
-until     TIMESTAMPTZ NOT NULL         -- Override aktiv bis zu diesem Zeitpunkt
-set_at    TIMESTAMPTZ NOT NULL DEFAULT now()  -- Wann der Override gesetzt wurde
-```
-
-Constraint:
-```sql
-CHECK (id = 1)
-```
-
-Regeln:
-
-- Die Tabelle enthaelt maximal eine Zeile (id = 1)
-- `type` bestimmt den globalen Zielzustand (alle Screens)
-- `until` gibt an, wann der Override automatisch aufgehoben wird
-- Der Scheduler prueft jede Minute, ob der Override noch aktiv ist (aktuell <= until)
-
 ### `screen_snapshots`
 
 Zweck:

docs/superpowers/specs/2026-03-27-override-wochenende-design.md

@@ -1,140 +0,0 @@
-# Design: Globaler Override & Wochenend-Sperre
-
-**Datum:** 2026-03-27
-**Status:** Approved
-
-## Zusammenfassung
-
-Schul-Ferien, Elternabende und Wochenenden erfordern, dass Monitorzeitpläne temporär ignoriert werden. Diese Funktion ergänzt das bestehende Zeitplansystem um:
-
-1. **Globaler Override** — alle zugänglichen Monitore bis zu einem Zeitpunkt aus- oder einschalten
-2. **Per-Screen Override** — einen einzelnen Monitor trotz globalem Off oder Wochenende einschalten
-3. **Wochenend-Sperre** — samstags und sonntags werden Zeitpläne ignoriert, Monitore bleiben aus
-
----
-
-## Datenmodell
-
-### Migration 006 — Tabelle `global_override`
-
-```sql
-CREATE TABLE global_override (
-    id      int PRIMARY KEY DEFAULT 1,
-    type    text NOT NULL,          -- 'on' oder 'off'
-    until   timestamptz NOT NULL,
-    set_at  timestamptz NOT NULL DEFAULT now(),
-    CHECK (id = 1)
-);
-```
-
-Immer genau eine Zeile (Upsert auf `id = 1`). Kein aktiver Override = leere Tabelle.
-
-### Migration 007 — Spalte in `screen_schedules`
-
-```sql
-ALTER TABLE screen_schedules
-    ADD COLUMN override_on_until timestamptz;
-```
-
-`NULL` = kein per-Screen-Override aktiv.
-
-### Store-Erweiterungen
-
-- `GlobalOverrideStore`: `Get(ctx)`, `Upsert(ctx, type, until)`, `Delete(ctx)`
-- `ScreenScheduleStore.Upsert`: nimmt `override_on_until` auf; `Get` liefert es zurück
-
----
-
-## Prioritätslogik
-
-Die neue Funktion `resolveDesiredState()` im Reconciler löst `desiredState()` ab:
-
-```
-1. per-Screen override_on_until > now            →  "on"
-2. Globaler Override aktiv (until > now):
-     type "off"                                  →  "off"
-     type "on"                                   →  "on"
-3. Wochenende (Samstag oder Sonntag)             →  "off"
-4. Normaler Zeitplan (bestehende Logik)
-```
-
-**Scheduler (Minuten-Tick):** Sendet kein Kommando, wenn Override oder Wochenende aktiv ist — der Reconciler korrigiert den Zustand.
-
-**Reconciler (5-Minuten-Tick):** Nutzt `resolveDesiredState()`. Abgelaufene Overrides werden automatisch ignoriert (`until < now`), kein explizites Löschen nötig.
-
-**Sofortige Aktivierung:** Beim Setzen eines globalen Overrides schickt der Handler nach dem DB-Upsert sofort MQTT-Kommandos an alle zugänglichen Screens.
-
----
-
-## API-Endpunkte
-
-### Globaler Override
-
-| Methode | Pfad | Beschreibung |
-|---------|------|--------------|
-| `GET`    | `/api/v1/global-override` | Aktuellen Override abrufen (204 wenn keiner aktiv) |
-| `POST`   | `/api/v1/global-override` | Override setzen + sofort MQTT an alle Screens |
-| `DELETE` | `/api/v1/global-override` | Override löschen (Reconciler normalisiert) |
-
-**POST-Body:**
-```json
-{ "type": "off", "until": "2026-04-05T18:00:00Z" }
-```
-
-**GET-Response (200):**
-```json
-{ "type": "off", "until": "2026-04-05T18:00:00Z", "set_at": "..." }
-```
-
-**Auth:** `authUser` (eingeloggt). Handler filtert auf alle zugänglichen Screens des Users.
-
-### Per-Screen Override
-
-Erweiterung des bestehenden Endpunkts:
-
-```
-POST /api/v1/screens/{screenSlug}/schedule
-```
-
-Neues optionales Feld im Body:
-```json
-{ "override_on_until": "2026-04-05T18:00:00Z" }
-```
-`null` löscht den Override. Kein neuer Endpunkt nötig.
-
----
-
-## UI
-
-### Monitorübersicht (`/manage`) — globaler Override
-
-- Neuer Banner-Bereich oberhalb der Monitorkarten
-- Zwei Buttons: **"Alle ausschalten bis…"** / **"Alle einschalten bis…"**
-- Klick klappt ein Inline-Formular auf (`<input type="datetime-local">` + "Setzen"-Button)
-- Wenn Override aktiv: farbiges Hinweisband mit Zeitangabe und "Aufheben"-Link
-- Bestehender 30s-Poll aktualisiert auch diesen Status
-
-### Monitorkarte (Übersicht) — per-Screen Override
-
-- Unter den Ein/Aus-Buttons: aufklappbarer Bereich mit `<input type="datetime-local">` + "Einschalten bis"-Button
-- Wenn aktiv: Badge `"ein bis 05.04. 18:00 ✕"`
-
-### Detailseite (`/manage/{slug}`) — per-Screen Override
-
-- Im bestehenden "Zeitplan"-Kasten: neues Feld "Einschalten bis (Override)"
-- `<input type="datetime-local">` + "Setzen" / "Aufheben"-Button
-- Wird über den bestehenden `saveSchedule()`-Aufruf gespeichert (neues Feld im Body)
-
----
-
-## Timezone
-
-`<input type="datetime-local">` liefert Browser-Lokalzeit ohne Timezone-Offset. Das Frontend sendet die Zeit als ISO-8601-String mit Offset (z.B. `+01:00`). Der Backend-Handler parst mit `time.Parse(time.RFC3339, ...)`. Die bestehende `TZ`-Env-Variable des Servers steuert die Interpretation im Scheduler/Reconciler — kein neuer Konfigurationsaufwand.
-
----
-
-## Nicht im Scope
-
-- Per-Screen "ausschalten bis" — nur "einschalten bis" pro Monitor
-- Globaler Override ist nicht per-Screen einschränkbar (kommt aus der Übersicht, gilt für alle zugänglichen Screens)
-- Sofortige Aktion beim Override-Ablauf — Reconciler (≤5 Min) reicht

server/backend/README.md

@@ -17,7 +17,7 @@ Dieses Verzeichnis enthaelt das zentrale Go-Backend fuer das Info-Board-System.
 - `internal/app/` — App-Initialisierung und Lifecycle
 - `internal/config/` — Konfiguration via Umgebungsvariablen
 - `internal/db/` — PostgreSQL-Anbindung und Migrations-Runner
-- `internal/store/` — Datenbankzugriff (TenantStore, ScreenStore, MediaStore, PlaylistStore, AuthStore, ScreenScheduleStore, GlobalOverrideStore)
+- `internal/store/` — Datenbankzugriff (TenantStore, ScreenStore, MediaStore, PlaylistStore, AuthStore)
 - `internal/fileutil/` — Upload-Hilfsfunktionen (SaveUploadedFile mit Tenant-Isolation)
 - `internal/httpapi/` — HTTP-Routing, Middleware und Handler
 - `internal/httpapi/csrf.go` — Double-Submit-Cookie CSRF-Schutz
@@ -42,10 +42,6 @@ Uhrzeit übereinstimmt — per MQTT den Befehl `display_on` bzw. `display_off` s
 Der Scheduler wird in `internal/app/app.go` als Goroutine gestartet und laeuft bis zum
 Kontext-Abbruch beim Server-Shutdown.
 
-**Wochenend-Sperre:** An Samstagen und Sonntagen werden Zeitplaene ignoriert — der Reconciler
-sendet dann keine automatischen Ein-/Ausschalt-Kommandos. Manuelle Overrides (global oder
-per-Screen) wirken jedoch auch am Wochenende.
-
 ## Datenbank-Stores
 
 ### AuthStore (`internal/store/auth.go`)
@@ -64,16 +60,6 @@ per-Screen) wirken jedoch auch am Wochenende.
 - `EnsureAdminUser(ctx, tenantSlug, password)` — Admin-User beim Start anlegen
 - `VerifyPassword(ctx, userID, password)` — Passwort gegen bcrypt-Hash pruefen
 
-### GlobalOverrideStore (`internal/store/store.go`)
-
-Verwaltet einen systemweiten Display-Override (max. 1 Zeile in `global_override`):
-
-- `Get(ctx)` — aktuellen globalen Override laden (nil wenn keiner gesetzt)
-- `Upsert(ctx, type, until)` — Override setzen oder ueberschreiben (`type`: `"on"` | `"off"`)
-- `Delete(ctx)` — Override entfernen
-
-Der Reconciler im Scheduler wertet den globalen Override aus und wendet ihn auf alle Screens an.
-
 ### ScreenStore (`internal/store/screen.go`)
 
 **Screen-User Zugriffskontrolle:**
@@ -131,10 +117,6 @@ Der Reconciler im Scheduler wertet den globalen Override aus und wendet ihn auf
 | GET     | `/api/v1/screens/{screenId}/screenshot`   | Screenshot eines Screens abrufen      |
 | POST    | `/api/v1/screens/{screenSlug}/display`    | Display ein-/ausschalten (MQTT)       |
 | POST    | `/api/v1/screens/{screenSlug}/schedule`   | Display-Zeitplan speichern            |
-| GET     | `/api/v1/global-override`                 | Globalen Override abrufen (204 = kein aktiver Override) |
-| POST    | `/api/v1/global-override`                 | Globalen Override setzen (type + until); sendet sofort MQTT |
-| DELETE  | `/api/v1/global-override`                 | Globalen Override loeschen            |
-| POST    | `/api/v1/screens/{screenSlug}/override`   | Per-Screen-Override setzen oder loeschen (on_until: null = loeschen) |
 
 ### Nur Admins (`RequireAuth` + `RequireAdmin`)
 
@@ -200,9 +182,8 @@ Middleware zur rollenbasierten Zugriffskontrolle auf Screen-Ressourcen.
 
 ## Migrationen
 
-- `001_initial.sql` — initiales Schema (Tenants, Screens, Playlists, Media, etc.)
+- `001_core.sql` — initiales Schema (Tenants, Screens, Playlists, Media, etc.)
 - `002_auth.sql` — Auth-Tabellen (`users`, `sessions`)
 - `003_user_screen_permissions.sql` — Screen-User Management (`user_screen_permissions`)
 - `004_screen_status.sql` — Display-Zustand pro Screen (`screen_status`: screen_id, display_state, reported_at)
 - `005_screen_schedules.sql` — Zeitplan pro Screen (`screen_schedules`: screen_id, schedule_enabled, power_on_time, power_off_time)
-- `006_override.sql` — Spalte `override_on_until` in `screen_schedules` (per-Screen-Override) und Tabelle `global_override` (systemweiter Display-Override)

server/backend/internal/app/app.go

@@ -26,9 +26,8 @@ type App struct {
 	server        *http.Server
 	notifier      *mqttnotifier.Notifier
 	authStore     *store.AuthStore
-	scheduleStore       *store.ScreenScheduleStore
+	scheduleStore *store.ScreenScheduleStore
-	globalOverrideStore *store.GlobalOverrideStore
+	screenStore   *store.ScreenStore
-	screenStore         *store.ScreenStore
 	dbPool        *db.Pool // V7: für db.Close() im Shutdown
 	logger        *log.Logger
 }
@@ -63,7 +62,6 @@ func New() (*App, error) {
 	playlists := store.NewPlaylistStore(pool.Pool)
 	authStore := store.NewAuthStore(pool.Pool)
 	schedules := store.NewScreenScheduleStore(pool.Pool)
-	globalOverrides := store.NewGlobalOverrideStore(pool.Pool)
 
 	// Ensure admin user exists — generate a random password if none is configured.
 	adminPassword := cfg.AdminPassword
@@ -102,9 +100,8 @@ func New() (*App, error) {
 		AuthStore:       authStore,
 		Notifier:        notifier,
 		ScreenshotStore: ss,
-		ScheduleStore:       schedules,
+		ScheduleStore:   schedules,
-		GlobalOverrideStore: globalOverrides,
+		Config:          cfg,
-		Config:              cfg,
 		UploadDir:       cfg.UploadDir,
 		Logger:          logger,
 	})
@@ -114,9 +111,8 @@ func New() (*App, error) {
 		server:        &http.Server{Addr: cfg.HTTPAddress, Handler: handler},
 		notifier:      notifier,
 		authStore:     authStore,
-		scheduleStore:       schedules,
+		scheduleStore: schedules,
-		globalOverrideStore: globalOverrides,
+		screenStore:   screens,
-		screenStore:         screens,
 		dbPool:        pool, // V7: Referenz für Shutdown
 		logger:        logger,
 	}, nil
@@ -149,8 +145,8 @@ func (a *App) Run() error {
 	}()
 
 	// Display-Zeitplan-Scheduler
-	go scheduler.Run(ctx, a.scheduleStore, a.screenStore, a.globalOverrideStore, a.notifier)
+	go scheduler.Run(ctx, a.scheduleStore, a.screenStore, a.notifier)
-	go scheduler.Reconcile(ctx, a.scheduleStore, a.screenStore, a.screenStore, a.globalOverrideStore, a.notifier)
+	go scheduler.Reconcile(ctx, a.scheduleStore, a.screenStore, a.screenStore, a.notifier)
 
 	// W2: Signal-Handler für Graceful Shutdown.
 	sigCh := make(chan os.Signal, 1)

server/backend/internal/db/migrations/006_override.sql

@@ -1,14 +0,0 @@
--- Migration 006: Globaler Override + per-Screen Override-Zeitpunkt
-
--- Globaler Override: immer maximal eine Zeile (id = 1 per CHECK-Constraint).
-create table if not exists global_override (
-    id      int         primary key default 1,
-    type    text        not null,           -- 'on' oder 'off'
-    until   timestamptz not null,
-    set_at  timestamptz not null default now(),
-    check (id = 1)
-);
-
--- Per-Screen Override: Einschalten bis Zeitpunkt (null = kein Override).
-alter table screen_schedules
-    add column if not exists override_on_until timestamptz;

server/backend/internal/httpapi/manage/override.go

@@ -1,138 +0,0 @@
-// server/backend/internal/httpapi/manage/override.go
-package manage
-
-import (
-	"context"
-	"encoding/json"
-	"log/slog"
-	"net/http"
-	"time"
-
-	"git.az-it.net/az/morz-infoboard/server/backend/internal/mqttnotifier"
-	"git.az-it.net/az/morz-infoboard/server/backend/internal/reqcontext"
-	"git.az-it.net/az/morz-infoboard/server/backend/internal/store"
-)
-
-// globalOverrideStore ist das Interface für Handler-Tests.
-type globalOverrideStore interface {
-	Get(ctx context.Context) (*store.GlobalOverride, error)
-	Upsert(ctx context.Context, overrideType string, until time.Time) error
-	Delete(ctx context.Context) error
-}
-
-// HandleGetGlobalOverride gibt den aktuellen globalen Override zurück (204 wenn keiner aktiv).
-func HandleGetGlobalOverride(overrides globalOverrideStore) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		o, err := overrides.Get(r.Context())
-		if err != nil {
-			http.Error(w, "internal error", http.StatusInternalServerError)
-			return
-		}
-		if o == nil || time.Now().After(o.Until) {
-			w.WriteHeader(http.StatusNoContent)
-			return
-		}
-		w.Header().Set("Content-Type", "application/json")
-		json.NewEncoder(w).Encode(o) //nolint:errcheck
-	}
-}
-
-// HandleSetGlobalOverride setzt den globalen Override und schickt sofort MQTT an alle Screens.
-// Hinweis: Der Override wird global gespeichert und vom Reconciler auf alle Screens angewendet.
-// Über authOnly haben alle eingeloggten Nutzer Zugriff; die sofortigen MQTT-Kommandos gehen
-// jedoch nur an ihre zugänglichen Screens. Soll der Zugriff auf Admins beschränkt werden,
-// authOnly durch authAdmin ersetzen.
-func HandleSetGlobalOverride(overrides globalOverrideStore, screens *store.ScreenStore, notifier *mqttnotifier.Notifier) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		var body struct {
-			Type  string    `json:"type"`
-			Until time.Time `json:"until"`
-		}
-		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-			http.Error(w, "invalid JSON", http.StatusBadRequest)
-			return
-		}
-		if body.Type != "on" && body.Type != "off" {
-			http.Error(w, `type must be "on" or "off"`, http.StatusBadRequest)
-			return
-		}
-		if body.Until.IsZero() || !time.Now().Before(body.Until) {
-			http.Error(w, "until must be in the future", http.StatusBadRequest)
-			return
-		}
-
-		if err := overrides.Upsert(r.Context(), body.Type, body.Until); err != nil {
-			slog.Error("set global override: upsert failed", "err", err)
-			http.Error(w, "internal error", http.StatusInternalServerError)
-			return
-		}
-
-		// Sofort MQTT an alle zugänglichen Screens schicken (falls screens/notifier vorhanden)
-		if screens != nil && notifier != nil {
-			u := reqcontext.UserFromContext(r.Context())
-			var allScreens []*store.Screen
-			if u != nil {
-				switch u.Role {
-				case "admin":
-					allScreens, _ = screens.ListAll(r.Context())
-				default:
-					allScreens, _ = screens.GetAccessibleScreens(r.Context(), u.ID)
-				}
-			}
-			action := "display_" + body.Type
-			for _, sc := range allScreens {
-				if err := notifier.SendDisplayCommand(sc.Slug, action); err != nil {
-					slog.Warn("set global override: send command failed", "slug", sc.Slug, "err", err)
-				}
-			}
-		}
-
-		w.WriteHeader(http.StatusNoContent)
-	}
-}
-
-// HandleDeleteGlobalOverride entfernt den globalen Override.
-func HandleDeleteGlobalOverride(overrides globalOverrideStore) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		if err := overrides.Delete(r.Context()); err != nil {
-			slog.Error("delete global override: failed", "err", err)
-			http.Error(w, "internal error", http.StatusInternalServerError)
-			return
-		}
-		w.WriteHeader(http.StatusNoContent)
-	}
-}
-
-// HandleSetScreenOverride setzt oder löscht den per-Screen-Override (on_until: null → löschen).
-func HandleSetScreenOverride(screens *store.ScreenStore, schedules *store.ScreenScheduleStore) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		screenSlug := r.PathValue("screenSlug")
-		screen, err := screens.GetBySlug(r.Context(), screenSlug)
-		if err != nil {
-			http.Error(w, "screen not found", http.StatusNotFound)
-			return
-		}
-		if !requireScreenAccess(w, r, screen) {
-			return
-		}
-
-		var body struct {
-			OnUntil *time.Time `json:"on_until"`
-		}
-		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-			http.Error(w, "invalid JSON", http.StatusBadRequest)
-			return
-		}
-		if body.OnUntil != nil && !time.Now().Before(*body.OnUntil) {
-			http.Error(w, "on_until must be in the future", http.StatusBadRequest)
-			return
-		}
-
-		if err := schedules.SetOverrideOnUntil(r.Context(), screen.ID, body.OnUntil); err != nil {
-			slog.Error("set screen override: db error", "screen_id", screen.ID, "err", err)
-			http.Error(w, "internal error", http.StatusInternalServerError)
-			return
-		}
-		w.WriteHeader(http.StatusNoContent)
-	}
-}

server/backend/internal/httpapi/manage/override_test.go

@@ -1,98 +0,0 @@
-// server/backend/internal/httpapi/manage/override_test.go
-package manage_test
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"git.az-it.net/az/morz-infoboard/server/backend/internal/httpapi/manage"
-	"git.az-it.net/az/morz-infoboard/server/backend/internal/store"
-)
-
-// --- Mocks ---
-
-type mockGlobalOverrideStore struct {
-	current      *store.GlobalOverride
-	upsertCalled bool
-	deleteCalled bool
-}
-
-func (m *mockGlobalOverrideStore) Get(_ context.Context) (*store.GlobalOverride, error) {
-	return m.current, nil
-}
-func (m *mockGlobalOverrideStore) Upsert(_ context.Context, t string, u time.Time) error {
-	m.current = &store.GlobalOverride{Type: t, Until: u}
-	m.upsertCalled = true
-	return nil
-}
-func (m *mockGlobalOverrideStore) Delete(_ context.Context) error {
-	m.current = nil
-	m.deleteCalled = true
-	return nil
-}
-
-// --- Tests ---
-
-func TestHandleGetGlobalOverride_None(t *testing.T) {
-	h := manage.HandleGetGlobalOverride(&mockGlobalOverrideStore{})
-	req := httptest.NewRequest(http.MethodGet, "/api/v1/global-override", nil)
-	w := httptest.NewRecorder()
-	h.ServeHTTP(w, req)
-	if w.Code != http.StatusNoContent {
-		t.Fatalf("want 204, got %d", w.Code)
-	}
-}
-
-func TestHandleGetGlobalOverride_Active(t *testing.T) {
-	until := time.Now().Add(time.Hour)
-	m := &mockGlobalOverrideStore{
-		current: &store.GlobalOverride{Type: "off", Until: until},
-	}
-	h := manage.HandleGetGlobalOverride(m)
-	req := httptest.NewRequest(http.MethodGet, "/api/v1/global-override", nil)
-	w := httptest.NewRecorder()
-	h.ServeHTTP(w, req)
-	if w.Code != http.StatusOK {
-		t.Fatalf("want 200, got %d", w.Code)
-	}
-	var resp store.GlobalOverride
-	if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
-		t.Fatal("decode response:", err)
-	}
-	if resp.Type != "off" {
-		t.Errorf("want type=off, got %q", resp.Type)
-	}
-}
-
-func TestHandleSetGlobalOverride_InvalidType(t *testing.T) {
-	h := manage.HandleSetGlobalOverride(&mockGlobalOverrideStore{}, nil, nil)
-	body := `{"type":"maybe","until":"` + time.Now().Add(time.Hour).Format(time.RFC3339) + `"}`
-	req := httptest.NewRequest(http.MethodPost, "/api/v1/global-override", bytes.NewBufferString(body))
-	req.Header.Set("Content-Type", "application/json")
-	w := httptest.NewRecorder()
-	h.ServeHTTP(w, req)
-	if w.Code != http.StatusBadRequest {
-		t.Fatalf("want 400, got %d", w.Code)
-	}
-}
-
-func TestHandleDeleteGlobalOverride(t *testing.T) {
-	m := &mockGlobalOverrideStore{
-		current: &store.GlobalOverride{Type: "off", Until: time.Now().Add(time.Hour)},
-	}
-	h := manage.HandleDeleteGlobalOverride(m)
-	req := httptest.NewRequest(http.MethodDelete, "/api/v1/global-override", nil)
-	w := httptest.NewRecorder()
-	h.ServeHTTP(w, req)
-	if w.Code != http.StatusNoContent {
-		t.Fatalf("want 204, got %d", w.Code)
-	}
-	if !m.deleteCalled {
-		t.Error("Delete() was not called")
-	}
-}

server/backend/internal/httpapi/manage/templates.go

@@ -982,27 +982,6 @@ const manageTmpl = `<!DOCTYPE html>
           </div>
           <p id="schedule-save-ok" class="save-ok mt-2" style="font-size:.8rem">✓ Gespeichert</p>
         </div>
-<!-- Per-Screen Override (Einschalten bis) -->
-<div class="box mb-3">
-  <h3 class="title is-6 mb-2">Einschalten bis (Override)</h3>
-  {{if not_expired .Schedule.OverrideOnUntil}}
-  <p style="font-size:.875rem;color:#059669;margin-bottom:.5rem">
-    &#x23F0; Aktiv bis {{.Schedule.OverrideOnUntil.Format "02.01.2006 15:04"}}
-  </p>
-  <button class="button is-small is-light" type="button"
-          onclick="clearScreenOverridePage()">Override aufheben</button>
-  {{else}}
-  <p style="font-size:.8rem;color:#6b7280;margin-bottom:.5rem">
-    &#220;berschreibt Zeitplan und Wochenend-Sperre &#x2014; Monitor bleibt bis zum angegebenen Zeitpunkt eingeschaltet.
-  </p>
-  <div style="display:flex;gap:.5rem;align-items:center;flex-wrap:wrap">
-    <input type="datetime-local" id="screen-override-until" class="input is-small" style="width:16rem">
-    <button class="button is-small is-success" type="button"
-            onclick="setScreenOverridePage()">Setzen</button>
-  </div>
-  {{end}}
-  <p id="screen-override-ok" class="save-ok mt-2" style="font-size:.8rem">&#x2713; Gespeichert</p>
-</div>
         <!-- Upload (collapsed) -->
         <div class="box mb-3">
           <details id="upload-details">
@@ -1210,33 +1189,6 @@ function saveSchedule() {
   }).catch(function() { showToast('Netzwerkfehler', 'is-danger'); });
 }
 
-function setScreenOverridePage() {
-  var val = document.getElementById('screen-override-until').value;
-  if (!val) { showToast('Bitte Datum und Uhrzeit angeben', 'is-warning'); return; }
-  var dt = new Date(val);
-  fetch('/api/v1/screens/' + SCREEN_SLUG + '/override', {
-    method: 'POST',
-    headers: {'Content-Type': 'application/json', 'X-CSRF-Token': getCsrf(), 'X-Requested-With': 'fetch'},
-    body: JSON.stringify({on_until: dt.toISOString()})
-  }).then(function(r) {
-    if (r.ok) {
-      var ok = document.getElementById('screen-override-ok');
-      if (ok) { ok.classList.add('show'); setTimeout(function() { ok.classList.remove('show'); }, 2000); }
-    } else { showToast('Fehler beim Setzen des Overrides', 'is-danger'); }
-  }).catch(function() { showToast('Netzwerkfehler', 'is-danger'); });
-}
-
-function clearScreenOverridePage() {
-  fetch('/api/v1/screens/' + SCREEN_SLUG + '/override', {
-    method: 'POST',
-    headers: {'Content-Type': 'application/json', 'X-CSRF-Token': getCsrf(), 'X-Requested-With': 'fetch'},
-    body: JSON.stringify({on_until: null})
-  }).then(function(r) {
-    if (r.ok) { location.reload(); }
-    else { showToast('Fehler beim Aufheben des Overrides', 'is-danger'); }
-  }).catch(function() { showToast('Netzwerkfehler', 'is-danger'); });
-}
-
 // ─── ?msg= toast ─────────────────────────────────────────────────
 (function() {
   var msg = new URLSearchParams(window.location.search).get('msg');
@@ -1440,29 +1392,6 @@ const screenOverviewTmpl = `<!DOCTYPE html>
 <section class="section">
   <div class="container">
     <h1 class="title is-4 mb-5">Meine Bildschirme</h1>
-    <!-- Globaler Override-Banner -->
-<div id="global-override-section" style="margin-bottom:1rem">
-  {{if .GlobalOverride}}
-  <div class="notification {{if eq .GlobalOverride.Type "off"}}is-warning{{else}}is-info{{end}} is-light py-2 px-3" style="display:flex;align-items:center;gap:1rem;flex-wrap:wrap">
-    <span>
-      Alle Monitore <strong>{{if eq .GlobalOverride.Type "off"}}ausgeschaltet{{else}}eingeschaltet{{end}}</strong>
-      bis {{.GlobalOverride.Until.Format "02.01.2006 15:04"}}
-    </span>
-    <button class="button is-small" type="button" onclick="deleteGlobalOverride()">Override aufheben</button>
-  </div>
-  {{else}}
-  <div style="display:flex;gap:.5rem;flex-wrap:wrap;align-items:center">
-    <button class="button is-small is-danger is-light" type="button" onclick="showGlobalOverrideForm('off')">Alle ausschalten bis&#x2026;</button>
-    <button class="button is-small is-success is-light" type="button" onclick="showGlobalOverrideForm('on')">Alle einschalten bis&#x2026;</button>
-    <span id="override-result" style="font-size:.8rem;color:#6b7280"></span>
-  </div>
-  <div id="global-override-form" style="display:none;margin-top:.5rem;gap:.5rem;align-items:center;flex-wrap:wrap">
-    <input type="datetime-local" id="global-override-until" class="input is-small" style="width:16rem">
-    <button class="button is-small is-primary" type="button" onclick="setGlobalOverride()">Setzen</button>
-    <button class="button is-small is-light" type="button" onclick="hideGlobalOverrideForm()">Abbrechen</button>
-  </div>
-  {{end}}
-</div>
     {{if gt (len .Cards) 1}}
     <div class="bulk-bar">
       <span style="font-size:.875rem;font-weight:600;color:#374151">Alle Displays:</span>
@@ -1495,24 +1424,6 @@ const screenOverviewTmpl = `<!DOCTYPE html>
               <button class="button is-small is-danger is-light" type="button"
                       onclick="sendDisplayCmd('{{.Screen.Slug}}','off')">Aus</button>
             </div>
-        <!-- Per-Screen Override -->
-        <div style="margin-top:.5rem;font-size:.8rem">
-          {{if .OverrideOnUntil}}
-          <span style="color:#059669">&#x23F0; Ein bis {{.OverrideOnUntil.Format "02.01. 15:04"}}</span>
-          <button class="button is-small is-light" style="padding:0 .4rem;height:1.4rem" type="button"
-                  onclick="clearScreenOverride('{{.Screen.Slug}}')">&#x2715;</button>
-          {{else}}
-          <details style="display:inline">
-            <summary style="cursor:pointer;color:#6b7280">Einschalten bis&#x2026;</summary>
-            <div style="display:flex;gap:.3rem;align-items:center;margin-top:.3rem;flex-wrap:wrap">
-              <input type="datetime-local" id="override-until-{{.Screen.Slug}}"
-                     class="input is-small" style="width:13rem;font-size:.75rem">
-              <button class="button is-small is-success is-light" type="button"
-                      onclick="setScreenOverride('{{.Screen.Slug}}')">Setzen</button>
-            </div>
-          </details>
-          {{end}}
-        </div>
           </div>
         </div>
       </div>
@@ -1602,68 +1513,6 @@ function bulkDisplay(state) {
     }).catch(function(){});
   });
 }
-
-var _globalOverrideType = '';
-
-function showGlobalOverrideForm(type) {
-  _globalOverrideType = type;
-  var form = document.getElementById('global-override-form');
-  if (form) form.style.display = 'flex';
-}
-
-function hideGlobalOverrideForm() {
-  var form = document.getElementById('global-override-form');
-  if (form) form.style.display = 'none';
-}
-
-function setGlobalOverride() {
-  var val = document.getElementById('global-override-until').value;
-  if (!val) {
-    document.getElementById('override-result').textContent = 'Bitte Datum und Uhrzeit angeben';
-    return;
-  }
-  var dt = new Date(val);
-  fetch('/api/v1/global-override', {
-    method: 'POST',
-    headers: {'Content-Type': 'application/json', 'X-CSRF-Token': getCsrf(), 'X-Requested-With': 'fetch'},
-    body: JSON.stringify({type: _globalOverrideType, until: dt.toISOString()})
-  }).then(function(r) {
-    if (r.ok) { location.reload(); }
-    else { document.getElementById('override-result').textContent = 'Fehler beim Setzen'; }
-  }).catch(function() { document.getElementById('override-result').textContent = 'Netzwerkfehler'; });
-}
-
-function deleteGlobalOverride() {
-  fetch('/api/v1/global-override', {
-    method: 'DELETE',
-    headers: {'X-CSRF-Token': getCsrf(), 'X-Requested-With': 'fetch'}
-  }).then(function(r) {
-    if (r.ok) { location.reload(); }
-  }).catch(function(){});
-}
-
-function setScreenOverride(slug) {
-  var val = document.getElementById('override-until-' + slug).value;
-  if (!val) return;
-  var dt = new Date(val);
-  fetch('/api/v1/screens/' + slug + '/override', {
-    method: 'POST',
-    headers: {'Content-Type': 'application/json', 'X-CSRF-Token': getCsrf(), 'X-Requested-With': 'fetch'},
-    body: JSON.stringify({on_until: dt.toISOString()})
-  }).then(function(r) {
-    if (r.ok) { location.reload(); }
-  }).catch(function(){});
-}
-
-function clearScreenOverride(slug) {
-  fetch('/api/v1/screens/' + slug + '/override', {
-    method: 'POST',
-    headers: {'Content-Type': 'application/json', 'X-CSRF-Token': getCsrf(), 'X-Requested-With': 'fetch'},
-    body: JSON.stringify({on_until: null})
-  }).then(function(r) {
-    if (r.ok) { location.reload(); }
-  }).catch(function(){});
-}
 </script>
 </body>
 </html>`

server/backend/internal/httpapi/manage/ui.go

@@ -137,9 +137,6 @@ var tmplFuncs = template.FuncMap{
 		}
 		return t.Format("02.01.2006 15:04")
 	},
-	"not_expired": func(t *time.Time) bool {
-		return t != nil && time.Now().Before(*t)
-	},
 }
 
 // HandleAdminUI renders the admin overview page (screens + users tabs).
@@ -284,13 +281,12 @@ func HandleRemoveUserFromScreen(screens *store.ScreenStore) http.HandlerFunc {
 }
 
 type screenCard struct {
-	Screen          *store.Screen
+	Screen       *store.Screen
-	DisplayState    string
+	DisplayState string
-	OverrideOnUntil *time.Time
 }
 
 // HandleScreenOverview renders a card-based overview of all accessible screens for a screen_user.
-func HandleScreenOverview(screens *store.ScreenStore, schedules *store.ScreenScheduleStore, overrides *store.GlobalOverrideStore, notifier *mqttnotifier.Notifier, cfg config.Config) http.HandlerFunc {
+func HandleScreenOverview(screens *store.ScreenStore, notifier *mqttnotifier.Notifier, cfg config.Config) http.HandlerFunc {
 	t := template.Must(template.New("screenOverview").Funcs(tmplFuncs).Parse(screenOverviewTmpl))
 	return func(w http.ResponseWriter, r *http.Request) {
 		u := reqcontext.UserFromContext(r.Context())
@@ -314,23 +310,11 @@ func HandleScreenOverview(screens *store.ScreenStore, schedules *store.ScreenSch
 		cards := make([]screenCard, 0, len(accessible))
 		for _, sc := range accessible {
 			ds, _ := screens.GetDisplayState(r.Context(), sc.ID)
-			sched, _ := schedules.Get(r.Context(), sc.ID)
+			cards = append(cards, screenCard{Screen: sc, DisplayState: ds})
-			var overrideOnUntil *time.Time
-			if sched != nil && sched.OverrideOnUntil != nil && time.Now().Before(*sched.OverrideOnUntil) {
-				overrideOnUntil = sched.OverrideOnUntil
-			}
-			cards = append(cards, screenCard{Screen: sc, DisplayState: ds, OverrideOnUntil: overrideOnUntil})
 		}
-
-		var activeOverride *store.GlobalOverride
-		if o, err := overrides.Get(r.Context()); err == nil && o != nil && time.Now().Before(o.Until) {
-			activeOverride = o
-		}
-
 		renderTemplate(w, t, map[string]any{
-			"Cards":          cards,
+			"Cards":     cards,
-			"CSRFToken":      csrfToken,
+			"CSRFToken": csrfToken,
-			"GlobalOverride": activeOverride,
 		})
 	}
 }

server/backend/internal/httpapi/router.go

@@ -21,9 +21,8 @@ type RouterDeps struct {
 	AuthStore       *store.AuthStore
 	Notifier        *mqttnotifier.Notifier
 	ScreenshotStore *ScreenshotStore
-	ScheduleStore       *store.ScreenScheduleStore
+	ScheduleStore   *store.ScreenScheduleStore
-	GlobalOverrideStore *store.GlobalOverrideStore
+	Config          config.Config
-	Config              config.Config
 	UploadDir       string
 	Logger          *log.Logger
 }
@@ -165,7 +164,7 @@ func registerManageRoutes(mux *http.ServeMux, d RouterDeps) {
 	// ── Playlist management UI ────────────────────────────────────────────
 	// authScreen enforces that screen_user only accesses their permitted screens.
 	mux.Handle("GET /manage",
-		authOnly(http.HandlerFunc(manage.HandleScreenOverview(d.ScreenStore, d.ScheduleStore, d.GlobalOverrideStore, notifier, d.Config))))
+		authOnly(http.HandlerFunc(manage.HandleScreenOverview(d.ScreenStore, notifier, d.Config))))
 	mux.Handle("GET /manage/{screenSlug}",
 		authScreen(http.HandlerFunc(manage.HandleManageUI(d.TenantStore, d.ScreenStore, d.ScheduleStore, d.MediaStore, d.PlaylistStore, d.Config, notifier))))
 	mux.Handle("POST /manage/{screenSlug}/upload",
@@ -193,18 +192,6 @@ func registerManageRoutes(mux *http.ServeMux, d RouterDeps) {
 	mux.Handle("POST /api/v1/screens/{screenSlug}/schedule",
 		authScreen(http.HandlerFunc(manage.HandleUpdateSchedule(d.ScreenStore, d.ScheduleStore))))
 
-	// ── Globaler Override ────────────────────────────────────────────────
-	mux.Handle("GET /api/v1/global-override",
-		authOnly(http.HandlerFunc(manage.HandleGetGlobalOverride(d.GlobalOverrideStore))))
-	mux.Handle("POST /api/v1/global-override",
-		authOnly(http.HandlerFunc(manage.HandleSetGlobalOverride(d.GlobalOverrideStore, d.ScreenStore, notifier))))
-	mux.Handle("DELETE /api/v1/global-override",
-		authOnly(http.HandlerFunc(manage.HandleDeleteGlobalOverride(d.GlobalOverrideStore))))
-
-	// ── Per-Screen Override ───────────────────────────────────────────────
-	mux.Handle("POST /api/v1/screens/{screenSlug}/override",
-		authScreen(http.HandlerFunc(manage.HandleSetScreenOverride(d.ScreenStore, d.ScheduleStore))))
-
 	// ── JSON API — screens ────────────────────────────────────────────────
 	// Self-registration: no auth (player calls this on startup).
 	mux.HandleFunc("POST /api/v1/screens/register",

server/backend/internal/scheduler/scheduler.go

@@ -25,20 +25,15 @@ type DisplayStateGetter interface {
 	GetDisplayState(ctx context.Context, screenID string) (string, error)
 }
 
-// AllScreensLister lädt alle bekannten Screens.
-type AllScreensLister interface {
-	ListAll(ctx context.Context) ([]*store.Screen, error)
-}
-
 // Run startet den Scheduler-Loop. Blockiert bis ctx abgebrochen wird.
-func Run(ctx context.Context, schedules *store.ScreenScheduleStore, screens ScreenSlugGetter, globalOverrides *store.GlobalOverrideStore, notifier DisplayCommander) {
+func Run(ctx context.Context, schedules *store.ScreenScheduleStore, screens ScreenSlugGetter, notifier DisplayCommander) {
 	ticker := time.NewTicker(1 * time.Minute)
 	defer ticker.Stop()
 
 	for {
 		select {
 		case <-ticker.C:
-			check(ctx, schedules, screens, globalOverrides, notifier)
+			check(ctx, schedules, screens, notifier)
 		case <-ctx.Done():
 			return
 		}
@@ -46,50 +41,39 @@ func Run(ctx context.Context, schedules *store.ScreenScheduleStore, screens Scre
 }
 
 // Reconcile läuft alle 5 Minuten und gleicht Ist- und Soll-Zustand ab.
-func Reconcile(ctx context.Context, schedules *store.ScreenScheduleStore, screens AllScreensLister, states DisplayStateGetter, globalOverrides *store.GlobalOverrideStore, notifier DisplayCommander) {
+func Reconcile(ctx context.Context, schedules *store.ScreenScheduleStore, screens ScreenSlugGetter, states DisplayStateGetter, notifier DisplayCommander) {
 	ticker := time.NewTicker(5 * time.Minute)
 	defer ticker.Stop()
 
 	for {
 		select {
 		case <-ticker.C:
-			reconcile(ctx, schedules, screens, states, globalOverrides, notifier)
+			reconcile(ctx, schedules, screens, states, notifier)
 		case <-ctx.Done():
 			return
 		}
 	}
 }
 
-func reconcile(ctx context.Context, schedules *store.ScreenScheduleStore, allScreens AllScreensLister, states DisplayStateGetter, globalOverrides *store.GlobalOverrideStore, notifier DisplayCommander) {
+func reconcile(ctx context.Context, schedules *store.ScreenScheduleStore, screens ScreenSlugGetter, states DisplayStateGetter, notifier DisplayCommander) {
-	now := time.Now()
+	now := time.Now().Format("15:04")
 
-	screenList, err := allScreens.ListAll(ctx)
+	enabled, err := schedules.ListEnabled(ctx)
 	if err != nil {
-		slog.Error("reconciler: list all screens failed", "err", err)
+		slog.Error("reconciler: list enabled schedules failed", "err", err)
 		return
 	}
 
-	globalOverride, err := globalOverrides.Get(ctx)
+	for _, sc := range enabled {
-	if err != nil {
+		if sc.PowerOnTime == "" || sc.PowerOffTime == "" {
-		slog.Warn("reconciler: get global override failed", "err", err)
-		// nicht fatal — ohne Override fortfahren
-	}
-
-	for _, screen := range screenList {
-		sc, err := schedules.Get(ctx, screen.ID)
-		if err != nil {
-			slog.Warn("reconciler: get schedule failed", "screen_id", screen.ID, "err", err)
 			continue
 		}
 
-		want, shouldControl := resolveDesiredState(*sc, globalOverride, now)
+		want := desiredState(sc.PowerOnTime, sc.PowerOffTime, now)
-		if !shouldControl {
-			continue
-		}
 
-		got, err := states.GetDisplayState(ctx, screen.ID)
+		got, err := states.GetDisplayState(ctx, sc.ScreenID)
 		if err != nil {
-			slog.Warn("reconciler: get display state failed", "screen_id", screen.ID, "err", err)
+			slog.Warn("reconciler: get display state failed", "screen_id", sc.ScreenID, "err", err)
 			continue
 		}
 
@@ -97,11 +81,17 @@ func reconcile(ctx context.Context, schedules *store.ScreenScheduleStore, allScr
 			continue
 		}
 
+		screen, err := screens.GetByID(ctx, sc.ScreenID)
+		if err != nil {
+			slog.Warn("reconciler: screen not found", "screen_id", sc.ScreenID, "err", err)
+			continue
+		}
+
 		action := "display_" + want
 		if err := notifier.SendDisplayCommand(screen.Slug, action); err != nil {
-			slog.Error("reconciler: send command failed", "screen_id", screen.ID, "action", action, "err", err)
+			slog.Error("reconciler: send command failed", "screen_id", sc.ScreenID, "action", action, "err", err)
 		} else {
-			slog.Info("reconciler: corrected display state", "screen_id", screen.ID, "slug", screen.Slug, "was", got, "want", want)
+			slog.Info("reconciler: corrected display state", "screen_id", sc.ScreenID, "slug", screen.Slug, "was", got, "want", want)
 		}
 	}
 }
@@ -123,49 +113,10 @@ func desiredState(onTime, offTime, now string) string {
 	return "off"
 }
 
-// resolveDesiredState ermittelt den Soll-Zustand eines Screens unter Berücksichtigung
-// aller Prioritätsstufen:
-//  1. per-Screen override_on_until (höchste Priorität)
-//  2. globaler Override
-//  3. Wochenende (Sa/So)
-//  4. normaler Zeitplan
-//
-// Gibt ("", false) zurück wenn keine Automatisierung aktiv ist.
-func resolveDesiredState(sc store.ScreenSchedule, globalOverride *store.GlobalOverride, now time.Time) (desired string, shouldControl bool) {
-	// 1. Per-Screen-Override: überschreibt alles
-	if sc.OverrideOnUntil != nil && now.Before(*sc.OverrideOnUntil) {
-		return "on", true
-	}
-	// 2. Globaler Override
-	if globalOverride != nil && now.Before(globalOverride.Until) {
-		return globalOverride.Type, true
-	}
-	// 3. Wochenende: Zeitpläne werden ignoriert, Monitore bleiben aus
-	wd := now.Weekday()
-	if wd == time.Saturday || wd == time.Sunday {
-		return "off", true
-	}
-	// 4. Normaler Zeitplan
-	if !sc.ScheduleEnabled || (sc.PowerOnTime == "" && sc.PowerOffTime == "") {
-		return "", false
-	}
-	return desiredState(sc.PowerOnTime, sc.PowerOffTime, now.Format("15:04")), true
-}
-
 // check prüft alle aktiven Zeitpläne und sendet ggf. Befehle.
-func check(ctx context.Context, schedules *store.ScreenScheduleStore, screens ScreenSlugGetter, globalOverrides *store.GlobalOverrideStore, notifier DisplayCommander) {
+func check(ctx context.Context, schedules *store.ScreenScheduleStore, screens ScreenSlugGetter, notifier DisplayCommander) {
 	// Uses process-local timezone — ensure TZ env var is set in the container (e.g. Europe/Berlin).
-	now := time.Now()
+	now := time.Now().Format("15:04")
-	nowStr := now.Format("15:04")
-
-	// Wochenende: keine Einschalte-Kommandos senden
-	isWeekend := now.Weekday() == time.Saturday || now.Weekday() == time.Sunday
-
-	// Globaler Override "off" aktiv?
-	globalOverrideOff := false
-	if o, err := globalOverrides.Get(ctx); err == nil && o != nil && now.Before(o.Until) && o.Type == "off" {
-		globalOverrideOff = true
-	}
 
 	enabled, err := schedules.ListEnabled(ctx)
 	if err != nil {
@@ -181,9 +132,9 @@ func check(ctx context.Context, schedules *store.ScreenScheduleStore, screens Sc
 		}
 
 		var action string
-		if sc.PowerOnTime != "" && sc.PowerOnTime == nowStr {
+		if sc.PowerOnTime != "" && sc.PowerOnTime == now {
 			action = "display_on"
-		} else if sc.PowerOffTime != "" && sc.PowerOffTime == nowStr {
+		} else if sc.PowerOffTime != "" && sc.PowerOffTime == now {
 			action = "display_off"
 		}
 
@@ -191,19 +142,6 @@ func check(ctx context.Context, schedules *store.ScreenScheduleStore, screens Sc
 			continue
 		}
 
-		// display_on unterdrücken wenn per-Screen-Override, Wochenende oder globaler Override "off"
-		if action == "display_on" {
-			if sc.OverrideOnUntil != nil && now.Before(*sc.OverrideOnUntil) {
-				// per-Screen Override aktiv → Kommando trotzdem senden (Override = on)
-			} else if isWeekend {
-				slog.Info("scheduler: display_on unterdrückt (Wochenende)", "screen_id", sc.ScreenID)
-				continue
-			} else if globalOverrideOff {
-				slog.Info("scheduler: display_on unterdrückt (globaler Override off)", "screen_id", sc.ScreenID)
-				continue
-			}
-		}
-
 		if err := notifier.SendDisplayCommand(screen.Slug, action); err != nil {
 			slog.Error("scheduler: send command failed", "screen_id", sc.ScreenID, "action", action, "err", err)
 		} else {

server/backend/internal/scheduler/scheduler_test.go

@@ -1,129 +0,0 @@
-package scheduler
-
-import (
-	"testing"
-	"time"
-
-	"git.az-it.net/az/morz-infoboard/server/backend/internal/store"
-)
-
-func ptrTime(t time.Time) *time.Time { return &t }
-
-func TestResolveDesiredState(t *testing.T) {
-	// Donnerstag 10:00 UTC
-	thu := time.Date(2026, 3, 26, 10, 0, 0, 0, time.UTC)
-	// Samstag 10:00 UTC
-	sat := time.Date(2026, 3, 28, 10, 0, 0, 0, time.UTC)
-
-	tests := []struct {
-		name        string
-		sc          store.ScreenSchedule
-		override    *store.GlobalOverride
-		now         time.Time
-		wantDesired string
-		wantControl bool
-	}{
-		{
-			name:        "per-screen override aktiv → on",
-			sc:          store.ScreenSchedule{OverrideOnUntil: ptrTime(thu.Add(time.Hour))},
-			now:         thu,
-			wantDesired: "on", wantControl: true,
-		},
-		{
-			name: "per-screen override abgelaufen → fällt durch zu Zeitplan",
-			sc: store.ScreenSchedule{
-				ScheduleEnabled: true,
-				PowerOnTime:     "09:00", PowerOffTime: "17:00",
-				OverrideOnUntil: ptrTime(thu.Add(-time.Hour)), // abgelaufen
-			},
-			now:         thu,
-			wantDesired: "on", wantControl: true, // Zeitplan: 09:00–17:00, jetzt 10:00
-		},
-		{
-			name: "per-screen override schlägt globalen Override off",
-			sc:   store.ScreenSchedule{OverrideOnUntil: ptrTime(thu.Add(time.Hour))},
-			override: &store.GlobalOverride{
-				Type:  "off",
-				Until: thu.Add(time.Hour),
-			},
-			now:         thu,
-			wantDesired: "on", wantControl: true,
-		},
-		{
-			name: "globaler Override off aktiv → off",
-			sc:   store.ScreenSchedule{ScheduleEnabled: true, PowerOnTime: "09:00", PowerOffTime: "17:00"},
-			override: &store.GlobalOverride{
-				Type:  "off",
-				Until: thu.Add(time.Hour),
-			},
-			now:         thu,
-			wantDesired: "off", wantControl: true,
-		},
-		{
-			name: "globaler Override on aktiv → on",
-			sc:   store.ScreenSchedule{},
-			override: &store.GlobalOverride{
-				Type:  "on",
-				Until: thu.Add(time.Hour),
-			},
-			now:         thu,
-			wantDesired: "on", wantControl: true,
-		},
-		{
-			name: "globaler Override abgelaufen → fällt durch",
-			sc:   store.ScreenSchedule{ScheduleEnabled: true, PowerOnTime: "09:00", PowerOffTime: "17:00"},
-			override: &store.GlobalOverride{
-				Type:  "off",
-				Until: thu.Add(-time.Hour), // abgelaufen
-			},
-			now:         thu,
-			wantDesired: "on", wantControl: true,
-		},
-		{
-			name:        "Wochenende → off",
-			sc:          store.ScreenSchedule{ScheduleEnabled: true, PowerOnTime: "09:00", PowerOffTime: "17:00"},
-			now:         sat,
-			wantDesired: "off", wantControl: true,
-		},
-		{
-			name:        "Wochenende + per-screen override → on",
-			sc:          store.ScreenSchedule{OverrideOnUntil: ptrTime(sat.Add(time.Hour))},
-			now:         sat,
-			wantDesired: "on", wantControl: true,
-		},
-		{
-			name:        "normaler Zeitplan: innerhalb → on",
-			sc:          store.ScreenSchedule{ScheduleEnabled: true, PowerOnTime: "09:00", PowerOffTime: "17:00"},
-			now:         thu, // 10:00
-			wantDesired: "on", wantControl: true,
-		},
-		{
-			name:        "normaler Zeitplan: außerhalb → off",
-			sc:          store.ScreenSchedule{ScheduleEnabled: true, PowerOnTime: "09:00", PowerOffTime: "17:00"},
-			now:         time.Date(2026, 3, 26, 8, 0, 0, 0, time.UTC), // 08:00
-			wantDesired: "off", wantControl: true,
-		},
-		{
-			name:        "kein Zeitplan, kein Override → keine Steuerung",
-			sc:          store.ScreenSchedule{},
-			now:         thu,
-			wantDesired: "", wantControl: false,
-		},
-		{
-			name:        "Zeitplan deaktiviert → keine Steuerung",
-			sc:          store.ScreenSchedule{ScheduleEnabled: false, PowerOnTime: "09:00", PowerOffTime: "17:00"},
-			now:         thu,
-			wantDesired: "", wantControl: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gotDesired, gotControl := resolveDesiredState(tt.sc, tt.override, tt.now)
-			if gotDesired != tt.wantDesired || gotControl != tt.wantControl {
-				t.Errorf("resolveDesiredState() = (%q, %v), want (%q, %v)",
-					gotDesired, gotControl, tt.wantDesired, tt.wantControl)
-			}
-		})
-	}
-}

server/backend/internal/store/store.go

@@ -42,11 +42,10 @@ type ScreenStatus struct {
 }
 
 type ScreenSchedule struct {
-	ScreenID        string     `json:"screen_id"`
+	ScreenID        string `json:"screen_id"`
-	ScheduleEnabled bool       `json:"schedule_enabled"`
+	ScheduleEnabled bool   `json:"schedule_enabled"`
-	PowerOnTime     string     `json:"power_on_time"`
+	PowerOnTime     string `json:"power_on_time"`
-	PowerOffTime    string     `json:"power_off_time"`
+	PowerOffTime    string `json:"power_off_time"`
-	OverrideOnUntil *time.Time `json:"override_on_until,omitempty"`
 }
 
 type MediaAsset struct {
@@ -654,9 +653,9 @@ func scanPlaylistItem(row interface {
 func (s *ScreenScheduleStore) Get(ctx context.Context, screenID string) (*ScreenSchedule, error) {
 	var sc ScreenSchedule
 	err := s.pool.QueryRow(ctx,
-		`select screen_id, schedule_enabled, power_on_time, power_off_time, override_on_until
+		`select screen_id, schedule_enabled, power_on_time, power_off_time
 		   from screen_schedules where screen_id = $1`, screenID).
-		Scan(&sc.ScreenID, &sc.ScheduleEnabled, &sc.PowerOnTime, &sc.PowerOffTime, &sc.OverrideOnUntil)
+		Scan(&sc.ScreenID, &sc.ScheduleEnabled, &sc.PowerOnTime, &sc.PowerOffTime)
 	if errors.Is(err, pgx.ErrNoRows) {
 		return &ScreenSchedule{ScreenID: screenID}, nil
 	}
@@ -667,8 +666,6 @@ func (s *ScreenScheduleStore) Get(ctx context.Context, screenID string) (*Screen
 }
 
 // Upsert speichert oder aktualisiert den Zeitplan eines Screens.
-// Hinweis: override_on_until wird hier bewusst nicht angefasst – das ist
-// ausschließlich Aufgabe von SetOverrideOnUntil (saubere Trennung, kein Datenverlust).
 func (s *ScreenScheduleStore) Upsert(ctx context.Context, sc *ScreenSchedule) error {
 	_, err := s.pool.Exec(ctx,
 		`insert into screen_schedules (screen_id, schedule_enabled, power_on_time, power_off_time)
@@ -684,7 +681,7 @@ func (s *ScreenScheduleStore) Upsert(ctx context.Context, sc *ScreenSchedule) er
 // ListEnabled gibt alle Screens mit aktivem Zeitplan zurück.
 func (s *ScreenScheduleStore) ListEnabled(ctx context.Context) ([]*ScreenSchedule, error) {
 	rows, err := s.pool.Query(ctx,
-		`select screen_id, schedule_enabled, power_on_time, power_off_time, override_on_until
+		`select screen_id, schedule_enabled, power_on_time, power_off_time
 		   from screen_schedules
 		  where schedule_enabled = true
 		    and (power_on_time != '' or power_off_time != '')`)
@@ -695,73 +692,10 @@ func (s *ScreenScheduleStore) ListEnabled(ctx context.Context) ([]*ScreenSchedul
 	var out []*ScreenSchedule
 	for rows.Next() {
 		var sc ScreenSchedule
-		if err := rows.Scan(&sc.ScreenID, &sc.ScheduleEnabled, &sc.PowerOnTime, &sc.PowerOffTime, &sc.OverrideOnUntil); err != nil {
+		if err := rows.Scan(&sc.ScreenID, &sc.ScheduleEnabled, &sc.PowerOnTime, &sc.PowerOffTime); err != nil {
 			return nil, err
 		}
 		out = append(out, &sc)
 	}
 	return out, rows.Err()
 }
-
-// SetOverrideOnUntil setzt oder löscht den per-Screen-Override (null = löschen).
-func (s *ScreenScheduleStore) SetOverrideOnUntil(ctx context.Context, screenID string, until *time.Time) error {
-	_, err := s.pool.Exec(ctx,
-		`insert into screen_schedules (screen_id, override_on_until)
-		 values ($1, $2)
-		 on conflict (screen_id) do update
-		   set override_on_until = excluded.override_on_until`,
-		screenID, until)
-	return err
-}
-
-// ------------------------------------------------------------------
-// GlobalOverrideStore
-// ------------------------------------------------------------------
-
-// GlobalOverride beschreibt einen aktiven globalen Display-Override.
-type GlobalOverride struct {
-	Type  string    `json:"type"`   // "on" oder "off"
-	Until time.Time `json:"until"`
-	SetAt time.Time `json:"set_at"`
-}
-
-// GlobalOverrideStore verwaltet den globalen Display-Override (max. 1 Zeile).
-type GlobalOverrideStore struct{ pool *pgxpool.Pool }
-
-func NewGlobalOverrideStore(pool *pgxpool.Pool) *GlobalOverrideStore {
-	return &GlobalOverrideStore{pool: pool}
-}
-
-// Get lädt den aktuellen globalen Override. Gibt nil zurück wenn keiner gesetzt ist.
-func (s *GlobalOverrideStore) Get(ctx context.Context) (*GlobalOverride, error) {
-	var o GlobalOverride
-	err := s.pool.QueryRow(ctx,
-		`select type, until, set_at from global_override where id = 1`).
-		Scan(&o.Type, &o.Until, &o.SetAt)
-	if errors.Is(err, pgx.ErrNoRows) {
-		return nil, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	return &o, nil
-}
-
-// Upsert setzt oder überschreibt den globalen Override.
-func (s *GlobalOverrideStore) Upsert(ctx context.Context, overrideType string, until time.Time) error {
-	_, err := s.pool.Exec(ctx,
-		`insert into global_override (id, type, until, set_at)
-		 values (1, $1, $2, now())
-		 on conflict (id) do update
-		   set type   = excluded.type,
-		       until  = excluded.until,
-		       set_at = excluded.set_at`,
-		overrideType, until)
-	return err
-}
-
-// Delete entfernt den globalen Override.
-func (s *GlobalOverrideStore) Delete(ctx context.Context) error {
-	_, err := s.pool.Exec(ctx, `delete from global_override where id = 1`)
-	return err
-}