arthexis 0.1.26__py3-none-any.whl → 0.1.28__py3-none-any.whl

ocpp/urls.py

@@ -5,6 +5,11 @@ from . import views
 urlpatterns = [
     path("cpms/dashboard/", views.dashboard, name="ocpp-dashboard"),
     path("evcs/simulator/", views.cp_simulator, name="cp-simulator"),
+    path(
+        "firmware/<int:deployment_id>/<slug:token>/",
+        views.firmware_download,
+        name="cp-firmware-download",
+    ),
     path("chargers/", views.charger_list, name="charger-list"),
     path("chargers/<str:cid>/", views.charger_detail, name="charger-detail"),
     path(

ocpp/views.py

@@ -30,7 +30,13 @@ from core.liveupdate import live_update
 from django.utils.dateparse import parse_datetime
 
 from . import store
-from .models import Transaction, Charger, DataTransferMessage, RFID
+from .models import (
+    Transaction,
+    Charger,
+    DataTransferMessage,
+    RFID,
+    CPFirmwareDeployment,
+)
 from .evcs import (
     _start_simulator,
     _stop_simulator,
@@ -44,23 +50,53 @@ CALL_ACTION_LABELS = {
     "RemoteStartTransaction": _("Remote start transaction"),
     "RemoteStopTransaction": _("Remote stop transaction"),
     "ChangeAvailability": _("Change availability"),
+    "ChangeConfiguration": _("Change configuration"),
     "DataTransfer": _("Data transfer"),
     "Reset": _("Reset"),
     "TriggerMessage": _("Trigger message"),
     "ReserveNow": _("Reserve connector"),
+    "ClearCache": _("Clear cache"),
 }
 
 CALL_EXPECTED_STATUSES: dict[str, set[str]] = {
     "RemoteStartTransaction": {"Accepted"},
     "RemoteStopTransaction": {"Accepted"},
     "ChangeAvailability": {"Accepted", "Scheduled"},
+    "ChangeConfiguration": {"Accepted", "Rejected", "RebootRequired"},
     "DataTransfer": {"Accepted"},
     "Reset": {"Accepted"},
     "TriggerMessage": {"Accepted"},
     "ReserveNow": {"Accepted"},
+    "ClearCache": {"Accepted", "Rejected"},
 }
 
 
+def firmware_download(request, deployment_id: int, token: str):
+    deployment = get_object_or_404(
+        CPFirmwareDeployment,
+        pk=deployment_id,
+        download_token=token,
+    )
+    expires = deployment.download_token_expires_at
+    if expires and timezone.now() > expires:
+        return HttpResponse(status=403)
+    firmware = deployment.firmware
+    if firmware is None:
+        raise Http404
+    payload = firmware.get_payload_bytes()
+    if not payload:
+        raise Http404
+    content_type = firmware.content_type or "application/octet-stream"
+    response = HttpResponse(payload, content_type=content_type)
+    filename = firmware.filename or f"firmware_{firmware.pk or deployment.pk}"
+    safe_filename = filename.replace("\r", "").replace("\n", "").replace("\"", "")
+    response["Content-Disposition"] = f'attachment; filename="{safe_filename}"'
+    response["Content-Length"] = str(len(payload))
+    deployment.downloaded_at = timezone.now()
+    deployment.save(update_fields=["downloaded_at", "updated_at"])
+    return response
+
+
 def _format_details(value: object) -> str:
     """Return a JSON representation of ``value`` suitable for error messages."""
 
@@ -119,6 +155,7 @@ def _evaluate_pending_call_result(
     if expected_statuses is not None:
         status_value = str(payload_dict.get("status") or "").strip()
         normalized_expected = {value.casefold() for value in expected_statuses if value}
+        remaining = {k: v for k, v in payload_dict.items() if k != "status"}
         if not status_value:
             detail = _("%(action)s response did not include a status.") % {
                 "action": action_label,
@@ -129,7 +166,15 @@ def _evaluate_pending_call_result(
                 "action": action_label,
                 "status": status_value,
             }
-            remaining = {k: v for k, v in payload_dict.items() if k != "status"}
+            extra = _format_details(remaining)
+            if extra:
+                detail += " " + _("Details: %(details)s") % {"details": extra}
+            return False, detail, 400
+        if status_value.casefold() == "rejected":
+            detail = _("%(action)s rejected with status %(status)s.") % {
+                "action": action_label,
+                "status": status_value,
+            }
             extra = _format_details(remaining)
             if extra:
                 detail += " " + _("Details: %(details)s") % {"details": extra}
@@ -401,72 +446,61 @@ def _collect_status_events(
         keys.append(store.identity_key(serial, None))
         keys.append(store.pending_key(serial))
 
-    seen_entries: set[str] = set()
     events: list[tuple[datetime, str]] = []
     latest_before_window: tuple[datetime, str] | None = None
 
-    for key in keys:
-        for entry in store.get_logs(key, log_type="charger"):
-            if entry in seen_entries:
-                continue
-            seen_entries.add(entry)
-            if len(entry) < 24:
-                continue
-            timestamp_raw = entry[:23]
-            message = entry[24:].strip()
-            try:
-                log_timestamp = datetime.strptime(
-                    timestamp_raw, "%Y-%m-%d %H:%M:%S.%f"
-                ).replace(tzinfo=dt_timezone.utc)
-            except ValueError:
-                continue
+    for entry in store.iter_log_entries(keys, log_type="charger", since=window_start):
+        if len(entry.text) < 24:
+            continue
+        message = entry.text[24:].strip()
+        log_timestamp = entry.timestamp
 
-            event_time = log_timestamp
-            status_bucket: str | None = None
+        event_time = log_timestamp
+        status_bucket: str | None = None
 
-            if message.startswith("StatusNotification processed:"):
-                payload_text = message.split(":", 1)[1].strip()
+        if message.startswith("StatusNotification processed:"):
+            payload_text = message.split(":", 1)[1].strip()
+            try:
+                payload = json.loads(payload_text)
+            except json.JSONDecodeError:
+                continue
+            target_id = payload.get("connectorId")
+            if connector_id is not None:
                 try:
-                    payload = json.loads(payload_text)
-                except json.JSONDecodeError:
+                    normalized_target = int(target_id)
+                except (TypeError, ValueError):
+                    normalized_target = None
+                if normalized_target not in {connector_id, None}:
                     continue
-                target_id = payload.get("connectorId")
-                if connector_id is not None:
-                    try:
-                        normalized_target = int(target_id)
-                    except (TypeError, ValueError):
-                        normalized_target = None
-                    if normalized_target not in {connector_id, None}:
-                        continue
-                raw_status = payload.get("status")
-                status_bucket = _normalize_timeline_status(
-                    raw_status if isinstance(raw_status, str) else None
-                )
-                payload_timestamp = payload.get("timestamp")
-                if isinstance(payload_timestamp, str):
-                    parsed = parse_datetime(payload_timestamp)
-                    if parsed is not None:
-                        if timezone.is_naive(parsed):
-                            parsed = timezone.make_aware(parsed, timezone=dt_timezone.utc)
-                        event_time = parsed
-            elif message.startswith("Connected"):
-                status_bucket = "available"
-            elif message.startswith("Closed"):
-                status_bucket = "offline"
-
-            if not status_bucket:
-                continue
+            raw_status = payload.get("status")
+            status_bucket = _normalize_timeline_status(
+                raw_status if isinstance(raw_status, str) else None
+            )
+            payload_timestamp = payload.get("timestamp")
+            if isinstance(payload_timestamp, str):
+                parsed = parse_datetime(payload_timestamp)
+                if parsed is not None:
+                    if timezone.is_naive(parsed):
+                        parsed = timezone.make_aware(parsed, timezone=dt_timezone.utc)
+                    event_time = parsed
+        elif message.startswith("Connected"):
+            status_bucket = "available"
+        elif message.startswith("Closed"):
+            status_bucket = "offline"
+
+        if not status_bucket:
+            continue
 
-            if event_time < window_start:
-                if (
-                    latest_before_window is None
-                    or event_time > latest_before_window[0]
-                ):
-                    latest_before_window = (event_time, status_bucket)
-                continue
-            if event_time > window_end:
-                continue
-            events.append((event_time, status_bucket))
+        if event_time < window_start:
+            if (
+                latest_before_window is None
+                or event_time > latest_before_window[0]
+            ):
+                latest_before_window = (event_time, status_bucket)
+            break
+        if event_time > window_end:
+            continue
+        events.append((event_time, status_bucket))
 
     events.sort(key=lambda item: item[0])
 
@@ -1695,17 +1729,9 @@ def charger_log_page(request, cid, connector=None):
         limit_choice = "20"
     limit_index = allowed_values.index(limit_choice)
 
-    log_entries_all = list(store.get_logs(target_id, log_type=log_type) or [])
     download_requested = request.GET.get("download") == "1"
-    if download_requested:
-        download_content = "\n".join(log_entries_all)
-        if download_content and not download_content.endswith("\n"):
-            download_content = f"{download_content}\n"
-        response = HttpResponse(download_content, content_type="text/plain; charset=utf-8")
-        response["Content-Disposition"] = f'attachment; filename="{download_filename}"'
-        return response
 
-    log_entries = log_entries_all
+    limit_value: int | None = None
     if limit_choice != "all":
         try:
             limit_value = int(limit_choice)
@@ -1713,7 +1739,19 @@ def charger_log_page(request, cid, connector=None):
             limit_value = 20
             limit_choice = "20"
             limit_index = allowed_values.index(limit_choice)
-        log_entries = log_entries[-limit_value:]
+    log_entries: list[str]
+    if download_requested:
+        log_entries = list(store.get_logs(target_id, log_type=log_type) or [])
+        download_content = "\n".join(log_entries)
+        if download_content and not download_content.endswith("\n"):
+            download_content = f"{download_content}\n"
+        response = HttpResponse(download_content, content_type="text/plain; charset=utf-8")
+        response["Content-Disposition"] = f'attachment; filename="{download_filename}"'
+        return response
+
+    log_entries = list(
+        store.get_logs(target_id, log_type=log_type, limit=limit_value) or []
+    )
 
     download_params = request.GET.copy()
     download_params["download"] = "1"
@@ -1896,6 +1934,70 @@ def dispatch_action(request, cid, connector=None):
             Charger.objects.filter(pk=charger_obj.pk).update(**updates)
             for field, value in updates.items():
                 setattr(charger_obj, field, value)
+    elif action == "change_configuration":
+        raw_key = data.get("key")
+        if not isinstance(raw_key, str) or not raw_key.strip():
+            return JsonResponse({"detail": "key required"}, status=400)
+        key_value = raw_key.strip()
+        raw_value = data.get("value", None)
+        value_included = False
+        value_text: str | None = None
+        if raw_value is not None:
+            if isinstance(raw_value, (str, int, float, bool)):
+                value_included = True
+                if isinstance(raw_value, str):
+                    value_text = raw_value
+                else:
+                    value_text = str(raw_value)
+            else:
+                return JsonResponse(
+                    {"detail": "value must be a string, number, or boolean"},
+                    status=400,
+                )
+        payload = {"key": key_value}
+        if value_included:
+            payload["value"] = value_text
+        message_id = uuid.uuid4().hex
+        ocpp_action = "ChangeConfiguration"
+        expected_statuses = CALL_EXPECTED_STATUSES.get(ocpp_action)
+        msg = json.dumps([2, message_id, "ChangeConfiguration", payload])
+    elif action == "clear_cache":
+        message_id = uuid.uuid4().hex
+        ocpp_action = "ClearCache"
+        expected_statuses = CALL_EXPECTED_STATUSES.get(ocpp_action)
+        msg = json.dumps([2, message_id, "ClearCache", {}])
+        async_to_sync(ws.send)(msg)
+        requested_at = timezone.now()
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "ChangeConfiguration",
+                "charger_id": cid,
+                "connector_id": connector_value,
+                "log_key": log_key,
+                "key": key_value,
+                "value": value_text,
+                "requested_at": requested_at,
+            },
+        )
+        timeout_message = str(_("Change configuration request timed out."))
+        store.schedule_call_timeout(
+            message_id,
+            action="ChangeConfiguration",
+            log_key=log_key,
+            message=timeout_message,
+        )
+        if value_included and value_text is not None:
+            change_message = str(
+                _("Requested configuration change for %(key)s to %(value)s")
+                % {"key": key_value, "value": value_text}
+            )
+        else:
+            change_message = str(
+                _("Requested configuration change for %(key)s")
+                % {"key": key_value}
+            )
+        store.add_log(log_key, change_message, log_type="charger")
     elif action == "data_transfer":
         vendor_id = data.get("vendorId")
         if not isinstance(vendor_id, str) or not vendor_id.strip():

pages/context_processors.py

@@ -1,5 +1,6 @@
 from utils.sites import get_site
 from django.urls import Resolver404, resolve
+from django.shortcuts import resolve_url
 from django.conf import settings
 from pathlib import Path
 from nodes.models import Node
@@ -148,4 +149,5 @@ def nav_links(request):
         "nav_modules": valid_modules,
         "favicon_url": favicon_url,
         "header_references": header_references,
+        "login_url": resolve_url(settings.LOGIN_URL),
     }

pages/models.py

@@ -56,6 +56,11 @@ class Application(Entity):
             return self.name
 
 
+    class Meta:
+        verbose_name = _("Application")
+        verbose_name_plural = _("Applications")
+
+
 class ModuleManager(models.Manager):
     def get_by_natural_key(self, role: str, path: str):
         return self.get(node_role__name=role, path=path)
@@ -222,6 +227,8 @@ class Landing(Entity):
 
     class Meta:
         unique_together = ("module", "path")
+        verbose_name = _("Landing")
+        verbose_name_plural = _("Landings")
 
     def __str__(self) -> str:  # pragma: no cover - simple representation
         return f"{self.label} ({self.path})"
@@ -515,6 +522,8 @@ class Favorite(Entity):
     class Meta:
         unique_together = ("user", "content_type")
         ordering = ["priority", "pk"]
+        verbose_name = _("Favorite")
+        verbose_name_plural = _("Favorites")
 
 
 class UserStory(Lead):

pages/tests.py

@@ -10,6 +10,7 @@ django.setup()
 from django.test import Client, RequestFactory, TestCase, SimpleTestCase, override_settings
 from django.test.utils import CaptureQueriesContext
 from django.urls import reverse
+from django.shortcuts import resolve_url
 from django.templatetags.static import static
 from urllib.parse import quote
 from django.contrib.auth import get_user_model
@@ -56,6 +57,7 @@ from core import mailer
 from core.admin import ProfileAdminMixin
 from core.models import (
     AdminHistory,
+    ClientReport,
     InviteLead,
     Package,
     Reference,
@@ -123,9 +125,26 @@ class LoginViewTests(TestCase):
         self.user = User.objects.create_user(username="user", password="pwd")
         Site.objects.update_or_create(id=1, defaults={"name": "Terminal"})
 
+    def _enable_rfid_scanner(self):
+        node, _ = Node.objects.get_or_create(
+            mac_address=Node.get_current_mac(),
+            defaults={"hostname": "local-node"},
+        )
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="rfid-scanner", defaults={"display": "RFID Scanner"}
+        )
+        NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+        return node
+
     def test_login_link_in_navbar(self):
         resp = self.client.get(reverse("pages:index"))
-        self.assertContains(resp, 'href="/login/"')
+        login_url = resolve_url(settings.LOGIN_URL)
+        self.assertContains(resp, f'href="{login_url}"')
+
+    @override_settings(LOGIN_URL="/staff/login/")
+    def test_login_link_uses_configured_login_url(self):
+        resp = self.client.get(reverse("pages:index"))
+        self.assertContains(resp, 'href="/staff/login/"')
 
     def test_login_page_shows_authenticator_toggle(self):
         resp = self.client.get(reverse("pages:login"))
@@ -201,6 +220,48 @@ class LoginViewTests(TestCase):
         )
         self.assertRedirects(resp, "/nodes/list/")
 
+    def test_login_page_shows_rfid_link_when_feature_enabled(self):
+        self._enable_rfid_scanner()
+        resp = self.client.get(reverse("pages:login"))
+        self.assertContains(resp, reverse("pages:rfid-login"))
+
+    def test_login_page_detects_rfid_lock_without_mac_address(self):
+        Node.objects.all().delete()
+        NodeFeature.objects.get_or_create(
+            slug="rfid-scanner", defaults={"display": "RFID Scanner"}
+        )
+        with tempfile.TemporaryDirectory() as tempdir:
+            locks_dir = Path(tempdir) / "locks"
+            locks_dir.mkdir()
+            (locks_dir / "rfid.lck").touch()
+            Node.objects.create(
+                hostname="local-node",
+                base_path=tempdir,
+                current_relation=Node.Relation.SELF,
+                mac_address=None,
+            )
+
+            resp = self.client.get(reverse("pages:login"))
+
+        self.assertContains(resp, reverse("pages:rfid-login"))
+
+    def test_rfid_login_page_requires_feature(self):
+        resp = self.client.get(reverse("pages:rfid-login"))
+        self.assertEqual(resp.status_code, 404)
+
+    def test_rfid_login_page_redirects_authenticated_user(self):
+        self._enable_rfid_scanner()
+        self.client.force_login(self.user)
+        resp = self.client.get(reverse("pages:rfid-login"))
+        self.assertRedirects(resp, "/")
+
+    def test_rfid_login_page_includes_scan_url(self):
+        self._enable_rfid_scanner()
+        resp = self.client.get(reverse("pages:rfid-login"))
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(resp.context["login_api_url"], reverse("rfid-login"))
+        self.assertEqual(resp.context["scan_api_url"], reverse("rfid-scan-next"))
+
     def test_homepage_excludes_version_banner_for_anonymous(self):
         response = self.client.get(reverse("pages:index"))
 
@@ -726,7 +787,7 @@ class AdminDashboardAppListTests(TestCase):
                 "hostname": socket.gethostname(),
                 "address": socket.gethostbyname(socket.gethostname()),
                 "base_path": settings.BASE_DIR,
-                "port": 8000,
+                "port": 8888,
             },
         )
         self.node.features.clear()
