initial feature/react-migration commit

dashboard-dash-backup/callbacks/appointment_modal_callbacks.py

@@ -0,0 +1,370 @@
+from dash import Input, Output, State, callback, html, dcc, no_update, ctx
+import dash_mantine_components as dmc
+from dash_iconify import DashIconify
+import dash_quill
+from datetime import datetime, date, timedelta
+import re
+
+# --- Typ-spezifische Felder anzeigen ---
+@callback(
+    Output('type-specific-fields', 'children'),
+    Input('type-input', 'value'),
+    prevent_initial_call=True
+)
+def show_type_specific_fields(event_type):
+    if not event_type:
+        return html.Div()
+    
+    if event_type == "presentation":
+        return dmc.Stack([
+            dmc.Divider(label="Präsentations-Details", labelPosition="center"),
+            dmc.Group([
+                dcc.Upload(
+                    id='presentation-upload',
+                    children=dmc.Button(
+                        "Datei hochladen",
+                        leftSection=DashIconify(icon="mdi:upload"),
+                        variant="outline"
+                    ),
+                    style={'width': 'auto'}
+                ),
+                dmc.TextInput(
+                    label="Präsentationslink",
+                    placeholder="https://...",
+                    leftSection=DashIconify(icon="mdi:link"),
+                    id="presentation-link",
+                    style={"minWidth": 0, "flex": 1, "marginBottom": 0}
+                )
+            ], grow=True, align="flex-end", style={"marginBottom": 10}),
+            html.Div(id="presentation-upload-status")
+        ], gap="sm")
+    
+    elif event_type == "video":
+        return dmc.Stack([
+            dmc.Divider(label="Video-Details", labelPosition="center"),
+            dmc.Group([
+                dcc.Upload(
+                    id='video-upload',
+                    children=dmc.Button(
+                        "Video hochladen",
+                        leftSection=DashIconify(icon="mdi:video-plus"),
+                        variant="outline"
+                    ),
+                    style={'width': 'auto'}
+                ),
+                dmc.TextInput(
+                    label="Videolink",
+                    placeholder="https://youtube.com/...",
+                    leftSection=DashIconify(icon="mdi:youtube"),
+                    id="video-link",
+                    style={"minWidth": 0, "flex": 1, "marginBottom": 0}
+                )
+            ], grow=True, align="flex-end", style={"marginBottom": 10}),
+            dmc.Group([
+                dmc.Checkbox(
+                    label="Endlos wiederholen",
+                    id="video-endless",
+                    checked=True,
+                    style={"marginRight": 20}
+                ),
+                dmc.NumberInput(
+                    label="Wiederholungen",
+                    id="video-repeats",
+                    value=1,
+                    min=1,
+                    max=99,
+                    step=1,
+                    disabled=True,
+                    style={"width": 150}
+                ),
+                dmc.Slider(
+                    label="Lautstärke",
+                    id="video-volume",
+                    value=70,
+                    min=0,
+                    max=100,
+                    step=5,
+                    marks=[
+                        {"value": 0, "label": "0%"},
+                        {"value": 50, "label": "50%"},
+                        {"value": 100, "label": "100%"}
+                    ],
+                    style={"flex": 1, "marginLeft": 20}
+                )
+            ], grow=True, align="flex-end"),
+            html.Div(id="video-upload-status")
+        ], gap="sm")
+    
+    elif event_type == "website":
+        return dmc.Stack([
+            dmc.Divider(label="Website-Details", labelPosition="center"),
+            dmc.TextInput(
+                label="Website-URL",
+                placeholder="https://example.com",
+                leftSection=DashIconify(icon="mdi:web"),
+                id="website-url",
+                required=True,
+                style={"flex": 1}
+            )
+        ], gap="sm")
+    
+    elif event_type == "message":
+        return dmc.Stack([
+            dmc.Divider(label="Nachrichten-Details", labelPosition="center"),
+            dash_quill.Quill(
+                id="message-content",
+                value="",
+            ),
+            dmc.Group([
+                dmc.Select(
+                    label="Schriftgröße",
+                    data=[
+                        {"value": "small", "label": "Klein"},
+                        {"value": "medium", "label": "Normal"},
+                        {"value": "large", "label": "Groß"},
+                        {"value": "xlarge", "label": "Sehr groß"}
+                    ],
+                    id="message-font-size",
+                    value="medium",
+                    style={"flex": 1}
+                ),
+                dmc.ColorPicker(
+                    id="message-color",
+                    value="#000000",
+                    format="hex",
+                    swatches=[
+                        "#000000", "#ffffff", "#ff0000", "#00ff00", 
+                        "#0000ff", "#ffff00", "#ff00ff", "#00ffff"
+                    ]
+                )
+            ], grow=True, align="flex-end")
+        ], gap="sm")
+    
+    return html.Div()
+
+# --- Callback zum Aktivieren/Deaktivieren des Wiederholungsfelds bei Video ---
+@callback(
+    Output("video-repeats", "disabled"),
+    Input("video-endless", "checked"),
+    prevent_initial_call=True
+)
+def toggle_video_repeats(endless_checked):
+    return endless_checked
+
+# --- Upload-Status für Präsentation ---
+@callback(
+    Output('presentation-upload-status', 'children'),
+    Input('presentation-upload', 'contents'),
+    State('presentation-upload', 'filename'),
+    prevent_initial_call=True
+)
+def update_presentation_upload_status(contents, filename):
+    if contents is not None and filename is not None:
+        return dmc.Alert(
+            f"✓ Datei '{filename}' erfolgreich hochgeladen",
+            color="green",
+            className="mt-2"
+        )
+    return html.Div()
+
+# --- Upload-Status für Video ---
+@callback(
+    Output('video-upload-status', 'children'),
+    Input('video-upload', 'contents'),
+    State('video-upload', 'filename'),
+    prevent_initial_call=True
+)
+def update_video_upload_status(contents, filename):
+    if contents is not None and filename is not None:
+        return dmc.Alert(
+            f"✓ Video '{filename}' erfolgreich hochgeladen",
+            color="green",
+            className="mt-2"
+        )
+    return html.Div()
+
+# --- Wiederholungsoptionen aktivieren/deaktivieren ---
+@callback(
+    [
+        Output('weekdays-select', 'disabled'),
+        Output('repeat-until-date', 'disabled'),
+        Output('skip-holidays-checkbox', 'disabled'),
+        Output('weekdays-select', 'value'),
+        Output('repeat-until-date', 'value'),
+        Output('skip-holidays-checkbox', 'checked')
+    ],
+    Input('repeat-checkbox', 'checked'),
+    prevent_initial_call=True
+)
+def toggle_repeat_options(is_repeat):
+    if is_repeat:
+        next_month = datetime.now().date() + timedelta(weeks=4)
+        return (
+            False,  # weekdays-select enabled
+            False,  # repeat-until-date enabled
+            False,  # skip-holidays-checkbox enabled
+            None,   # weekdays value
+            next_month,  # repeat-until-date value
+            False   # skip-holidays-checkbox checked
+        )
+    else:
+        return (
+            True,   # weekdays-select disabled
+            True,   # repeat-until-date disabled
+            True,   # skip-holidays-checkbox disabled
+            None,   # weekdays value
+            None,   # repeat-until-date value
+            False   # skip-holidays-checkbox checked
+        )
+
+# --- Dynamische Zeitoptionen für Startzeit ---
+def validate_and_format_time(time_str):
+    if not time_str:
+        return None, "Keine Zeit angegeben"
+    if re.match(r'^\d{2}:\d{2}$', time_str):
+        try:
+            h, m = map(int, time_str.split(':'))
+            if 0 <= h <= 23 and 0 <= m <= 59:
+                return time_str, "Gültige Zeit"
+        except:
+            pass
+    patterns = [
+        (r'^(\d{1,2}):(\d{2})$', lambda m: (int(m.group(1)), int(m.group(2)))),
+        (r'^(\d{1,2})\.(\d{2})$', lambda m: (int(m.group(1)), int(m.group(2)))),
+        (r'^(\d{1,2})(\d{2})$', lambda m: (int(m.group(1)), int(m.group(2)))),
+        (r'^(\d{1,2})$', lambda m: (int(m.group(1)), 0)),
+    ]
+    for pattern, extractor in patterns:
+        match = re.match(pattern, time_str.strip())
+        if match:
+            try:
+                hours, minutes = extractor(match)
+                if 0 <= hours <= 23 and 0 <= minutes <= 59:
+                    return f"{hours:02d}:{minutes:02d}", "Automatisch formatiert"
+            except:
+                continue
+    return None, "Ungültiges Zeitformat"
+
+@callback(
+    [
+        Output('time-start', 'data'),
+        Output('start-time-feedback', 'children')
+    ],
+    Input('time-start', 'searchValue'),
+    prevent_initial_call=True
+)
+def update_start_time_options(search_value):
+    time_options = [
+        {"value": f"{h:02d}:{m:02d}", "label": f"{h:02d}:{m:02d}"}
+        for h in range(6, 24) for m in [0, 30]
+    ]
+    base_options = time_options.copy()
+    feedback = None
+    if search_value:
+        validated_time, status = validate_and_format_time(search_value)
+        if validated_time:
+            if not any(opt["value"] == validated_time for opt in base_options):
+                base_options.insert(0, {
+                    "value": validated_time, 
+                    "label": f"{validated_time} (Ihre Eingabe)"
+                })
+            feedback = dmc.Text(f"✓ {status}: {validated_time}", size="xs", c="green")
+        else:
+            feedback = dmc.Text(f"✗ {status}", size="xs", c="red")
+    return base_options, feedback
+
+# --- Dynamische Zeitoptionen für Endzeit ---
+@callback(
+    [
+        Output('time-end', 'data'),
+        Output('end-time-feedback', 'children')
+    ],
+    Input('time-end', 'searchValue'),
+    prevent_initial_call=True
+)
+def update_end_time_options(search_value):
+    time_options = [
+        {"value": f"{h:02d}:{m:02d}", "label": f"{h:02d}:{m:02d}"}
+        for h in range(6, 24) for m in [0, 30]
+    ]
+    base_options = time_options.copy()
+    feedback = None
+    if search_value:
+        validated_time, status = validate_and_format_time(search_value)
+        if validated_time:
+            if not any(opt["value"] == validated_time for opt in base_options):
+                base_options.insert(0, {
+                    "value": validated_time, 
+                    "label": f"{validated_time} (Ihre Eingabe)"
+                })
+            feedback = dmc.Text(f"✓ {status}: {validated_time}", size="xs", c="green")
+        else:
+            feedback = dmc.Text(f"✗ {status}", size="xs", c="red")
+    return base_options, feedback
+
+# --- Automatische Endzeit-Berechnung mit Validation ---
+@callback(
+    Output('time-end', 'value'),
+    [
+        Input('time-start', 'value'),
+        Input('btn-reset', 'n_clicks')
+    ],
+    State('time-end', 'value'),
+    prevent_initial_call=True
+)
+def handle_end_time(start_time, reset_clicks, current_end_time):
+    if not ctx.triggered:
+        return no_update
+    trigger_id = ctx.triggered[0]['prop_id'].split('.')[0]
+    if trigger_id == 'btn-reset' and reset_clicks:
+        return None
+    if trigger_id == 'time-start' and start_time:
+        if current_end_time:
+            return no_update
+        try:
+            validated_start, _ = validate_and_format_time(start_time)
+            if validated_start:
+                start_dt = datetime.strptime(validated_start, "%H:%M")
+                end_dt = start_dt + timedelta(hours=1, minutes=30)
+                if end_dt.hour >= 24:
+                    end_dt = end_dt.replace(hour=23, minute=59)
+                return end_dt.strftime("%H:%M")
+        except:
+            pass
+    return no_update
+
+# --- Reset-Funktion erweitert ---
+@callback(
+    [
+        Output('title-input', 'value'),
+        Output('start-date-input', 'value', allow_duplicate=True),
+        Output('time-start', 'value'),
+        Output('type-input', 'value'),
+        Output('description-input', 'value'),
+        Output('repeat-checkbox', 'checked'),
+        Output('weekdays-select', 'value', allow_duplicate=True),
+        Output('repeat-until-date', 'value', allow_duplicate=True),
+        Output('skip-holidays-checkbox', 'checked', allow_duplicate=True)
+    ],
+    Input('btn-reset', 'n_clicks'),
+    prevent_initial_call=True
+)
+def reset_form(n_clicks):
+    if n_clicks:
+        return "", datetime.now().date(), "09:00", None, "", False, None, None, False
+    return no_update
+
+# --- Speichern-Funktion (Demo) ---
+@callback(
+    Output('save-feedback', 'children'),
+    Input('btn-save', 'n_clicks'),
+    prevent_initial_call=True
+)
+def save_appointments_demo(n_clicks):
+    if not n_clicks:
+        return no_update
+    return dmc.Alert(
+        "Demo: Termine würden hier gespeichert werden",
+        color="blue",
+        title="Speichern (Demo)"
+    )

