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

pages/context_processors.py

@@ -50,6 +50,13 @@ def nav_links(request):
     valid_modules = []
     datasette_enabled = False
     current_module = None
+    user = getattr(request, "user", None)
+    user_is_authenticated = getattr(user, "is_authenticated", False)
+    user_is_superuser = getattr(user, "is_superuser", False)
+    if user_is_authenticated:
+        user_group_names = set(user.groups.values_list("name", flat=True))
+    else:
+        user_group_names = set()
     for module in modules:
         landings = []
         for landing in module.landings.filter(enabled=True):
@@ -62,7 +69,19 @@ def nav_links(request):
             if not requires_login and hasattr(view_func, "login_url"):
                 requires_login = True
             staff_only = getattr(view_func, "staff_required", False)
-            if requires_login and not request.user.is_authenticated:
+            required_groups = getattr(
+                view_func, "required_security_groups", frozenset()
+            )
+            if required_groups:
+                requires_login = True
+                setattr(landing, "requires_login", True)
+                if not user_is_authenticated:
+                    continue
+                if not user_is_superuser and not (
+                    user_group_names & set(required_groups)
+                ):
+                    continue
+            elif requires_login and not user_is_authenticated:
                 setattr(landing, "requires_login", True)
             if staff_only and not request.user.is_staff:
                 continue

pages/middleware.py

@@ -10,6 +10,7 @@ from django.conf import settings
 from django.urls import Resolver404, resolve
 
 from .models import Landing, LandingLead, ViewHistory
+from .utils import landing_leads_supported
 
 
 logger = logging.getLogger(__name__)
@@ -125,6 +126,9 @@ class ViewHistoryMiddleware:
         if request.method.upper() != "GET":
             return
 
+        if not landing_leads_supported():
+            return
+
         referer = request.META.get("HTTP_REFERER", "") or ""
         user_agent = request.META.get("HTTP_USER_AGENT", "") or ""
         ip_address = self._extract_client_ip(request) or None

pages/models.py

@@ -1,3 +1,6 @@
+import logging
+from pathlib import Path
+
 from django.db import models
 from django.db.models import Q
 from core.entity import Entity
@@ -15,6 +18,10 @@ from django.core.validators import MaxLengthValidator, MaxValueValidator, MinVal
 from django.core.exceptions import ValidationError
 
 from core import github_issues
+from .tasks import create_user_story_github_issue
+
+
+logger = logging.getLogger(__name__)
 
 
 class ApplicationManager(models.Manager):
@@ -463,7 +470,7 @@ class Favorite(Entity):
         unique_together = ("user", "content_type")
 
 
