fix(notifications): hide dead "Mark all read" button + add motion toggle

Two related fixes on the notification inbox UX:

1. "Mark all read" button was always a no-op

   Opening the bell panel already calls markAllViewed() to clear the
   badge (see togglePanel), so by the time the button was visible the
   work was done. Clicking it re-ran the same call with no visible
   effect — users thought it was broken. Gate the button on
   unreadCount > 0 so it only appears when there's actually unread
   content (new items arriving via SSE while the panel is open).

2. Motion notifications were un-silenceable

   Add a per-org preferences gate (motion / camera transition / node
   transition) stored via the existing Setting key/value table. The
   gate lives inside create_notification() so every emitter respects
   it without duplicating the check. Defaults match previous behaviour
   ("all on") so existing orgs see no change until an admin flips a
   toggle off.

   Motion events are still recorded to the database for incidents and
   analytics — the gate only suppresses the bell-inbox row. Motion SSE
   (dashboard toasts) is intentionally NOT gated: if we ever want to
   mute those too it's a separate toggle.

   UI: Settings > Notifications > "Motion detection" toggle. Backend
   also exposes camera/node transition toggles (same pattern) ready
   for a future UI addition.

Tests: 9 new backend tests covering the gate helper, the routes (GET,
POST, admin-only, round-trip), and the /api/settings aggregate. Full
suite: 164 passed (was 155).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Sbussiso

backend/app/api/cameras.py

@@ -10,9 +10,20 @@
 from app.models.models import Camera, CameraGroup, Setting, AuditLog
 from app.schemas.schemas import (
     CameraGroupCreate,
+    NotificationSettings,
     RecordingSettings,
 )
 
+
+# Shared defaults for notification toggles — used by the GET handler and
+# the /api/settings aggregate.  Pydantic's NotificationSettings holds the
+# canonical values; this dict re-expresses them as strings for Setting.get_many.
+_NOTIFICATION_SETTING_DEFAULTS = {
+    "motion_notifications": "true",
+    "camera_transition_notifications": "true",
+    "node_transition_notifications": "true",
+}
+
 router = APIRouter(prefix="/api", tags=["api"])
 logger = logging.getLogger(__name__)
 