dashboard-dash-backup/callbacks/appointments_callbacks.py

@@ -0,0 +1,168 @@
+import logging
+from math import fabs
+
+logger = logging.getLogger(__name__)
+# dashboard/callbacks/appointments_callbacks.py
+import requests
+import json
+from flask import session
+from dash import Input, Output, State, callback, ctx, dash, no_update
+import os
+import sys
+from datetime import datetime, timedelta
+
+# This message will now appear in the terminal during startup
+logger.debug("Registering appointments page...")
+
+
+# --- Modalbox öffnen: jetzt auch auf Kalenderklick reagieren ---
+
+sys.path.append('/workspace')
+
+print("appointments_callbacks.py geladen")
+
+API_BASE_URL = os.getenv("API_BASE_URL", "http://192.168.43.100")
+ENV = os.getenv("ENV", "development")
+
+
+@callback(
+    dash.Output('output', 'children'),
+    dash.Input('calendar', 'lastDateClick')
+)
+def display_date(date_str):
+    if date_str:
+        return f"Letzter Klick auf: {date_str}"
+    return "Klicke auf ein Datum im Kalender!"
+
+
+@callback(
+    dash.Output('event-output', 'children'),
+    dash.Input('calendar', 'lastEventClick')
+)
+def display_event(event_id):
+    if event_id:
+        return f"Letztes Event geklickt: {event_id}"
+    return "Klicke auf ein Event im Kalender!"
+
+
+@callback(
+    dash.Output('select-output', 'children'),
+    dash.Input('calendar', 'lastSelect')
+)
+def display_select(select_info):
+    if select_info:
+        return f"Markiert: {select_info['start']} bis {select_info['end']} (ganztägig: {select_info['allDay']})"
+    return "Markiere einen Bereich im Kalender!"
+
+
+@callback(
+    dash.Output('calendar', 'events'),
+    dash.Input('calendar', 'lastNavClick'),
+)
+def load_events(view_dates):
+    logger.info(f"Lade Events für Zeitraum: {view_dates}")
+    if not view_dates or "start" not in view_dates or "end" not in view_dates:
+        return []
+    start = view_dates["start"]
+    end = view_dates["end"]
+    try:
+        verify_ssl = True if ENV == "production" else False
+        resp = requests.get(
+            f"{API_BASE_URL}/api/events",
+            params={"start": start, "end": end},
+            verify=verify_ssl
+        )
+        resp.raise_for_status()
+        events = resp.json()
+        return events
+    except Exception as e:
+        logger.info(f"Fehler beim Laden der Events: {e}")
+        return []
+
+# --- Modalbox öffnen ---
+
+
+@callback(
+    [
+        Output("appointment-modal", "opened"),
+        Output("start-date-input", "value", allow_duplicate=True),
+        Output("time-start", "value", allow_duplicate=True),
+        Output("time-end", "value", allow_duplicate=True),
+    ],
+    [
+        Input("calendar", "lastDateClick"),
+        Input("calendar", "lastSelect"),
+        Input("open-appointment-modal-btn", "n_clicks"),
+        Input("close-appointment-modal-btn", "n_clicks"),
+    ],
+    State("appointment-modal", "opened"),
+    prevent_initial_call=True
+)
+def open_modal(date_click, select, open_click, close_click, is_open):
+    trigger = ctx.triggered_id
+
+    # Bereichsauswahl (lastSelect)
+    if trigger == "calendar" and select:
+        try:
+            start_dt = datetime.fromisoformat(select["start"])
+            end_dt = datetime.fromisoformat(select["end"])
+
+            return (
+                True,
+                start_dt.date().isoformat(),
+                start_dt.strftime("%H:%M"),
+                end_dt.strftime("%H:%M"),
+            )
+        except Exception as e:
+            print("Fehler beim Parsen von select:", e)
+            return no_update, no_update, no_update, no_update
+
+    # Einzelklick (lastDateClick)
+    if trigger == "calendar" and date_click:
+        try:
+            dt = datetime.fromisoformat(date_click)
+            # Versuche, die Slotlänge aus dem Kalender zu übernehmen (optional)
+            # Hier als Beispiel 30 Minuten aufaddieren, falls keine Endzeit vorhanden
+            end_dt = dt + timedelta(minutes=30)
+            return (
+                True,
+                dt.date().isoformat(),
+                dt.strftime("%H:%M"),
+                end_dt.strftime("%H:%M"),
+            )
+        except Exception as e:
+            print("Fehler beim Parsen von date_click:", e)
+            return no_update, no_update, no_update, no_update
+
+    # Modal öffnen per Button
+    if trigger == "open-appointment-modal-btn" and open_click:
+        now = datetime.now()
+        end_dt = now + timedelta(minutes=30)
+        return True, now.date().isoformat(), now.strftime("%H:%M"), end_dt.strftime("%H:%M")
+
+    # Modal schließen
+    if trigger == "close-appointment-modal-btn" and close_click:
+        return False, no_update, no_update, no_update
+
+    return is_open, no_update, no_update, no_update
+
+
+# @callback(
+#     Output("time-end", "value", allow_duplicate=True),
+#     Input("time-start", "value"),
+#     prevent_initial_call=True
+# )
+# def handle_end_time(start_time, duration="00:30"):
+#     trigger = ctx.triggered_id
+#     if trigger == "time-start" and start_time and duration:
+#         try:
+#             # Beispiel für start_time: "09:00"
+#             start_dt = datetime.strptime(start_time, "%H:%M")
+#             # Dauer in Stunden und Minuten, z.B. "01:30"
+#             hours, minutes = map(int, duration.split(":"))
+#             # Endzeit berechnen: Dauer addieren!
+#             end_dt = start_dt + timedelta(hours=hours, minutes=minutes)
+#             return end_dt.strftime("%H:%M")
+#         except Exception as e:
+#             print("Fehler bei der Berechnung der Endzeit:", e)
+#     return no_update