-class UserStory(Entity):
+class UserStory(Lead):
     path = models.CharField(max_length=500)
     name = models.CharField(max_length=40, blank=True)
     rating = models.PositiveSmallIntegerField(
@@ -599,6 +606,37 @@ from django.db.models.signals import post_save
 from django.dispatch import receiver
 
 
+def _celery_lock_path() -> Path:
+    return Path(settings.BASE_DIR) / "locks" / "celery.lck"
+
+
+def _is_celery_enabled() -> bool:
+    return _celery_lock_path().exists()
+
+
+@receiver(post_save, sender=UserStory)
+def _queue_low_rating_user_story_issue(
+    sender, instance: UserStory, created: bool, raw: bool, **kwargs
+) -> None:
+    if raw or not created:
+        return
+    if instance.rating >= 5:
+        return
+    if instance.github_issue_url:
+        return
+    if not instance.user_id:
+        return
+    if not _is_celery_enabled():
+        return
+
+    try:
+        create_user_story_github_issue.delay(instance.pk)
+    except Exception:  # pragma: no cover - logging only
+        logger.exception(
+            "Failed to enqueue GitHub issue creation for user story %s", instance.pk
+        )
+
+
 @receiver(post_save, sender=Module)
 def _create_landings(
     sender, instance, created, raw, **kwargs

pages/module_defaults.py

@@ -0,0 +1,156 @@
+"""Utilities to restore default navigation modules."""
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
+
+
+ModuleDefinition = Mapping[str, object]
+LandingDefinition = tuple[str, str]
+
+
+ROLE_MODULE_DEFAULTS: Mapping[str, tuple[ModuleDefinition, ...]] = {
+    "Constellation": (
+        {
+            "application": "ocpp",
+            "path": "/ocpp/",
+            "menu": "Chargers",
+            "landings": (
+                ("/ocpp/", "CPMS Online Dashboard"),
+                ("/ocpp/simulator/", "Charge Point Simulator"),
+                ("/ocpp/rfid/", "RFID Tag Validator"),
+            ),
+        },
+        {
+            "application": "awg",
+            "path": "/awg/",
+            "menu": "",
+            "landings": (
+                ("/awg/", "AWG Calculator"),
+                ("/awg/energy-tariff/", "Energy Tariff Calculator"),
+            ),
+        },
+    ),
+}
+
+
+@dataclass
+class ReloadSummary:
+    """Report about the changes performed while restoring defaults."""
+
+    roles_processed: int = 0
+    modules_created: int = 0
+    modules_updated: int = 0
+    landings_created: int = 0
+    landings_updated: int = 0
+
+    @property
+    def has_changes(self) -> bool:
+        return any(
+            (
+                self.modules_created,
+                self.modules_updated,
+                self.landings_created,
+                self.landings_updated,
+            )
+        )
+
+
+def _manager(model, name: str):
+    manager = getattr(model, name, None)
+    if manager is not None:
+        return manager
+    return model.objects
+
+
+def reload_default_modules(Application, Module, Landing, NodeRole) -> ReloadSummary:
+    """Ensure default navigation modules exist for the configured roles."""
+
+    summary = ReloadSummary()
+    application_manager = _manager(Application, "all_objects")
+    module_manager = _manager(Module, "all_objects")
+    landing_manager = _manager(Landing, "all_objects")
+    role_manager = _manager(NodeRole, "all_objects")
+
+    for role_name, module_definitions in ROLE_MODULE_DEFAULTS.items():
+        try:
+            role = role_manager.get(name=role_name)
+        except NodeRole.DoesNotExist:
+            continue
+
+        summary.roles_processed += 1
+
+        for definition in module_definitions:
+            app_name: str = definition["application"]  # type: ignore[assignment]
+            try:
+                application = application_manager.get(name=app_name)
+            except Application.DoesNotExist:
+                continue
+
+            module, created = module_manager.get_or_create(
+                node_role=role,
+                path=definition["path"],
+                defaults={
+                    "application": application,
+                    "menu": definition["menu"],
+                    "is_seed_data": True,
+                    "is_deleted": False,
+                },
+            )
+            if created:
+                summary.modules_created += 1
+
+            module_updates: list[str] = []
+            if module.application_id != application.id:
+                module.application = application
+                module_updates.append("application")
+            if module.menu != definition["menu"]:
+                module.menu = definition["menu"]  # type: ignore[index]
+                module_updates.append("menu")
+            if getattr(module, "is_deleted", False):
+                module.is_deleted = False
+                module_updates.append("is_deleted")
+            if not getattr(module, "is_seed_data", False):
+                module.is_seed_data = True
+                module_updates.append("is_seed_data")
+            if module_updates:
+                module.save(update_fields=module_updates)
+                if not created:
+                    summary.modules_updated += 1
+
+            landings: Iterable[tuple[str, str]] = definition["landings"]  # type: ignore[index]
+            for path, label in landings:
+                landing, landing_created = landing_manager.get_or_create(
+                    module=module,
+                    path=path,
+                    defaults={
+                        "label": label,
+                        "description": "",
+                        "enabled": True,
+                    },
+                )
+                if landing_created:
+                    summary.landings_created += 1
+
+                landing_updates: list[str] = []
+                if landing.label != label:
+                    landing.label = label
+                    landing_updates.append("label")
+                if landing.description:
+                    landing.description = ""
+                    landing_updates.append("description")
+                if not landing.enabled:
+                    landing.enabled = True
+                    landing_updates.append("enabled")
+                if getattr(landing, "is_deleted", False):
+                    landing.is_deleted = False
+                    landing_updates.append("is_deleted")
+                if not getattr(landing, "is_seed_data", False):
+                    landing.is_seed_data = True
+                    landing_updates.append("is_seed_data")
+                if landing_updates:
+                    landing.save(update_fields=landing_updates)
+                    if not landing_created:
+                        summary.landings_updated += 1
+
+    return summary

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