@@ -859,8 +920,11 @@ class ViewHistoryLoggingTests(TestCase):
 
     def _reset_purge_task(self):
         from django_celery_beat.models import PeriodicTask
+        from core.celery_utils import periodic_task_name_variants
 
-        PeriodicTask.objects.filter(name="pages_purge_landing_leads").delete()
+        PeriodicTask.objects.filter(
+            name__in=periodic_task_name_variants("pages_purge_landing_leads")
+        ).delete()
 
     def _create_local_node(self):
         node, _ = Node.objects.update_or_create(
@@ -869,7 +933,7 @@ class ViewHistoryLoggingTests(TestCase):
                 "hostname": socket.gethostname(),
                 "address": "127.0.0.1",
                 "base_path": settings.BASE_DIR,
-                "port": 8000,
+                "port": 8888,
             },
         )
         return node
@@ -1178,7 +1242,7 @@ class LandingLeadAdminTests(TestCase):
                 "hostname": socket.gethostname(),
                 "address": "127.0.0.1",
                 "base_path": settings.BASE_DIR,
-                "port": 8000,
+                "port": 8888,
             },
         )
         self.node.features.clear()
@@ -1186,8 +1250,11 @@ class LandingLeadAdminTests(TestCase):
 
     def _reset_purge_task(self):
         from django_celery_beat.models import PeriodicTask
