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

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, ...]] = {
+    "Watchtower": (
+        {
+            "application": "ocpp",
+            "path": "/ocpp/",
+            "menu": "Chargers",
+            "landings": (
+                ("/ocpp/cpms/dashboard/", "CPMS Online Dashboard"),
+                ("/ocpp/evcs/simulator/", "Charge Point Simulator"),
+                ("/ocpp/rfid/validator/", "RFID Tag Validator"),
+            ),
+        },
+        {
+            "application": "awg",
+            "path": "/awg/",
+            "menu": "",
+            "landings": (
+                ("/awg/", "AWG Cable 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/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/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