arthexis 0.1.17__py3-none-any.whl → 0.1.19__py3-none-any.whl

pages/tests.py

@@ -8,18 +8,19 @@ django.setup()
 
 from django.test import Client, RequestFactory, TestCase, SimpleTestCase, override_settings
 from django.test.utils import CaptureQueriesContext
-from django.urls import NoReverseMatch, reverse
+from django.urls import reverse
 from django.templatetags.static import static
 from urllib.parse import quote
 from django.contrib.auth import get_user_model
 from django.contrib.sites.models import Site
-from django.contrib import admin
+from django.contrib import admin, messages
 from django.contrib.messages.storage.fallback import FallbackStorage
 from django.core.exceptions import DisallowedHost
 from django.core.cache import cache
 from django.db import connection
 import socket
 from django.db import connection
+from pages import site_config
 from pages.models import (
     Application,
     Landing,
@@ -32,6 +33,8 @@ from pages.models import (
     UserManual,
     UserStory,
 )
+from django.http import FileResponse
+
 from pages.admin import (
     ApplicationAdmin,
     UserManualAdmin,
@@ -47,6 +50,7 @@ from pages.screenshot_specs import (
 )
 from pages.context_processors import nav_links
 from django.apps import apps as django_apps
+from config.middleware import SiteHttpsRedirectMiddleware
 from core import mailer
 from core.admin import ProfileAdminMixin
 from core.models import (
@@ -60,8 +64,10 @@ from core.models import (
     Todo,
     TOTPDeviceSettings,
 )
+from ocpp.models import Charger
 from django.core.files.uploadedfile import SimpleUploadedFile
 import base64
+import json
 import tempfile
 import shutil
 from io import StringIO
@@ -72,6 +78,7 @@ from types import SimpleNamespace
 from django.core.management import call_command
 import re
 from django.contrib.contenttypes.models import ContentType
+from django.http import HttpResponse
 from datetime import (
     date,
     datetime,
@@ -685,23 +692,6 @@ class AdminDashboardAppListTests(TestCase):
         resp = self.client.get(reverse("admin:index"))
         self.assertContains(resp, "5. Horologia MODELS")
 
-    def test_dashboard_handles_missing_last_net_message_url(self):
-        from pages.templatetags import admin_extras
-
-        real_reverse = admin_extras.reverse
-
-        def fake_reverse(name, *args, **kwargs):
-            if name == "last-net-message":
-                raise NoReverseMatch("missing")
-            return real_reverse(name, *args, **kwargs)
-
-        with patch("pages.templatetags.admin_extras.reverse", side_effect=fake_reverse):
-            resp = self.client.get(reverse("admin:index"))
-
-        self.assertEqual(resp.status_code, 200)
-        self.assertNotIn(b"last-net-message", resp.content)
-
-
 class AdminSidebarTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -811,7 +801,8 @@ class ViewHistoryLoggingTests(TestCase):
         )
         landing = module.landings.get(path="/")
         landing.label = "Home Landing"
-        landing.save(update_fields=["label"])
+        landing.track_leads = True
+        landing.save(update_fields=["label", "track_leads"])
 
         resp = self.client.get(
             reverse("pages:index"), HTTP_REFERER="https://example.com/ref"
@@ -836,7 +827,8 @@ class ViewHistoryLoggingTests(TestCase):
         )
         landing = module.landings.get(path="/")
         landing.label = "No Celery"
-        landing.save(update_fields=["label"])
+        landing.track_leads = True
+        landing.save(update_fields=["label", "track_leads"])
 
         resp = self.client.get(reverse("pages:index"))
 
@@ -856,7 +848,8 @@ class ViewHistoryLoggingTests(TestCase):
         )
         landing = module.landings.get(path="/")
         landing.enabled = False
-        landing.save(update_fields=["enabled"])
+        landing.track_leads = True
+        landing.save(update_fields=["enabled", "track_leads"])
 
         resp = self.client.get(reverse("pages:index"))
 
@@ -1125,6 +1118,50 @@ class LogViewerAdminTests(SimpleTestCase):
         self.assertEqual(context["selected_log"], "selected.log")
         self.assertIn("hello world", context["log_content"])
 
+    def test_log_viewer_applies_line_limit(self):
+        content = "\n".join(f"line {i}" for i in range(50))
+        self._create_log("limited.log", content)
+        response = self._render({"log": "limited.log", "limit": "20"})
+        context = response.context_data
+        self.assertEqual(context["log_limit_choice"], "20")
+        self.assertIn("line 49", context["log_content"])
+        self.assertIn("line 30", context["log_content"])
+        self.assertNotIn("line 29", context["log_content"])
+
+    def test_log_viewer_all_limit_returns_full_log(self):
+        content = "first\nsecond\nthird"
+        self._create_log("all.log", content)
+        response = self._render({"log": "all.log", "limit": "all"})
+        context = response.context_data
+        self.assertEqual(context["log_limit_choice"], "all")
+        self.assertIn("first", context["log_content"])
+        self.assertIn("second", context["log_content"])
+
+    def test_log_viewer_invalid_limit_defaults_to_20(self):
+        content = "\n".join(f"item {i}" for i in range(5))
+        self._create_log("invalid-limit.log", content)
+        response = self._render({"log": "invalid-limit.log", "limit": "oops"})
+        context = response.context_data
+        self.assertEqual(context["log_limit_choice"], "20")
+
+    def test_log_viewer_downloads_selected_log(self):
+        self._create_log("download.log", "downloadable content")
+        request = self._build_request({"log": "download.log", "download": "1"})
+        context = {
+            "site_title": "Constellation",
+            "site_header": "Constellation",
+            "site_url": "/",
+            "available_apps": [],
+        }
+        with patch("pages.admin.admin.site.each_context", return_value=context), patch(
+            "pages.context_processors.get_site", return_value=None
+        ):
+            response = log_viewer(request)
+        self.assertIsInstance(response, FileResponse)
+        self.assertIn("attachment", response["Content-Disposition"])
+        content = b"".join(response.streaming_content).decode()
+        self.assertIn("downloadable content", content)
+
     def test_log_viewer_reports_missing_log(self):
         response = self._render({"log": "missing.log"})
         self.assertIn("requested log could not be found", response.context_data["log_error"])
@@ -1172,6 +1209,125 @@ class AdminModelStatusTests(TestCase):
         self.assertContains(resp, 'class="model-status missing"', count=1)
 
 
+class _FakeQuerySet(list):
+    def only(self, *args, **kwargs):
+        return self
+
+    def order_by(self, *args, **kwargs):
+        return self
+
+
+class SiteConfigurationStagingTests(SimpleTestCase):
+    def setUp(self):
+        self.tmpdir = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, self.tmpdir)
+        self.config_path = Path(self.tmpdir) / "nginx-sites.json"
+        self._path_patcher = patch(
+            "pages.site_config._sites_config_path", side_effect=lambda: self.config_path
+        )
+        self._path_patcher.start()
+        self.addCleanup(self._path_patcher.stop)
+        self._model_patcher = patch("pages.site_config.apps.get_model")
+        self.mock_get_model = self._model_patcher.start()
+        self.addCleanup(self._model_patcher.stop)
+
+    def _read_config(self):
+        if not self.config_path.exists():
+            return None
+        return json.loads(self.config_path.read_text(encoding="utf-8"))
+
+    def _set_sites(self, sites):
+        queryset = _FakeQuerySet(sites)
+
+        class _Manager:
+            @staticmethod
+            def filter(**kwargs):
+                return queryset
+
+        self.mock_get_model.return_value = SimpleNamespace(objects=_Manager())
+
+    def test_managed_site_persists_configuration(self):
+        self._set_sites([SimpleNamespace(domain="example.com", require_https=True)])
+        site_config.update_local_nginx_scripts()
+        config = self._read_config()
+        self.assertEqual(
+            config,
+            [
+                {
+                    "domain": "example.com",
+                    "require_https": True,
+                }
+            ],
+        )
+
+    def test_disabling_managed_site_removes_entry(self):
+        primary = SimpleNamespace(domain="primary.test", require_https=False)
+        secondary = SimpleNamespace(domain="secondary.test", require_https=False)
+        self._set_sites([primary, secondary])
+        site_config.update_local_nginx_scripts()
+        config = self._read_config()
+        self.assertEqual(
+            [entry["domain"] for entry in config],
+            ["primary.test", "secondary.test"],
+        )
+
+        self._set_sites([secondary])
+        site_config.update_local_nginx_scripts()
+        config = self._read_config()
+        self.assertEqual(config, [{"domain": "secondary.test", "require_https": False}])
+
+        self._set_sites([])
+        site_config.update_local_nginx_scripts()
+        self.assertIsNone(self._read_config())
+
+    def test_require_https_toggle_updates_configuration(self):
+        site = SimpleNamespace(domain="secure.example", require_https=False)
+        self._set_sites([site])
+        site_config.update_local_nginx_scripts()
+        config = self._read_config()
+        self.assertEqual(config, [{"domain": "secure.example", "require_https": False}])
+
+        site.require_https = True
+        self._set_sites([site])
+        site_config.update_local_nginx_scripts()
+        config = self._read_config()
+        self.assertEqual(config, [{"domain": "secure.example", "require_https": True}])
+
+
+class SiteRequireHttpsMiddlewareTests(SimpleTestCase):
+    def setUp(self):
+        self.factory = RequestFactory()
+        self.middleware = SiteHttpsRedirectMiddleware(lambda request: HttpResponse("ok"))
+        self.secure_site = SimpleNamespace(domain="secure.test", require_https=True)
+
+    def test_http_request_redirects_to_https(self):
+        request = self.factory.get("/", HTTP_HOST="secure.test")
+        request.site = self.secure_site
+        response = self.middleware(request)
+        self.assertEqual(response.status_code, 301)
+        self.assertTrue(response["Location"].startswith("https://secure.test"))
+
+    def test_secure_request_not_redirected(self):
+        request = self.factory.get("/", HTTP_HOST="secure.test", secure=True)
+        request.site = self.secure_site
+        response = self.middleware(request)
+        self.assertEqual(response.status_code, 200)
+
+    def test_forwarded_proto_respected(self):
+        request = self.factory.get(
+            "/", HTTP_HOST="secure.test", HTTP_X_FORWARDED_PROTO="https"
+        )
+        request.site = self.secure_site
+        response = self.middleware(request)
+        self.assertEqual(response.status_code, 200)
+
+        self.secure_site.require_https = False
+        request = self.factory.get("/", HTTP_HOST="secure.test")
+        request.site = self.secure_site
+        response = self.middleware(request)
+        self.assertEqual(response.status_code, 200)
+
+
 class SiteAdminRegisterCurrentTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -1323,17 +1479,17 @@ class NavAppsTests(TestCase):
         )
         app = Application.objects.create(name="Readme")
         Module.objects.create(
-            node_role=role, application=app, path="/", is_default=True
+            node_role=role, application=app, path="/", is_default=True, menu="Cookbook"
         )
 
     def test_nav_pill_renders(self):
         resp = self.client.get(reverse("pages:index"))