+        from core.celery_utils import periodic_task_name_variants
 
-        PeriodicTask.objects.filter(name="pages_purge_landing_leads").delete()
+        PeriodicTask.objects.filter(
+            name__in=periodic_task_name_variants("pages_purge_landing_leads")
+        ).delete()
 
     def test_changelist_warns_without_celery(self):
         url = reverse("admin:pages_landinglead_changelist")
@@ -1403,15 +1470,12 @@ class AdminModelStatusTests(TestCase):
 
         Node.objects.create(hostname="testserver", address="127.0.0.1")
 
-    @patch("pages.templatetags.admin_extras.connection.introspection.table_names")
-    def test_status_dots_render(self, mock_tables):
-        from django.db import connection
-
-        tables = type(connection.introspection).table_names(connection.introspection)
-        mock_tables.return_value = [t for t in tables if t != "pages_module"]
+    def test_status_indicator_removed(self):
         resp = self.client.get(reverse("admin:index"))
-        self.assertContains(resp, 'class="model-status ok"')
-        self.assertContains(resp, 'class="model-status missing"', count=1)
+        self.assertNotContains(resp, "class=\"model-status")
+
+        changelist = self.client.get(reverse("admin:pages_application_changelist"))
+        self.assertNotContains(changelist, "class=\"model-status")
 
 
 class _FakeQuerySet(list):
