arthexis 0.1.14__py3-none-any.whl → 0.1.15__py3-none-any.whl

pages/tasks.py

@@ -0,0 +1,74 @@
+"""Celery tasks for the pages application."""
+
+from __future__ import annotations
+
+import logging
+from datetime import timedelta
+
+from celery import shared_task
+
+from django.utils import timezone
+
+
+logger = logging.getLogger(__name__)
+
+
+@shared_task
+def create_user_story_github_issue(user_story_id: int) -> str | None:
+    """Create a GitHub issue for the provided ``UserStory`` instance."""
+
+    from .models import UserStory
+
+    try:
+        story = UserStory.objects.get(pk=user_story_id)
+    except UserStory.DoesNotExist:  # pragma: no cover - defensive guard
+        logger.warning(
+            "User story %s no longer exists; skipping GitHub issue creation",
+            user_story_id,
+        )
+        return None
+
+    if story.rating >= 5:
+        logger.info(
+            "Skipping GitHub issue creation for user story %s with rating %s",
+            story.pk,
+            story.rating,
+        )
+        return None
+
+    if story.github_issue_url:
+        logger.info(
+            "GitHub issue already recorded for user story %s: %s",
+            story.pk,
+            story.github_issue_url,
+        )
+        return story.github_issue_url
+
+    issue_url = story.create_github_issue()
+
+    if issue_url:
+        logger.info(
+            "Created GitHub issue %s for user story %s", issue_url, story.pk
+        )
+    else:
+        logger.info(
+            "No GitHub issue created for user story %s", story.pk
+        )
+
+    return issue_url
+
+
+@shared_task
+def purge_expired_landing_leads(days: int = 30) -> int:
+    """Remove landing leads older than ``days`` days."""
+
+    from .models import LandingLead
+
+    cutoff = timezone.now() - timedelta(days=days)
+    queryset = LandingLead.objects.filter(created_on__lt=cutoff)
+    deleted, _ = queryset.delete()
+    if deleted:
+        logger.info(
+            "Purged %s landing leads older than %s days", deleted, days
+        )
+    return deleted

pages/tests.py

@@ -7,6 +7,7 @@ import django
 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.templatetags.static import static
 from urllib.parse import quote
@@ -15,7 +16,10 @@ from django.contrib.sites.models import Site
 from django.contrib import admin
 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.models import (
     Application,
     Landing,
@@ -62,7 +66,7 @@ import shutil
 from io import StringIO
 from django.conf import settings
 from pathlib import Path
-from unittest.mock import MagicMock, Mock, patch
+from unittest.mock import MagicMock, Mock, call, patch
 from types import SimpleNamespace
 from django.core.management import call_command
 import re
@@ -706,6 +710,32 @@ class ViewHistoryLoggingTests(TestCase):
     def setUp(self):
         self.client = Client()
         Site.objects.update_or_create(id=1, defaults={"name": "Terminal"})
+        self.addCleanup(self._reset_purge_task)
+
+    def _reset_purge_task(self):
+        from django_celery_beat.models import PeriodicTask
+
+        PeriodicTask.objects.filter(name="pages_purge_landing_leads").delete()
+
+    def _create_local_node(self):
+        node, _ = Node.objects.update_or_create(
+            mac_address=Node.get_current_mac(),
+            defaults={
+                "hostname": socket.gethostname(),
+                "address": "127.0.0.1",
+                "base_path": settings.BASE_DIR,
+                "port": 8000,
+            },
+        )
+        return node
+
+    def _enable_celery_feature(self):
+        node = self._create_local_node()
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="celery-queue", defaults={"display": "Celery Queue"}
+        )
+        NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+        return node
 
     def test_successful_visit_creates_entry(self):
         resp = self.client.get(reverse("pages:index"))
@@ -750,6 +780,8 @@ class ViewHistoryLoggingTests(TestCase):
         self.assertEqual(user.last_visit_ip_address, "203.0.113.5")
 
     def test_landing_visit_records_lead(self):
