first commit

backend/app/services/kiosk_settings.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from typing import Any
+
+from flask import session
+
+from app.core_settings import AppSettings, get_settings
+from app.storage.kiosk_settings import SQLiteKioskSettingsRepository
+
+
+VALID_MODES = {"public", "private"}
+DEFAULT_WIDGETS = ["hero", "history", "strings", "status", "production", "comparison", "importStatus"]
+VALID_WIDGETS = {"hero", "quickMetrics", "history", "status", "strings", "production", "comparison", "distribution", "importStatus"}
+VALID_REALTIME_RANGES = {"today", "yesterday", "6h", "12h", "24h", "48h", "7d"}
+VALID_ANALYTICS_RANGES = {"today", "yesterday", "7d", "30d", "90d", "365d", "custom"}
+
+
+class KioskSettingsService:
+    def __init__(self, settings: AppSettings | None = None) -> None:
+        self.settings = settings or get_settings()
+        self.repository = SQLiteKioskSettingsRepository(self.settings.storage["sqlite_path"])
+
+    def get(self, mode: str) -> dict[str, Any]:
+        normalized_mode = self._normalize_mode(mode)
+        stored = self.repository.get(normalized_mode)
+        if stored is None:
+            return self._default_payload(normalized_mode)
+        return self._sanitize_payload(normalized_mode, stored, persist_if_changed=False)
+
+    def update(self, mode: str, payload: dict[str, Any], updated_by: str | None = None) -> dict[str, Any]:
+        normalized_mode = self._normalize_mode(mode)
+        merged = {**self.get(normalized_mode), **(payload or {})}
+        cleaned = self._sanitize_payload(normalized_mode, merged, persist_if_changed=False)
+        return self.repository.upsert(normalized_mode, cleaned, updated_by=updated_by)
+
+    def update_from_session(self, mode: str, payload: dict[str, Any]) -> dict[str, Any]:
+        updated_by = session.get("auth_user")
+        return self.update(mode, payload, updated_by=updated_by)
+
+    def _default_payload(self, mode: str) -> dict[str, Any]:
+        return {
+            "mode": mode,
+            "widgets": list(DEFAULT_WIDGETS),
+            "realtime_range": self._default_realtime_range(),
+            "analytics_range": self._default_analytics_range(),
+            "analytics_bucket": self._default_analytics_bucket(),
+            "compare_mode": self._default_compare_mode(),
+            "updated_at": None,
+            "updated_by": None,
+        }
+
+    def _sanitize_payload(self, mode: str, payload: dict[str, Any], persist_if_changed: bool = False) -> dict[str, Any]:
+        cleaned = {
+            "mode": mode,
+            "widgets": self._normalize_widgets(payload.get("widgets")),
+            "realtime_range": self._normalize_realtime_range(payload.get("realtime_range")),
+            "analytics_range": self._normalize_analytics_range(payload.get("analytics_range")),
+            "analytics_bucket": self._normalize_bucket(payload.get("analytics_bucket")),
+            "compare_mode": self._normalize_compare_mode(payload.get("compare_mode")),
+            "updated_at": payload.get("updated_at"),
+            "updated_by": payload.get("updated_by"),
+        }
+        if persist_if_changed:
+            return self.repository.upsert(mode, cleaned, updated_by=cleaned.get("updated_by"))
+        return cleaned
+
+    def _normalize_mode(self, mode: str) -> str:
+        normalized = (mode or "").strip().lower()
+        if normalized not in VALID_MODES:
+            raise ValueError("Mode musi byc jednym z: public, private")
+        return normalized
+
+    def _normalize_widgets(self, widgets: Any) -> list[str]:
+        if not isinstance(widgets, list):
+            return list(DEFAULT_WIDGETS)
+        normalized: list[str] = []
+        for item in widgets:
+            widget = str(item or "").strip()
+            if widget in VALID_WIDGETS and widget not in normalized:
+                normalized.append(widget)
+        return normalized or list(DEFAULT_WIDGETS)
+
+    def _normalize_realtime_range(self, value: Any) -> str:
+        normalized = str(value or self._default_realtime_range()).strip()
+        return normalized if normalized in VALID_REALTIME_RANGES else self._default_realtime_range()
+
+    def _normalize_analytics_range(self, value: Any) -> str:
+        normalized = str(value or self._default_analytics_range()).strip()
+        return normalized if normalized in VALID_ANALYTICS_RANGES else self._default_analytics_range()
+
+    def _normalize_bucket(self, value: Any) -> str:
+        normalized = str(value or self._default_analytics_bucket()).strip()
+        return normalized if normalized in self.settings.analytics["bucket_labels"] else self._default_analytics_bucket()
+
+    def _normalize_compare_mode(self, value: Any) -> str:
+        normalized = str(value or self._default_compare_mode()).strip()
+        return normalized if normalized in self.settings.analytics["compare_modes"] else self._default_compare_mode()
+
+    def _default_realtime_range(self) -> str:
+        raw = str(self.settings.realtime.get("history_default_range", "12h"))
+        return raw if raw in VALID_REALTIME_RANGES else "12h"
+
+    def _default_analytics_range(self) -> str:
+        raw = str(self.settings.analytics.get("default_range", "30d"))
+        return raw if raw in VALID_ANALYTICS_RANGES else "30d"
+
+    def _default_analytics_bucket(self) -> str:
+        raw = str(self.settings.analytics.get("default_bucket", "day"))
+        return raw if raw in self.settings.analytics["bucket_labels"] else "day"
+
+    def _default_compare_mode(self) -> str:
+        raw = str(self.settings.analytics.get("default_compare", "none"))
+        return raw if raw in self.settings.analytics["compare_modes"] else "none"
+
+
+_kiosk_settings_service: KioskSettingsService | None = None
+
+
+def get_kiosk_settings_service() -> KioskSettingsService:
+    global _kiosk_settings_service
+    if _kiosk_settings_service is None:
+        _kiosk_settings_service = KioskSettingsService()
+    return _kiosk_settings_service