@@ -1694,7 +1758,7 @@ class NavAppsTests(TestCase):
         self.assertContains(resp, "badge rounded-pill")
 
     def test_nav_pill_renders_with_port(self):
-        resp = self.client.get(reverse("pages:index"), HTTP_HOST="127.0.0.1:8000")
+        resp = self.client.get(reverse("pages:index"), HTTP_HOST="127.0.0.1:8888")
         self.assertContains(resp, "COOKBOOKS")
 
     def test_nav_pill_uses_menu_field(self):
@@ -2324,6 +2388,68 @@ class PowerNavTests(TestCase):
         self.assertEqual(icon_index, -1)
 
 
+class WatchtowerLandingLinkTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        self.role, _ = NodeRole.objects.get_or_create(name="Watchtower")
+        Node.objects.update_or_create(
+            mac_address=Node.get_current_mac(),
+            defaults={
+                "hostname": "localhost",
+                "address": "127.0.0.1",
+                "role": self.role,
+            },
+        )
+        Site.objects.update_or_create(
+            id=1, defaults={"domain": "testserver", "name": ""}
+        )
+        self.ocpp_app, _ = Application.objects.get_or_create(name="ocpp")
+        self.ocpp_module, _ = Module.objects.get_or_create(
+            node_role=self.role,
+            application=self.ocpp_app,
+            path="/ocpp/",
+        )
+        self.ocpp_module.create_landings()
+
+    def _get_ocpp_module(self, response):
+        for module in response.context["nav_modules"]:
+            if module.path == "/ocpp/":
+                return module
+        return None
+
+    def test_ocpp_landings_present_for_anonymous_users(self):
+        response = self.client.get(reverse("pages:index"))
+        ocpp_module = self._get_ocpp_module(response)
+        self.assertIsNotNone(ocpp_module)
+        landing_by_label = {
+            landing.label: landing for landing in ocpp_module.enabled_landings
+        }
+        expected_landings = {
+            "CPMS Online Dashboard": "/ocpp/cpms/dashboard/",
+            "Charge Point Simulator": "/ocpp/evcs/simulator/",
+            "RFID Tag Validator": "/ocpp/rfid/validator/",
+        }
+        for label, path in expected_landings.items():
+            with self.subTest(label=label):
+                landing = landing_by_label.get(label)
+                self.assertIsNotNone(landing)
+                self.assertEqual(landing.path, path)
+                self.assertTrue(path.startswith("/"))
+                resolve(path)
+
+    def test_simulator_requires_login(self):
+        response = self.client.get(reverse("pages:index"))
+        ocpp_module = self._get_ocpp_module(response)
+        self.assertIsNotNone(ocpp_module)
+        locked_landings = {
+            landing.label: landing
+            for landing in ocpp_module.enabled_landings
+            if getattr(landing, "nav_is_locked", False)
+        }
+        simulator = locked_landings.get("Charge Point Simulator")
+        self.assertIsNotNone(simulator)
+        self.assertTrue(simulator.nav_is_locked)
+
 class StaffNavVisibilityTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -3133,7 +3259,7 @@ class FavoriteTests(TestCase):
             hostname="cached-node",
             address="127.0.0.1",
             mac_address="AA:BB:CC:DD:EE:FF",