dashboard-dash-backup/callbacks/auth_callbacks.py

@@ -0,0 +1,31 @@
+# dashboard/callbacks/auth_callbacks.py
+import dash
+from dash import Input, Output, State, dcc
+from flask import session
+from utils.auth import check_password, get_user_role
+from config import ENV
+from utils.db import execute_query
+
+@dash.callback(
+    Output("login-feedback", "children"),
+    Output("header-right", "children"),
+    Input("btn-login", "n_clicks"),
+    State("input-user", "value"),
+    State("input-pass", "value"),
+    prevent_initial_call=True
+)
+def login_user(n_clicks, username, password):
+    if ENV == "development":
+        # Dev‐Bypass: setze immer Admin‐Session und leite weiter
+        session["username"] = "dev_admin"
+        session["role"] = "admin"
+        return dcc.Location(href="/overview", id="redirect-dev"), None
+
+    # Produktions‐Login: User in DB suchen
+    user = execute_query("SELECT username, pwd_hash, role FROM users WHERE username=%s", (username,), fetch_one=True)
+    if user and check_password(password, user["pwd_hash"]):
+        session["username"] = user["username"]
+        session["role"] = user["role"]
+        return dcc.Location(href="/overview", id="redirect-ok"), None
+    else:
+        return "Ungültige Zugangsdaten.", None

