arthexis 0.1.16__py3-none-any.whl → 0.1.18__py3-none-any.whl

pages/admin.py

@@ -6,12 +6,13 @@ from django.contrib.sites.admin import SiteAdmin as DjangoSiteAdmin
 from django.contrib.sites.models import Site
 from django import forms
 from django.shortcuts import redirect, render, get_object_or_404
-from django.urls import path, reverse
+from django.urls import NoReverseMatch, path, reverse
 from django.utils.html import format_html
 from django.template.response import TemplateResponse
 from django.http import JsonResponse
 from django.utils import timezone
 from django.db.models import Count
+from django.core.exceptions import FieldError
 from django.db.models.functions import TruncDate
 from datetime import datetime, time, timedelta
 import ipaddress
@@ -25,6 +26,7 @@ from nodes.utils import capture_screenshot, save_screenshot
 
 from .forms import UserManualAdminForm
 from .module_defaults import reload_default_modules as restore_default_modules
+from .site_config import ensure_site_fields
 from .utils import landing_leads_supported
 
 from .models import (
@@ -41,6 +43,7 @@ from .models import (
     UserStory,
 )
 from django.contrib.contenttypes.models import ContentType
+from core.models import ReleaseManager
 from core.user_data import EntityModelAdmin
 
 
@@ -73,12 +76,47 @@ class SiteForm(forms.ModelForm):
         fields = "__all__"
 
 
+ensure_site_fields()
+
+
+class _BooleanAttributeListFilter(admin.SimpleListFilter):
+    """Filter helper for boolean attributes on :class:`~django.contrib.sites.models.Site`."""
+
+    field_name: str
+
+    def lookups(self, request, model_admin):  # pragma: no cover - admin UI
+        return (("1", _("Yes")), ("0", _("No")))
+
+    def queryset(self, request, queryset):
+        value = self.value()
+        if value not in {"0", "1"}:
+            return queryset
+        expected = value == "1"
+        try:
+            return queryset.filter(**{self.field_name: expected})
+        except FieldError:  # pragma: no cover - defensive when fields missing
+            return queryset
+
+
+class ManagedSiteListFilter(_BooleanAttributeListFilter):
+    title = _("Managed by local NGINX")
+    parameter_name = "managed"
+    field_name = "managed"
+
+
+class RequireHttpsListFilter(_BooleanAttributeListFilter):
+    title = _("Require HTTPS")
+    parameter_name = "require_https"
+    field_name = "require_https"
+
+
 class SiteAdmin(DjangoSiteAdmin):
     form = SiteForm
     inlines = [SiteBadgeInline]
     change_list_template = "admin/sites/site/change_list.html"
-    fields = ("domain", "name")
-    list_display = ("domain", "name")
+    fields = ("domain", "name", "managed", "require_https")
+    list_display = ("domain", "name", "managed", "require_https")
+    list_filter = (ManagedSiteListFilter, RequireHttpsListFilter)
     actions = ["capture_screenshot"]
 
     @admin.action(description="Capture screenshot")
@@ -110,6 +148,27 @@ class SiteAdmin(DjangoSiteAdmin):
                     messages.INFO,
                 )
 
+    def save_model(self, request, obj, form, change):
+        super().save_model(request, obj, form, change)
+        if {"managed", "require_https"} & set(form.changed_data or []):
+            self.message_user(
+                request,
+                _(
+                    "Managed NGINX configuration staged. Run network-setup.sh to apply changes."
+                ),
+                messages.INFO,
+            )
+
+    def delete_model(self, request, obj):
+        super().delete_model(request, obj)
+        self.message_user(
+            request,
+            _(
+                "Managed NGINX configuration staged. Run network-setup.sh to apply changes."
+            ),
+            messages.INFO,
+        )
+
     def _reload_site_fixtures(self, request):
         fixtures_dir = Path(settings.BASE_DIR) / "core" / "fixtures"
         fixture_paths = sorted(fixtures_dir.glob("references__00_site_*.json"))
@@ -708,10 +767,33 @@ class UserStoryAdmin(EntityModelAdmin):
                 issue_url = story.create_github_issue()
             except Exception as exc:  # pragma: no cover - network/runtime errors
                 logger.exception("Failed to create GitHub issue for UserStory %s", story.pk)
+                message = _("Unable to create a GitHub issue for %(story)s: %(error)s") % {
+                    "story": story,
+                    "error": exc,
+                }
+
+                if (
+                    isinstance(exc, RuntimeError)
+                    and "GitHub token is not configured" in str(exc)
+                ):
+                    try:
+                        opts = ReleaseManager._meta
+                        config_url = reverse(
+                            f"{self.admin_site.name}:{opts.app_label}_{opts.model_name}_changelist"
+                        )
+                    except NoReverseMatch:  # pragma: no cover - defensive guard
+                        config_url = None
+                    if config_url:
+                        message = format_html(
+                            "{} <a href=\"{}\">{}</a>",
+                            message,
+                            config_url,
+                            _("Configure GitHub credentials."),
+                        )
+
                 self.message_user(
                     request,
-                    _("Unable to create a GitHub issue for %(story)s: %(error)s")
-                    % {"story": story, "error": exc},
+                    message,
                     messages.ERROR,
                 )
                 continue

pages/apps.py

@@ -8,3 +8,6 @@ class PagesConfig(AppConfig):
 
     def ready(self):  # pragma: no cover - import for side effects
         from . import checks  # noqa: F401
+        from . import site_config
+
+        site_config.ready()

pages/site_config.py