+        self._enable_celery_feature()
+
         role = NodeRole.objects.create(name="landing-role")
         application = Application.objects.create(
             name="landing-tests-app", description=""
@@ -774,6 +806,26 @@ class ViewHistoryLoggingTests(TestCase):
         self.assertEqual(lead.path, "/")
         self.assertEqual(lead.referer, "https://example.com/ref")
 
+    def test_landing_visit_does_not_record_lead_without_celery(self):
+        role = NodeRole.objects.create(name="no-celery-role")
+        application = Application.objects.create(
+            name="no-celery-app", description=""
+        )
+        module = Module.objects.create(
+            node_role=role,
+            application=application,
+            path="/",
+            menu="Landing",
+        )
+        landing = module.landings.get(path="/")
+        landing.label = "No Celery"
+        landing.save(update_fields=["label"])
+
+        resp = self.client.get(reverse("pages:index"))
+
+        self.assertEqual(resp.status_code, 200)
+        self.assertFalse(LandingLead.objects.exists())
+
     def test_disabled_landing_does_not_record_lead(self):
         role = NodeRole.objects.create(name="landing-role-disabled")
         application = Application.objects.create(
@@ -894,6 +946,93 @@ class ViewHistoryAdminTests(TestCase):
         self.assertContains(resp, static("core/vendor/chart.umd.min.js"))
 
 
+class LandingLeadAdminTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User = get_user_model()
+        self.admin = User.objects.create_superuser(
+            username="lead_admin", password="pwd", email="lead@example.com"
+        )
+        self.client.force_login(self.admin)
+        Site.objects.update_or_create(
+            id=1, defaults={"name": "test", "domain": "testserver"}
+        )
+        self.node, _ = Node.objects.update_or_create(
+            mac_address=Node.get_current_mac(),
+            defaults={
+                "hostname": socket.gethostname(),
+                "address": "127.0.0.1",
+                "base_path": settings.BASE_DIR,
+                "port": 8000,
+            },
+        )
+        self.node.features.clear()
+        self.addCleanup(self._reset_purge_task)
+
+    def _reset_purge_task(self):
+        from django_celery_beat.models import PeriodicTask
+
+        PeriodicTask.objects.filter(name="pages_purge_landing_leads").delete()
+
+    def test_changelist_warns_without_celery(self):
+        url = reverse("admin:pages_landinglead_changelist")
+        response = self.client.get(url)
+        self.assertContains(
+            response,
+            "Landing leads are not being recorded because Celery is not running on this node.",
+        )
+
+    def test_changelist_no_warning_with_celery(self):
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="celery-queue", defaults={"display": "Celery Queue"}
+        )
+        NodeFeatureAssignment.objects.get_or_create(node=self.node, feature=feature)
+        url = reverse("admin:pages_landinglead_changelist")
+        response = self.client.get(url)
+        self.assertNotContains(
+            response,
+            "Landing leads are not being recorded because Celery is not running on this node.",
+        )
+
+
+class LandingLeadTaskTests(TestCase):
+    def setUp(self):
+        self.role = NodeRole.objects.create(name="lead-task-role")
+        self.application = Application.objects.create(
+            name="lead-task-app", description=""
+        )
+        self.module = Module.objects.create(
+            node_role=self.role,
+            application=self.application,
+            path="/tasks",
+            menu="Landing",
+        )
+        self.landing = Landing.objects.create(
+            module=self.module,
+            path="/tasks/",
+            label="Tasks Landing",
+            enabled=True,
+        )
+
+    def test_purge_expired_landing_leads_removes_old_records(self):
+        from pages.tasks import purge_expired_landing_leads
+
+        stale = LandingLead.objects.create(landing=self.landing, path="/tasks/")
+        recent = LandingLead.objects.create(landing=self.landing, path="/tasks/")
+        LandingLead.objects.filter(pk=stale.pk).update(
+            created_on=timezone.now() - timedelta(days=31)
+        )
+        LandingLead.objects.filter(pk=recent.pk).update(
+            created_on=timezone.now() - timedelta(days=5)
+        )
+
+        deleted = purge_expired_landing_leads()
+
+        self.assertEqual(deleted, 1)
+        self.assertFalse(LandingLead.objects.filter(pk=stale.pk).exists())
+        self.assertTrue(LandingLead.objects.filter(pk=recent.pk).exists())
+
+
 class LogViewerAdminTests(SimpleTestCase):
     def setUp(self):
         self.factory = RequestFactory()
@@ -1092,6 +1231,45 @@ class SiteAdminScreenshotTests(TestCase):
         mock_capture.assert_called_once_with("http://testserver/")
 
 
+class SiteAdminReloadFixturesTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User = get_user_model()
+        self.admin = User.objects.create_superuser(
+            username="fixture-admin", password="pwd", email="admin@example.com"
+        )
+        self.client.force_login(self.admin)
+        Site.objects.update_or_create(
+            id=1, defaults={"name": "Terminal", "domain": "testserver"}
+        )
+
+    @patch("pages.admin.call_command")
+    def test_reload_site_fixtures_action(self, mock_call_command):
+        response = self.client.post(
+            reverse("admin:pages_siteproxy_changelist"),
+            {"action": "reload_site_fixtures", "_selected_action": [1]},
+            follow=True,
+        )
+        self.assertEqual(response.status_code, 200)
+
+        fixtures_dir = Path(settings.BASE_DIR) / "core" / "fixtures"
+        expected = sorted(fixtures_dir.glob("references__00_site_*.json"))
+        sigil_fixture = fixtures_dir / "sigil_roots__site.json"
+        if sigil_fixture.exists():
+            expected.append(sigil_fixture)
+
+        expected_calls = [
+            call("loaddata", str(path), verbosity=0) for path in expected
+        ]
+        self.assertEqual(mock_call_command.call_args_list, expected_calls)
+
+        if expected_calls:
+            self.assertContains(
+                response,
+                f"Reloaded {len(expected_calls)} site fixtures.",
+            )
+
+
 class AdminBadgesWebsiteTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -1358,6 +1536,12 @@ class ControlNavTests(TestCase):
             id=1, defaults={"domain": "testserver", "name": ""}
         )
         fixtures = [
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "default__application_pages.json",
+            ),
             Path(
                 settings.BASE_DIR,
                 "pages",
@@ -1388,6 +1572,18 @@ class ControlNavTests(TestCase):
                 "fixtures",
                 "control__landing_ocpp_rfid.json",
             ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "control__module_readme.json",
+            ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "control__landing_readme.json",
+            ),
         ]
         call_command("loaddata", *map(str, fixtures))
 