-        self.assertContains(resp, "README")
+        self.assertContains(resp, "COOKBOOK")
         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")
-        self.assertContains(resp, "README")
+        self.assertContains(resp, "COOKBOOK")
 
     def test_nav_pill_uses_menu_field(self):
         site_app = Module.objects.get()
@@ -1341,7 +1497,7 @@ class NavAppsTests(TestCase):
         site_app.save()
         resp = self.client.get(reverse("pages:index"))
         self.assertContains(resp, 'badge rounded-pill text-bg-secondary">DOCS')
-        self.assertNotContains(resp, 'badge rounded-pill text-bg-secondary">README')
+        self.assertNotContains(resp, 'badge rounded-pill text-bg-secondary">COOKBOOK')
 
     def test_app_without_root_url_excluded(self):
         role = NodeRole.objects.get(name="Terminal")
@@ -1711,8 +1867,57 @@ class ControlNavTests(TestCase):
 
     def test_readme_pill_visible(self):
         resp = self.client.get(reverse("pages:readme"))
-        self.assertContains(resp, 'href="/readme/"')
-        self.assertContains(resp, 'badge rounded-pill text-bg-secondary">README')
+        self.assertContains(resp, 'href="/read/"')
+        self.assertContains(resp, 'badge rounded-pill text-bg-secondary">COOKBOOK')
+
+    def test_cookbook_pill_has_no_dropdown(self):
+        module = Module.objects.get(node_role__name="Control", path="/read/")
+        Landing.objects.create(
+            module=module,
+            path="/man/",
+            label="Manuals",
+            enabled=True,
+        )
+
+        resp = self.client.get(reverse("pages:readme"))
+
+        self.assertContains(
+            resp,
+            '<a class="nav-link" href="/read/"><span class="badge rounded-pill text-bg-secondary">COOKBOOK</span></a>',
+            html=True,
+        )
+        self.assertNotContains(resp, 'dropdown-item" href="/man/"')
+
+    def test_readme_page_includes_qr_share(self):
+        resp = self.client.get(reverse("pages:readme"), {"section": "intro"})
+        self.assertContains(resp, 'id="reader-qr"')
+        self.assertContains(
+            resp,
+            'data-url="http://testserver/read/?section=intro"',
+        )
+        self.assertNotContains(resp, "Scan this page")
+        self.assertNotContains(
+            resp, 'class="small text-break text-muted mt-3 mb-0"'
+        )
+
+    def test_readme_document_by_name(self):
+        resp = self.client.get(reverse("pages:readme-document", args=["AGENTS.md"]))
+        self.assertEqual(resp.status_code, 200)
+        self.assertContains(resp, "Agent Guidelines")
+
+    def test_readme_document_by_relative_path(self):
+        resp = self.client.get(
+            reverse(
+                "pages:readme-document",
+                args=["docs/development/maintenance-roadmap.md"],
+            )
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.assertContains(resp, "Maintenance Improvement Proposals")
+
+    def test_readme_document_rejects_traversal(self):
+        resp = self.client.get("/read/../../SECRET.md")
+        self.assertEqual(resp.status_code, 404)
 
 
 class SatelliteNavTests(TestCase):
@@ -1784,8 +1989,8 @@ class SatelliteNavTests(TestCase):
 
     def test_readme_pill_visible(self):
         resp = self.client.get(reverse("pages:readme"))
-        self.assertContains(resp, 'href="/readme/"')
-        self.assertContains(resp, 'badge rounded-pill text-bg-secondary">README')
+        self.assertContains(resp, 'href="/read/"')
+        self.assertContains(resp, 'badge rounded-pill text-bg-secondary">COOKBOOK')
 
 
 class PowerNavTests(TestCase):
@@ -2064,6 +2269,47 @@ class UserManualAdminFormTests(TestCase):
         self.assertEqual(form.cleaned_data["content_pdf"], self.manual.content_pdf)
 
 
+class UserManualModelTests(TestCase):
+    def _build_manual(self, **overrides):
+        defaults = {
+            "slug": "manual-model-test",
+            "title": "Manual Model",
+            "description": "Manual description",
+            "languages": "en",
+            "content_html": "<p>Manual</p>",
+            "content_pdf": base64.b64encode(b"initial").decode("ascii"),
+        }
+        defaults.update(overrides)
+        return UserManual(**defaults)
+
+    def test_save_encodes_uploaded_file(self):
+        upload = SimpleUploadedFile("manual.pdf", b"PDF data")
+        manual = self._build_manual(slug="manual-upload", content_pdf=upload)
+        manual.save()
+        manual.refresh_from_db()
+        self.assertEqual(
+            manual.content_pdf,
+            base64.b64encode(b"PDF data").decode("ascii"),
+        )
+
+    def test_save_encodes_raw_bytes(self):
+        manual = self._build_manual(slug="manual-bytes", content_pdf=b"PDF raw")
+        manual.save()
+        manual.refresh_from_db()
+        self.assertEqual(
+            manual.content_pdf,
+            base64.b64encode(b"PDF raw").decode("ascii"),
+        )
+
+    def test_save_strips_data_uri_prefix(self):
+        encoded = base64.b64encode(b"PDF data").decode("ascii")
+        data_uri = f"data:application/pdf;base64,{encoded}"
+        manual = self._build_manual(slug="manual-data-uri", content_pdf=data_uri)
+        manual.save()
+        manual.refresh_from_db()
+        self.assertEqual(manual.content_pdf, encoded)
+
+
 class LandingCreationTests(TestCase):
     def setUp(self):
         role, _ = NodeRole.objects.get_or_create(name="Terminal")
@@ -2422,6 +2668,48 @@ class FavoriteTests(TestCase):
         self.assertContains(resp, f'title="{badge_label}"')
         self.assertContains(resp, f'aria-label="{badge_label}"')
 
+    def test_dashboard_shows_charge_point_availability_badge(self):
+        Charger.objects.create(
+            charger_id="CP-001", connector_id=1, last_status="Available"
+        )
+        Charger.objects.create(charger_id="CP-002", last_status="Available")
+        Charger.objects.create(
+            charger_id="CP-003", connector_id=1, last_status="Unavailable"
+        )
+
+        resp = self.client.get(reverse("admin:index"))
+
+        expected = "1 / 2"
+        badge_label = gettext(
+            "%(available)s chargers reporting Available status with a CP number, out of %(total)s total Available chargers. %(missing)s Available chargers are missing a connector number."
+        ) % {"available": 1, "total": 2, "missing": 1}
+
+        self.assertContains(resp, expected)
+        self.assertContains(resp, 'class="charger-availability-badge"')
+        self.assertContains(resp, f'title="{badge_label}"')
+        self.assertContains(resp, f'aria-label="{badge_label}"')
+
+    def test_dashboard_charge_point_badge_ignores_aggregator(self):
+        Charger.objects.create(charger_id="CP-AGG", last_status="Available")
+        Charger.objects.create(
+            charger_id="CP-AGG", connector_id=1, last_status="Available"
+        )
+        Charger.objects.create(
+            charger_id="CP-AGG", connector_id=2, last_status="Available"
+        )
+
+        resp = self.client.get(reverse("admin:index"))
+
+        expected = "2 / 2"
+        badge_label = gettext(
+            "%(available)s chargers reporting Available status with a CP number."
+        ) % {"available": 2}
+
+        self.assertContains(resp, expected)
+        self.assertContains(resp, 'class="charger-availability-badge"')
+        self.assertContains(resp, f'title="{badge_label}"')
+        self.assertContains(resp, f'aria-label="{badge_label}"')
+
     def test_nav_sidebar_hides_dashboard_badges(self):
         InviteLead.objects.create(email="open@example.com")
         RFID.objects.create(rfid="RFID0003", released=True, allowed=True)
@@ -3159,6 +3447,40 @@ class UserStoryAdminActionTests(TestCase):
 
         mock_create_issue.assert_not_called()
 
+    def test_create_github_issues_action_links_to_credentials_when_missing(self):
+        request = self._build_request()
+        queryset = UserStory.objects.filter(pk=self.story.pk)
+
+        mock_url = "/admin/core/releasemanager/"
+        with (
+            patch(
+                "pages.admin.reverse", return_value=mock_url
+            ) as mock_reverse,
+            patch.object(
+                UserStory,
+                "create_github_issue",
+                side_effect=RuntimeError("GitHub token is not configured"),
+            ),
+        ):
+            self.admin.create_github_issues(request, queryset)
+
+        messages_list = list(request._messages)
+        self.assertTrue(messages_list)
+
+        opts = ReleaseManager._meta
+        mock_reverse.assert_called_once_with(
+            f"{self.admin.admin_site.name}:{opts.app_label}_{opts.model_name}_changelist"
+        )
+        self.assertTrue(
+            any(mock_url in message.message for message in messages_list),
+        )
+        self.assertTrue(
+            any("Configure GitHub credentials" in message.message for message in messages_list),
+        )
+        self.assertTrue(
+            any(message.level == messages.ERROR for message in messages_list),
+        )
+
 
 class ClientReportLiveUpdateTests(TestCase):
     def setUp(self):

pages/urls.py

@@ -6,7 +6,8 @@ app_name = "pages"
 
 urlpatterns = [
     path("", views.index, name="index"),
-    path("readme/", views.readme, name="readme"),
+    path("read/", views.readme, name="readme"),
+    path("read/<path:doc>", views.readme, name="readme-document"),
     path("sitemap.xml", views.sitemap, name="pages-sitemap"),
     path("release/", views.release_admin_redirect, name="release-admin"),
     path("client-report/", views.client_report, name="client-report"),

pages/views.py

@@ -439,38 +439,80 @@ def admin_model_graph(request, app_label: str):
     return response
 
 
-def _render_readme(request, role):
+def _render_readme(request, role, doc: str | None = None):
     app = (
         Module.objects.filter(node_role=role, is_default=True)
         .select_related("application")
         .first()
     )
     app_slug = app.path.strip("/") if app else ""
-    readme_base = (
-        Path(settings.BASE_DIR) / app_slug if app_slug else Path(settings.BASE_DIR)
-    )
+    root_base = Path(settings.BASE_DIR).resolve()
+    readme_base = (root_base / app_slug).resolve() if app_slug else root_base
     lang = getattr(request, "LANGUAGE_CODE", "")
     lang = lang.replace("_", "-").lower()
-    root_base = Path(settings.BASE_DIR)
     candidates = []
-    if lang:
-        candidates.append(readme_base / f"README.{lang}.md")
-        short = lang.split("-")[0]
-        if short != lang:
-            candidates.append(readme_base / f"README.{short}.md")
-    candidates.append(readme_base / "README.md")
-    if readme_base != root_base:
+    if doc:
+        normalized = doc.strip().replace("\\", "/")
+        while normalized.startswith("./"):
+            normalized = normalized[2:]
+        normalized = normalized.lstrip("/")
+        if not normalized:
+            raise Http404("Document not found")
+        doc_path = Path(normalized)
+        if doc_path.is_absolute() or any(part == ".." for part in doc_path.parts):
+            raise Http404("Document not found")
+
+        relative_candidates: list[Path] = []
+
+        def add_candidate(path: Path) -> None:
+            if path not in relative_candidates:
+                relative_candidates.append(path)
+
+        add_candidate(doc_path)
+        if doc_path.suffix.lower() != ".md" or doc_path.suffix != ".md":
+            add_candidate(doc_path.with_suffix(".md"))
+        if doc_path.suffix.lower() != ".md":
+            add_candidate(doc_path / "README.md")
+
+        search_roots = [readme_base]
+        if readme_base != root_base:
+            search_roots.append(root_base)
+
+        for relative in relative_candidates:
+            for base in search_roots:
+                base_resolved = base.resolve()
+                candidate = (base_resolved / relative).resolve(strict=False)
+                try:
+                    candidate.relative_to(base_resolved)
+                except ValueError:
+                    continue
+                candidates.append(candidate)
+    else:
         if lang:
-            candidates.append(root_base / f"README.{lang}.md")
+            candidates.append(readme_base / f"README.{lang}.md")
             short = lang.split("-")[0]
             if short != lang:
-                candidates.append(root_base / f"README.{short}.md")
-        candidates.append(root_base / "README.md")
-    readme_file = next((p for p in candidates if p.exists()), root_base / "README.md")
+                candidates.append(readme_base / f"README.{short}.md")
+        candidates.append(readme_base / "README.md")
+        if readme_base != root_base:
+            if lang:
+                candidates.append(root_base / f"README.{lang}.md")
+                short = lang.split("-")[0]
+                if short != lang:
+                    candidates.append(root_base / f"README.{short}.md")
+            candidates.append(root_base / "README.md")
+    readme_file = next((p for p in candidates if p.exists()), None)
+    if readme_file is None:
+        raise Http404("Document not found")
     text = readme_file.read_text(encoding="utf-8")
     html, toc_html = _render_markdown_with_toc(text)
     title = "README" if readme_file.name.startswith("README") else readme_file.stem
-    context = {"content": html, "title": title, "toc": toc_html}
+    context = {
+        "content": html,
+        "title": title,
+        "toc": toc_html,
+        "page_url": request.build_absolute_uri(),
+    }
     response = render(request, "pages/readme.html", context)
     patch_vary_headers(response, ["Accept-Language", "Cookie"])
     return response
@@ -525,10 +567,10 @@ def index(request):
 
 
 @never_cache
-def readme(request):
+def readme(request, doc=None):
     node = Node.get_local()
     role = node.role if node else None
-    return _render_readme(request, role)
+    return _render_readme(request, role, doc)
 
 
 def sitemap(request):
@@ -976,10 +1018,10 @@ class ClientReportForm(forms.Form):
         label=_("Email destinations"),
         required=False,
         widget=forms.Textarea(attrs={"rows": 2}),
-        help_text=_("Separate addresses with commas or new lines."),
+        help_text=_("Separate addresses with commas, whitespace, or new lines."),
     )
     recurrence = forms.ChoiceField(
-        label=_("Recurrency"),
+        label=_("Recurrence"),
         choices=RECURRENCE_CHOICES,
         initial=ClientReportSchedule.PERIODICITY_NONE,
         help_text=_("Defines how often the report should be generated automatically."),
@@ -1006,8 +1048,13 @@ class ClientReportForm(forms.Form):
             week_str = cleaned.get("week")
             if not week_str:
                 raise forms.ValidationError(_("Please select a week."))
-            year, week_num = week_str.split("-W")
-            start = datetime.date.fromisocalendar(int(year), int(week_num), 1)
+            try:
+                year_str, week_num_str = week_str.split("-W", 1)
+                start = datetime.date.fromisocalendar(
+                    int(year_str), int(week_num_str), 1
+                )
+            except (TypeError, ValueError):
+                raise forms.ValidationError(_("Please select a week."))
             cleaned["start"] = start
             cleaned["end"] = start + datetime.timedelta(days=6)
         elif period == "month":