@@ -0,0 +1,137 @@
+"""Customizations for :mod:`django.contrib.sites`."""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+
+from django.apps import apps
+from django.conf import settings
+from django.contrib.sites.models import Site
+from django.db import DatabaseError, models
+from django.db.models.signals import post_delete, post_migrate, post_save
+from django.dispatch import receiver
+from django.utils.translation import gettext_lazy as _
+
+
+logger = logging.getLogger(__name__)
+
+
+_FIELD_DEFINITIONS: tuple[tuple[str, models.Field], ...] = (
+    (
+        "managed",
+        models.BooleanField(
+            default=False,
+            db_default=False,
+            verbose_name=_("Managed by local NGINX"),
+            help_text=_(
+                "Include this site when staging the local NGINX configuration."
+            ),
+        ),
+    ),
+    (
+        "require_https",
+        models.BooleanField(
+            default=False,
+            db_default=False,
+            verbose_name=_("Require HTTPS"),
+            help_text=_(
+                "Redirect HTTP traffic to HTTPS when the staged NGINX configuration is applied."
+            ),
+        ),
+    ),
+)
+
+
+def _sites_config_path() -> Path:
+    return Path(settings.BASE_DIR) / "scripts" / "generated" / "nginx-sites.json"
+
+
+def _ensure_directories(path: Path) -> bool:
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+    except OSError as exc:  # pragma: no cover - filesystem errors
+        logger.warning("Unable to create directory for %s: %s", path, exc)
+        return False
+    return True
+
+
+def update_local_nginx_scripts() -> None:
+    """Serialize managed site configuration for the network setup script."""
+
+    SiteModel = apps.get_model("sites", "Site")
+    data: list[dict[str, object]] = []
+    seen_domains: set[str] = set()
+
+    try:
+        sites = list(
+            SiteModel.objects.filter(managed=True)
+            .only("domain", "require_https")
+            .order_by("domain")
+        )
+    except DatabaseError:  # pragma: no cover - database not ready
+        return
+
+    for site in sites:
+        domain = (site.domain or "").strip()
+        if not domain:
+            continue
+        if domain.lower() in seen_domains:
+            continue
+        seen_domains.add(domain.lower())
+        data.append({"domain": domain, "require_https": bool(site.require_https)})
+
+    output_path = _sites_config_path()
+    if not _ensure_directories(output_path):
+        return
+
+    if data:
+        try:
+            output_path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+        except OSError as exc:  # pragma: no cover - filesystem errors
+            logger.warning("Failed to write managed site configuration: %s", exc)
+    else:
+        try:
+            output_path.unlink()
+        except FileNotFoundError:
+            pass
+        except OSError as exc:  # pragma: no cover - filesystem errors
+            logger.warning("Failed to remove managed site configuration: %s", exc)
+
+
+def _install_fields() -> None:
+    for name, field in _FIELD_DEFINITIONS:
+        if hasattr(Site, name):
+            continue
+        Site.add_to_class(name, field.clone())
+
+
+def ensure_site_fields() -> None:
+    """Ensure the custom ``Site`` fields are installed."""
+
+    _install_fields()
+
+
+@receiver(post_save, sender=Site, dispatch_uid="pages_site_save_update_nginx")
+def _site_saved(sender, **kwargs) -> None:  # pragma: no cover - signal wrapper
+    update_local_nginx_scripts()
+
+
+@receiver(post_delete, sender=Site, dispatch_uid="pages_site_delete_update_nginx")
+def _site_deleted(sender, **kwargs) -> None:  # pragma: no cover - signal wrapper
+    update_local_nginx_scripts()
+
+
+def _run_post_migrate_update(**kwargs) -> None:  # pragma: no cover - signal wrapper
+    update_local_nginx_scripts()
+
+
+def ready() -> None:
+    """Apply customizations and connect signal handlers."""
+
+    ensure_site_fields()
+    post_migrate.connect(
+        _run_post_migrate_update,
+        dispatch_uid="pages_site_post_migrate_update",
+    )

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 reverse
+from django.urls import NoReverseMatch, 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,
@@ -47,6 +48,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 +62,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 +76,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,6 +690,22 @@ 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):
@@ -1156,6 +1177,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()
@@ -2406,6 +2546,27 @@ 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", last_status="Available")
+        Charger.objects.create(
+            charger_id="CP-001", connector_id=1, last_status="Available"
+        )
+        Charger.objects.create(
+            charger_id="CP-002", connector_id=1, last_status="Unavailable"
+        )
+
+        resp = self.client.get(reverse("admin:index"))
+
+        expected = "2 / 1"
+        badge_label = gettext(
+            "%(total)s chargers reporting Available status, including %(with_cp)s with a CP number"
+        ) % {"total": 2, "with_cp": 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_nav_sidebar_hides_dashboard_badges(self):
         InviteLead.objects.create(email="open@example.com")
         RFID.objects.create(rfid="RFID0003", released=True, allowed=True)
@@ -2568,6 +2729,15 @@ class FavoriteTests(TestCase):
             resp, '<div class="todo-details">More info</div>', html=True
         )
 
+    def test_dashboard_hides_completed_todos(self):
+        todo = Todo.objects.create(request="Completed task")
+        Todo.objects.filter(pk=todo.pk).update(done_on=timezone.now())
+
+        resp = self.client.get(reverse("admin:index"))
+
+        self.assertNotContains(resp, todo.request)
+        self.assertNotContains(resp, "Completed")
+
     def test_dashboard_shows_todos_when_node_unknown(self):
         Todo.objects.create(request="Check fallback")
         from nodes.models import Node
@@ -3134,6 +3304,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):