@@ -1428,6 +1624,84 @@ class ControlNavTests(TestCase):
         self.assertFalse(resp.context["header_references"])
         self.assertNotContains(resp, "https://example.com/hidden")
 
+    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')
+
+
+class SatelliteNavTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        role, _ = NodeRole.objects.get_or_create(name="Satellite")
+        Node.objects.update_or_create(
+            mac_address=Node.get_current_mac(),
+            defaults={
+                "hostname": "localhost",
+                "address": "127.0.0.1",
+                "role": role,
+            },
+        )
+        Site.objects.update_or_create(
+            id=1, defaults={"domain": "testserver", "name": ""}
+        )
+        fixtures = [
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "default__application_pages.json",
+            ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "satellite_box__application_ocpp.json",
+            ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "satellite_box__module_ocpp.json",
+            ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "satellite_box__landing_ocpp_dashboard.json",
+            ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "satellite_box__landing_ocpp_cp_simulator.json",
+            ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "satellite_box__landing_ocpp_rfid.json",
+            ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "satellite_box__module_readme.json",
+            ),
+            Path(
+                settings.BASE_DIR,
+                "pages",
+                "fixtures",
+                "satellite_box__landing_readme.json",
+            ),
+        ]
+        call_command("loaddata", *map(str, fixtures))
+
+    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')
+
 
 class PowerNavTests(TestCase):
     def setUp(self):