@@ -233,6 +244,7 @@ async def get_all_settings(
         "scheduled_start": "06:00",
         "scheduled_end": "17:00",
         "continuous_24_7": "false",
+        **_NOTIFICATION_SETTING_DEFAULTS,
     })
     return {
         "recording": {
@@ -241,6 +253,11 @@ async def get_all_settings(
             "scheduled_end": vals["scheduled_end"],
             "continuous_24_7": vals["continuous_24_7"] == "true",
         },
+        "notifications": {
+            "motion_notifications": vals["motion_notifications"] == "true",
+            "camera_transition_notifications": vals["camera_transition_notifications"] == "true",
+            "node_transition_notifications": vals["node_transition_notifications"] == "true",
+        },
     }
 
 
@@ -295,6 +312,67 @@ async def update_recording_settings(
     return {"success": True}
 
 
+# Notification preferences — parallel to the recording settings pair.
+# GET is view-level (every member needs to know what's on), POST is
+# admin-only (same audit-worthy gate as the other per-org toggles).
+
+@router.get("/settings/notifications")
+async def get_notification_settings(
+    user: AuthUser = Depends(require_view), db: Session = Depends(get_db)
+):
+    """Return the org's notification preferences.
+
+    Defaults to "all on" for backward compat with orgs that existed
+    before the settings UI landed — the gate only starts filtering
+    after an admin explicitly flips a toggle off.
+    """
+    vals = Setting.get_many(db, user.org_id, _NOTIFICATION_SETTING_DEFAULTS)
+    return {
+        "motion_notifications": vals["motion_notifications"] == "true",
+        "camera_transition_notifications": vals["camera_transition_notifications"] == "true",
+        "node_transition_notifications": vals["node_transition_notifications"] == "true",
+    }
+
+
+@router.post("/settings/notifications")
+@limiter.limit("30/minute")
+async def update_notification_settings(
+    data: NotificationSettings,
+    request: Request,
+    user: AuthUser = Depends(require_admin),
+    db: Session = Depends(get_db),
+):
+    """Update notification preferences. Requires admin.
+
+    Persists each toggle as a stringified bool so the existing Setting
+    key/value table can store it without a schema change — same
+    convention the recording toggles use.
+    """
+    Setting.set(db, user.org_id, "motion_notifications", str(data.motion_notifications).lower())
+    Setting.set(
+        db, user.org_id, "camera_transition_notifications",
+        str(data.camera_transition_notifications).lower(),
+    )
+    Setting.set(
+        db, user.org_id, "node_transition_notifications",
+        str(data.node_transition_notifications).lower(),
+    )
+    write_audit(
+        db,
+        org_id=user.org_id,
+        event="notification_settings_updated",
+        user_id=user.user_id,
+        username=audit_label(user),
+        details={
+            "motion_notifications": bool(data.motion_notifications),
+            "camera_transition_notifications": bool(data.camera_transition_notifications),
+            "node_transition_notifications": bool(data.node_transition_notifications),
+        },
+        request=request,
+    )
+    return {"success": True}
+
+
 # Audit Logs
 @router.get("/audit-logs")
 async def list_audit_logs(

backend/app/api/notifications.py

@@ -29,7 +29,41 @@
 
 from app.core.auth import AuthUser, require_view
 from app.core.database import SessionLocal, get_db
-from app.models.models import Notification, UserNotificationState
+from app.models.models import Notification, Setting, UserNotificationState
+
+
+# ── Per-org preference gate ────────────────────────────────────────
+# Which notification kinds the org wants delivered to the inbox.
+# Defaults intentionally match "everything on" so behaviour before the
+# settings UI shipped is unchanged — operators only ever see less noise
+# than before, never more.  Keys map kind → (setting_key, default).
+
+_NOTIFICATION_KIND_TO_SETTING: dict[str, tuple[str, bool]] = {
+    "motion": ("motion_notifications", True),
+    "camera_online": ("camera_transition_notifications", True),
+    "camera_offline": ("camera_transition_notifications", True),
+    "node_online": ("node_transition_notifications", True),
+    "node_offline": ("node_transition_notifications", True),
+}
+
+
+def notifications_enabled(db: Session, org_id: str, kind: str) -> bool:
+    """Return True if notifications of ``kind`` should be delivered for
+    ``org_id``.  Unknown kinds default to enabled so new notification
+    types don't silently disappear when added without a settings migration.
+
+    Reads from the ``Setting`` table using the same "string value" pattern
+    the recording toggles use.  Keeping it here (not in the motion path)
+    means every emitter can gate without duplicating the lookup logic.
+    """
+    cfg = _NOTIFICATION_KIND_TO_SETTING.get(kind)
+    if cfg is None:
+        return True
+    key, default = cfg
+    val = Setting.get(db, org_id, key, None)
+    if val is None:
+        return default
+    return val == "true"
 
 logger = logging.getLogger(__name__)
 
@@ -124,6 +158,20 @@ def create_notification(
     if severity not in ("info", "warning", "error", "critical"):
         severity = "info"
 
+    # Per-org preference gate — an operator who turned off "motion
+    # notifications" in Settings should stop seeing new motion rows in
+    # the inbox without affecting the motion-event pipeline itself.
+    # Done here (vs. at each call site) so every emitter, current and
+    # future, automatically respects the toggle.
+    try:
+        if not notifications_enabled(session, org_id, kind):
+            return None
+    except Exception:
+        # Gate failures must not block notifications — fall through to
+        # the normal create path so we're no worse off than before the
+        # gate existed.
+        logger.exception("[Notifications] preference lookup failed; emitting anyway")
+
     try:
         notif = Notification(
             org_id=org_id,

backend/app/schemas/schemas.py

@@ -15,6 +15,19 @@ class RecordingSettings(BaseModel):
     continuous_24_7: bool = False
 
 
+class NotificationSettings(BaseModel):
+    """Per-org toggles controlling which kinds of notifications show up in
+    the bell inbox.  Camera/node transitions stay on by default because
+    those are operator-critical; motion can get noisy so we let operators
+    silence it per-org without disabling the motion-event pipeline itself
+    (motion still records to the DB for incidents and analytics).
+    """
+
+    motion_notifications: bool = True
+    camera_transition_notifications: bool = True
+    node_transition_notifications: bool = True
+
+
 class CameraReport(BaseModel):
     camera_id: Optional[str] = Field(None, max_length=150)
     device_path: Optional[str] = Field(None, max_length=255)

backend/tests/test_cameras.py

@@ -16,7 +16,7 @@ def test_list_cameras_empty(admin_client):
 
 
 def test_get_settings(admin_client):
-    """Settings endpoint returns recording settings without fake detection fields."""
+    """Settings endpoint returns recording + notification sections."""
     from app.core.auth import require_view
     from tests.conftest import _make_admin_user
     app = admin_client.app
@@ -32,14 +32,21 @@ def test_get_settings(admin_client):
     assert "scheduled_recording" in recording
     assert "continuous_24_7" in recording
 
-    # Should NOT have fake detection fields
+    # Should NOT have fake detection fields — these were removed because
+    # the backend never actually did motion/face/object recording.
     assert "motion_recording" not in recording
     assert "face_recording" not in recording
     assert "object_recording" not in recording
     assert "post_buffer" not in recording
 
-    # Should NOT have notifications section
-    assert "notifications" not in data
+    # Should have notifications section with all three toggles defaulted on
+    # (backwards compat: orgs that pre-date the toggle default to everything
+    # enabled, same behaviour they had before).
+    assert "notifications" in data
+    notifications = data["notifications"]
+    assert notifications["motion_notifications"] is True
+    assert notifications["camera_transition_notifications"] is True
+    assert notifications["node_transition_notifications"] is True
 
 
 def test_update_recording_settings(admin_client):
@@ -54,11 +61,58 @@ def test_update_recording_settings(admin_client):
     assert resp.json()["success"] is True
 
 
-def test_notification_endpoints_removed(admin_client):
-    """Fake notification endpoints should no longer exist."""
+def test_get_notification_settings_defaults_on(admin_client):
+    """New orgs see all notification toggles enabled by default."""
     resp = admin_client.get("/api/settings/notifications")
-    # Should return 404 (or be caught by SPA middleware)
-    assert resp.status_code in (404, 405, 200)  # 200 if SPA middleware serves index.html
+    assert resp.status_code == 200
+    body = resp.json()
+    assert body["motion_notifications"] is True
+    assert body["camera_transition_notifications"] is True
+    assert body["node_transition_notifications"] is True
+
+
+def test_update_notification_settings(admin_client):
+    """Admin can flip motion notifications off and the change persists."""
+    resp = admin_client.post("/api/settings/notifications", json={
+        "motion_notifications": False,
+        "camera_transition_notifications": True,
+        "node_transition_notifications": True,
+    })
+    assert resp.status_code == 200
+    assert resp.json()["success"] is True
+
+    # Round-trip: GET must reflect the change
+    follow = admin_client.get("/api/settings/notifications")
+    assert follow.status_code == 200
+    body = follow.json()
+    assert body["motion_notifications"] is False
+    assert body["camera_transition_notifications"] is True
+    assert body["node_transition_notifications"] is True
+
+
+def test_notification_settings_reflected_in_all_settings(admin_client):
+    """After toggling motion off, /api/settings aggregate shows the change."""
+    admin_client.post("/api/settings/notifications", json={
+        "motion_notifications": False,
+        "camera_transition_notifications": True,
+        "node_transition_notifications": True,
+    })
+    resp = admin_client.get("/api/settings")
+    assert resp.status_code == 200
+    assert resp.json()["notifications"]["motion_notifications"] is False
+
+
+def test_update_notification_settings_requires_admin(viewer_client):
+    """Non-admin members can't flip the toggles."""
+    resp = viewer_client.post("/api/settings/notifications", json={
+        "motion_notifications": False,
+        "camera_transition_notifications": True,
+        "node_transition_notifications": True,
+    })
+    # require_admin yields 401/403/404 depending on the auth layer's
+    # rejection path — viewer_client doesn't override require_admin so
+    # the real dependency runs and rejects.
+    assert resp.status_code in (401, 403)
 
 
 def test_camera_groups_crud(admin_client):

backend/tests/test_notifications.py

@@ -23,9 +23,10 @@
     emit_camera_transition,
     emit_node_transition,
     notification_broadcaster,
+    notifications_enabled,
 )
 from app.main import run_offline_sweep
-from app.models.models import Camera, CameraNode, Notification, UserNotificationState
+from app.models.models import Camera, CameraNode, Notification, Setting, UserNotificationState
 from tests.conftest import TestSession
 
 
@@ -473,3 +474,85 @@ def test_offline_sweep_mixed_fresh_and_stale(db):
     notifs = {n.kind: n for n in db.query(Notification).all()}
     assert notifs["camera_offline"].node_id == "node_1"  # linked to parent node
     assert notifs["node_offline"].audience == "admin"
+
+
+# ── Preference gate ────────────────────────────────────────────────
+# The Settings UI lets operators silence specific notification kinds
+# without disabling the underlying event pipeline.  These tests pin the
+# gate's behaviour so a refactor can't silently stop respecting the
+# toggle (which would be noisy in the worst way — spam returns).
+
+def test_notifications_enabled_defaults_true(db):
+    # No Setting row exists → gate returns the per-kind default, which is
+    # True for every kind we ship today.  Legacy orgs shouldn't lose
+    # notifications just because they never visited the settings page.
+    assert notifications_enabled(db, "org_test123", "motion") is True
+    assert notifications_enabled(db, "org_test123", "camera_offline") is True
+    assert notifications_enabled(db, "org_test123", "node_online") is True
+
+
+def test_notifications_enabled_honors_false_flag(db):
+    Setting.set(db, "org_test123", "motion_notifications", "false")
+    assert notifications_enabled(db, "org_test123", "motion") is False
+    # Other kinds unaffected — each toggle is scoped to its setting key.
+    assert notifications_enabled(db, "org_test123", "camera_offline") is True
+
+
+def test_notifications_enabled_unknown_kind_defaults_true(db):
+    # A future notification kind added without a settings migration
+    # should default to delivered, not silently dropped.
+    assert notifications_enabled(db, "org_test123", "brand_new_kind") is True
+
+
+def test_create_notification_respects_motion_toggle(db):
+    Setting.set(db, "org_test123", "motion_notifications", "false")
+
+    result = create_notification(
+        org_id="org_test123",
+        kind="motion",
+        title="Motion on cam_abc",
+        body="Scene change detected at 42% intensity.",
+        audience="all",
+        camera_id="cam_abc",
+        db=db,
+    )
+
+    # Gate returns None when disabled — no row persisted, no broadcast.
+    assert result is None
+    assert db.query(Notification).filter_by(kind="motion").count() == 0
+
+
+def test_create_notification_motion_allowed_when_toggle_on(db):
+    # Explicitly enable (belt-and-suspenders; default is also True).
+    Setting.set(db, "org_test123", "motion_notifications", "true")
+
+    result = create_notification(
+        org_id="org_test123",
+        kind="motion",
+        title="Motion on cam_abc",
+        audience="all",
+        camera_id="cam_abc",
+        db=db,
+    )
+
+    assert result is not None
+    assert db.query(Notification).filter_by(kind="motion").count() == 1
+
+
+def test_create_notification_camera_transition_gated(db):
+    # Camera online/offline share one toggle.  Turning it off suppresses
+    # BOTH directions — the user either wants camera transition alerts or
+    # doesn't.
+    Setting.set(db, "org_test123", "camera_transition_notifications", "false")
+
+    offline = create_notification(
+        org_id="org_test123", kind="camera_offline",
+        title="cam_abc offline", audience="all", db=db,
+    )
+    online = create_notification(
+        org_id="org_test123", kind="camera_online",
+        title="cam_abc online", audience="all", db=db,
+    )
+    assert offline is None
+    assert online is None
+    assert db.query(Notification).count() == 0