dashboard-dash-backup/callbacks/overview_callbacks.py

@@ -0,0 +1,139 @@
+# dashboard/callbacks/overview_callbacks.py
+import sys
+sys.path.append('/workspace')
+import threading
+import dash
+import requests
+from dash import Input, Output, State, MATCH, html, dcc
+from flask import session
+from utils.db import get_session  # Diese Funktion muss eine SQLAlchemy-Session liefern!
+from utils.mqtt_client import publish, start_loop
+from config import ENV
+import dash_bootstrap_components as dbc
+import os
+import time
+import pytz
+from datetime import datetime
+
+print("overview_callbacks.py geladen")
+
+API_BASE_URL = os.getenv("API_BASE_URL", "https://192.168.43.100")
+
+mqtt_thread_started = False
+SCREENSHOT_DIR = "received-screenshots"
+
+def ensure_mqtt_running():
+    global mqtt_thread_started
+    if not mqtt_thread_started:
+        thread = threading.Thread(target=start_loop, daemon=True)
+        thread.start()
+        mqtt_thread_started = True
+
+def get_latest_screenshot(client_uuid):
+    cache_buster = int(time.time())  # aktuelle Unix-Zeit in Sekunden
+    # TODO: Hier genau im Produkitv-Modus die IPs testen!
+    # Wenn API_BASE_URL auf "http" beginnt, absolute URL verwenden (z.B. im lokalen Dev)
+    if API_BASE_URL.startswith("http"):
+        return f"{API_BASE_URL}/screenshots/{client_uuid}?t={cache_buster}"
+    # Sonst relative URL (nginx-Proxy übernimmt das Routing)
+    return f"/screenshots/{client_uuid}?t={cache_buster}"
+
+def fetch_clients():
+    try:
+        verify_ssl = True if ENV == "production" else False
+        resp = requests.get(
+            f"{API_BASE_URL}/api/clients",
+            verify=verify_ssl
+        )
+        resp.raise_for_status()
+        return resp.json()
+    except Exception as e:
+        print("Fehler beim Abrufen der Clients:", e)
+        return []
+
+@dash.callback(
+    Output("clients-cards-container", "children"),
+    Input("interval-update", "n_intervals")
+)
+def update_clients(n):
+    # ... Session-Handling wie gehabt ...
+    ensure_mqtt_running()
+    clients = fetch_clients()
+    cards = []
+    for client in clients:
+        uuid = client["uuid"]
+        screenshot = get_latest_screenshot(uuid)
+        last_alive_utc = client.get("last_alive")
+        if last_alive_utc:
+            try:
+                # Unterstützt sowohl "2024-06-08T12:34:56Z" als auch "2024-06-08T12:34:56"
+                if last_alive_utc.endswith("Z"):
+                    dt_utc = datetime.strptime(last_alive_utc, "%Y-%m-%dT%H:%M:%SZ")
+                else:
+                    dt_utc = datetime.strptime(last_alive_utc, "%Y-%m-%dT%H:%M:%S")
+                dt_utc = dt_utc.replace(tzinfo=pytz.UTC)
+                # Lokale Zeitzone fest angeben, z.B. Europe/Berlin
+                local_tz = pytz.timezone("Europe/Berlin")
+                dt_local = dt_utc.astimezone(local_tz)
+                last_alive_str = dt_local.strftime("%d.%m.%Y %H:%M:%S")
+            except Exception:
+                last_alive_str = last_alive_utc
+        else:
+            last_alive_str = "-"
+        
+        card = dbc.Card(
+            [
+                dbc.CardHeader(client["location"]),
+                dbc.CardBody([
+                    html.Img(
+                        src=screenshot,
+                        style={
+                            "width": "240px",
+                            "height": "135px",
+                            "object-fit": "cover",
+                            "display": "block",
+                            "margin-left": "auto",
+                            "margin-right": "auto"
+                        },
+                    ),
+                    html.P(f"IP: {client['ip_address'] or '-'}", className="card-text"),
+                    html.P(f"Letzte Aktivität: {last_alive_str}", className="card-text"),
+                    dbc.ButtonGroup([
+                        dbc.Button("Reload Page", color="primary", id={"type": "btn-reload", "index": uuid}, n_clicks=0),
+                        dbc.Button("Restart Client", color="danger", id={"type": "btn-restart", "index": uuid}, n_clicks=0),
+                    ], className="mt-2"),
+                    html.Div(id={"type": "restart-feedback", "index": uuid}),
+                    html.Div(id={"type": "reload-feedback", "index": uuid}),
+                ]),
+            ],
+            className="mb-4",
+            style={"width": "18rem"},
+        )
+        cards.append(dbc.Col(card, width=4))
+    return dbc.Row(cards)
+
+@dash.callback(
+    Output({"type": "restart-feedback", "index": MATCH}, "children"),
+    Input({"type": "btn-restart", "index": MATCH}, "n_clicks"),
+    State({"type": "btn-restart", "index": MATCH}, "id")
+)
+def on_restart(n_clicks, btn_id):
+    if n_clicks and n_clicks > 0:
+        cid = btn_id["index"]
+        payload = '{"command": "restart"}'
+        ok = publish(f"clients/{cid}/control", payload)
+        return "Befehl gesendet." if ok else "Fehler beim Senden."
+    return ""
+
+@dash.callback(
+    Output({"type": "reload-feedback", "index": MATCH}, "children"),
+    Input({"type": "btn-reload", "index": MATCH}, "n_clicks"),
+    State({"type": "btn-reload", "index": MATCH}, "id")
+)
+def on_reload(n_clicks, btn_id):
+    if n_clicks and n_clicks > 0:
+        cid = btn_id["index"]
+        payload = '{"command": "reload"}'
+        ok = publish(f"clients/{cid}/control", payload)
+        return "Befehl gesendet." if ok else "Fehler beim Senden."
+    return ""