@@ -2069,6 +2343,40 @@ class FavoriteTests(TestCase):
         self.assertNotIn("Packages", labels)
         ContentType.objects.clear_cache()
 
+    def test_future_action_items_limits_user_data_queries(self):
+        from pages.templatetags import admin_extras
+
+        cache.delete(admin_extras.USER_DATA_MODELS_CACHE_KEY)
+        self.addCleanup(cache.delete, admin_extras.USER_DATA_MODELS_CACHE_KEY)
+
+        for index in range(3):
+            NodeRole.objects.create(name=f"CachedRole{index}", is_user_data=True)
+        for index in range(2):
+            NodeFeature.objects.create(
+                slug=f"cached-feature-{index}",
+                display=f"Feature {index}",
+                is_user_data=True,
+            )
+
+        Node.objects.create(
+            hostname="cached-node",
+            address="127.0.0.1",
+            mac_address="AA:BB:CC:DD:EE:FF",
+            port=8000,
+            is_user_data=True,
+        )
+
+        response = self.client.get(reverse("admin:index"))
+        request = response.wsgi_request
+
+        admin_extras.future_action_items({"request": request})
+        with CaptureQueriesContext(connection) as ctx:
+            admin_extras.future_action_items({"request": request})
+
+        # History and favorites queries should remain bounded regardless of the
+        # number of Entity subclasses with user data.
+        self.assertLessEqual(len(ctx.captured_queries), 4)
+
     def test_favorite_ct_id_recreates_missing_content_type(self):
         ct = ContentType.objects.get_by_natural_key("pages", "application")
         ct.delete()
@@ -2172,6 +2480,62 @@ class FavoriteTests(TestCase):
         self.assertContains(resp, todo.request)
 
 
+class AdminIndexQueryRegressionTests(TestCase):
+    def setUp(self):
+        User = get_user_model()
+        self.client = Client()
+        self.user = User.objects.create_superuser(
+            username="queryadmin", password="pwd", email="query@example.com"
+        )
+        self.client.force_login(self.user)
+        Site.objects.update_or_create(
+            id=1, defaults={"name": "test", "domain": "testserver"}
+        )
+        favorite_cts = [
+            ContentType.objects.get_for_model(Application),
+            ContentType.objects.get_for_model(Landing),
+        ]
+        for ct in favorite_cts:
+            Favorite.objects.create(user=self.user, content_type=ct)
+
+    def _render_admin_and_count_queries(self):
+        url = reverse("admin:index")
+        with CaptureQueriesContext(connection) as ctx:
+            response = self.client.get(url)
+        self.assertEqual(response.status_code, 200)
+        sql_statements = [query["sql"].lower() for query in ctx.captured_queries]
+        ct_queries = [sql for sql in sql_statements if '"django_content_type"' in sql]
+        favorite_queries = [sql for sql in sql_statements if '"pages_favorite"' in sql]
+        return len(ct_queries), len(favorite_queries)
+
+    def test_admin_index_queries_constant_with_more_models(self):
+        site = admin.site
+        original_registry = site._registry.copy()
+        registry_items = list(original_registry.items())
+        if len(registry_items) < 2:
+            self.skipTest("Not enough registered admin models for regression test")
+
+        for model in original_registry.keys():
+            ContentType.objects.get_for_model(model)
+
+        try:
+            site._registry = dict(registry_items[:1])
+            baseline_ct_queries, baseline_favorite_queries = (
+                self._render_admin_and_count_queries()
+            )
+
+            expanded_limit = min(len(registry_items), 5)
+            site._registry = dict(registry_items[:expanded_limit])
+            expanded_ct_queries, expanded_favorite_queries = (
+                self._render_admin_and_count_queries()
+            )
+        finally:
+            site._registry = original_registry
+
+        self.assertEqual(expanded_ct_queries, baseline_ct_queries)
+        self.assertEqual(expanded_favorite_queries, baseline_favorite_queries)
+
+
 class AdminActionListTests(TestCase):
     def setUp(self):
         User = get_user_model()