-            port=8000,
+            port=8888,
             is_user_data=True,
         )
 
@@ -3580,7 +3706,7 @@ class UserStorySubmissionTests(TestCase):
             defaults={
                 "hostname": "local-node",
                 "address": "127.0.0.1",
-                "port": 8000,
+                "port": 8888,
                 "public_endpoint": "local-node",
             },
         )
@@ -3917,9 +4043,31 @@ class ClientReportLiveUpdateTests(TestCase):
 
     def test_client_report_includes_interval(self):
         resp = self.client.get(reverse("pages:client-report"))
-        self.assertEqual(resp.context["request"].live_update_interval, 5)
+        self.assertEqual(resp.wsgi_request.live_update_interval, 5)
         self.assertContains(resp, "setInterval(() => location.reload()")
 
+    def test_client_report_download_disables_refresh(self):
+        User = get_user_model()
+        user = User.objects.create_user(username="download-user", password="pwd")
+        report = ClientReport.objects.create(
+            start_date=date(2024, 1, 1),
+            end_date=date(2024, 1, 2),
+            data={},
+            owner=user,
+            disable_emails=True,
+            language="en",
+            title="",
+        )
+
+        self.client.force_login(user)
+        resp = self.client.get(
+            reverse("pages:client-report"), {"download": report.pk}
+        )
+
+        self.assertIsNone(getattr(resp.wsgi_request, "live_update_interval", None))
+        self.assertContains(resp, "report-download-frame")
+        self.assertNotContains(resp, "setInterval(() => location.reload()")
+
 
 class ScreenshotSpecInfrastructureTests(TestCase):
     def test_runner_creates_outputs_and_cleans_old_samples(self):

pages/urls.py

@@ -23,6 +23,7 @@ urlpatterns = [
         name="client-report-download",
     ),
     path("release-checklist", views.release_checklist, name="release-checklist"),
+    path("login/rfid/", views.rfid_login_page, name="rfid-login"),
     path("login/", views.login_view, name="login"),
     path("authenticator/setup/", views.authenticator_setup, name="authenticator-setup"),
     path("request-invite/", views.request_invite, name="request-invite"),