dashboard-dash-backup/callbacks/settings_callbacks.py

@@ -0,0 +1,20 @@
+# dashboard/callbacks/settings_callbacks.py
+import dash
+from dash import Input, Output, State, dcc
+from flask import session
+from utils.db import execute_query, execute_non_query
+
+@dash.callback(
+    Output("settings-feedback", "children"),
+    Input("btn-save-settings", "n_clicks"),
+    State("input-default-volume", "value"),
+    prevent_initial_call=True
+)
+def save_settings(n_clicks, volume):
+    if "role" not in session:
+        return dcc.Location(href="/login")
+    if n_clicks and n_clicks > 0:
+        sql = "UPDATE global_settings SET value=%s WHERE key='default_volume'"
+        rc = execute_non_query(sql, (volume,))
+        return "Einstellungen gespeichert." if rc else "Speichern fehlgeschlagen."
+    return ""

dashboard-dash-backup/callbacks/ui_callbacks.py

@@ -0,0 +1,26 @@
+# dashboard/callbacks/ui_callbacks.py
+
+from dash import Input, Output, State, callback
+from components.sidebar import Sidebar
+
+@callback(
+    Output("sidebar", "children"),
+    Output("sidebar", "className"),
+    Input("sidebar-state", "data"),
+)
+def render_sidebar(data):
+    collapsed = data.get("collapsed", False)
+    return Sidebar(collapsed=collapsed), f"sidebar{' collapsed' if collapsed else ''}"
+
+@callback(
+    Output("sidebar-state", "data"),
+    Input("btn-toggle-sidebar", "n_clicks"),
+    State("sidebar-state", "data"),
+    prevent_initial_call=True,
+)
+def toggle_sidebar(n, data):
+    if n is None:
+        # Kein Klick, nichts ändern!
+        return data
+    collapsed = not data.get("collapsed", False)
+    return {"collapsed": collapsed}

dashboard-dash-backup/callbacks/users_callbacks.py

@@ -0,0 +1,24 @@
+# dashboard/callbacks/users_callbacks.py
+import dash
+from dash import Input, Output, State, dcc
+from flask import session
+from utils.db import execute_query, execute_non_query
+from utils.auth import hash_password
+
+@dash.callback(
+    Output("users-feedback", "children"),
+    Input("btn-new-user", "n_clicks"),
+    State("input-new-username", "value"),
+    State("input-new-password", "value"),
+    State("input-new-role", "value"),
+    prevent_initial_call=True
+)
+def create_user(n_clicks, uname, pwd, role):
+    if session.get("role") != "admin":
+        return "Keine Berechtigung."
+    if n_clicks and n_clicks > 0:
+        pwd_hash = hash_password(pwd)
+        sql = "INSERT INTO users (username, pwd_hash, role) VALUES (%s, %s, %s)"
+        rc = execute_non_query(sql, (uname, pwd_hash, role))
+        return "Benutzer erstellt." if rc else "Fehler beim Erstellen."
+    return ""