@@ -2446,6 +2810,55 @@ class UserStorySubmissionTests(TestCase):
         self.assertIsNone(story.owner)
 
 
+class UserStoryIssueAutomationTests(TestCase):
+    def setUp(self):
+        self.lock_dir = Path(settings.BASE_DIR) / "locks"
+        self.lock_dir.mkdir(parents=True, exist_ok=True)
+        self.lock_file = self.lock_dir / "celery.lck"
+
+    def tearDown(self):
+        self.lock_file.unlink(missing_ok=True)
+
+    def test_low_rating_story_enqueues_issue_creation_when_celery_enabled(self):
+        self.lock_file.write_text("")
+
+        with patch("pages.models.create_user_story_github_issue.delay") as mock_delay:
+            story = UserStory.objects.create(
+                path="/feedback/",
+                rating=2,
+                comments="Needs work",
+                take_screenshot=False,
+            )
+
+        mock_delay.assert_called_once_with(story.pk)
+
+    def test_five_star_story_does_not_enqueue_issue(self):
+        self.lock_file.write_text("")
+
+        with patch("pages.models.create_user_story_github_issue.delay") as mock_delay:
+            UserStory.objects.create(
+                path="/feedback/",
+                rating=5,
+                comments="Great!",
+                take_screenshot=True,
+            )
+
+        mock_delay.assert_not_called()
+
+    def test_low_rating_story_skips_when_celery_disabled(self):
+        self.lock_file.unlink(missing_ok=True)
+
+        with patch("pages.models.create_user_story_github_issue.delay") as mock_delay:
+            UserStory.objects.create(
+                path="/feedback/",
+                rating=1,
+                comments="Not good",
+                take_screenshot=False,
+            )
+
+        mock_delay.assert_not_called()
+
+
 class UserStoryAdminActionTests(TestCase):
     def setUp(self):
         self.client = Client()

pages/urls.py

@@ -6,6 +6,7 @@ app_name = "pages"
 
 urlpatterns = [
     path("", views.index, name="index"),
+    path("readme/", views.readme, name="readme"),
     path("sitemap.xml", views.sitemap, name="pages-sitemap"),
     path("client-report/", views.client_report, name="client-report"),
     path("release-checklist", views.release_checklist, name="release-checklist"),

pages/utils.py

@@ -10,3 +10,14 @@ def landing(label=None):
         return view
 
     return decorator
+
+
+def landing_leads_supported() -> bool:
+    """Return ``True`` when the local node supports landing lead tracking."""
+
+    from nodes.models import Node
+
+    node = Node.get_local()
+    if not node:
+        return False
+    return node.has_feature("celery-queue")

pages/views.py

@@ -411,6 +411,43 @@ def admin_model_graph(request, app_label: str):
     return TemplateResponse(request, "admin/model_graph.html", context)
 
 
+def _render_readme(request, role):
+    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)
+    )
+    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 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()), root_base / "README.md")
+    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}
+    response = render(request, "pages/readme.html", context)
+    patch_vary_headers(response, ["Accept-Language", "Cookie"])
+    return response
+
+
 @landing("Home")
 @never_cache
 def index(request):
@@ -456,40 +493,14 @@ def index(request):
             target_path = landing_obj.path
             if target_path and target_path != request.path:
                 return redirect(target_path)
-    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)
-    )
-    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 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()), root_base / "README.md")
-    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}
-    response = render(request, "pages/readme.html", context)
-    patch_vary_headers(response, ["Accept-Language", "Cookie"])
-    return response
+    return _render_readme(request, role)
+
+
+@never_cache
+def readme(request):
+    node = Node.get_local()
+    role = node.role if node else None
+    return _render_readme(request, role)
 
 
 def sitemap(request):