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

pages/middleware.py

@@ -10,7 +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
+from .utils import cache_original_referer, get_original_referer, landing_leads_supported
 
 
 logger = logging.getLogger(__name__)
@@ -30,6 +30,7 @@ class ViewHistoryMiddleware:
         )
 
     def __call__(self, request):
+        cache_original_referer(request)
         should_track = self._should_track(request)
         if not should_track:
             return self.get_response(request)
@@ -126,10 +127,13 @@ class ViewHistoryMiddleware:
         if request.method.upper() != "GET":
             return
 
+        if not getattr(landing, "track_leads", False):
+            return
+
         if not landing_leads_supported():
             return
 
-        referer = request.META.get("HTTP_REFERER", "") or ""
+        referer = get_original_referer(request)
         user_agent = request.META.get("HTTP_USER_AGENT", "") or ""
         ip_address = self._extract_client_ip(request) or None
         user = getattr(request, "user", None)

pages/models.py

@@ -1,4 +1,6 @@
+import base64
 import logging
+from datetime import timedelta
 from pathlib import Path
 
 from django.db import models
@@ -6,10 +8,11 @@ from django.db.models import Q
 from core.entity import Entity
 from core.models import Lead, SecurityGroup
 from django.contrib.sites.models import Site
-from nodes.models import NodeRole
+from nodes.models import ContentSample, NodeRole
 from django.apps import apps as django_apps
+from django.utils import timezone
 from django.utils.text import slugify
-from django.utils.translation import gettext, gettext_lazy as _
+from django.utils.translation import gettext, gettext_lazy as _, get_language_info
 from importlib import import_module
 from django.urls import URLPattern
 from django.conf import settings
@@ -53,6 +56,11 @@ class Application(Entity):
             return self.name
 
 
+    class Meta:
+        verbose_name = _("Application")
+        verbose_name_plural = _("Applications")
+
+
 class ModuleManager(models.Manager):
     def get_by_natural_key(self, role: str, path: str):
         return self.get(node_role__name=role, path=path)
@@ -212,12 +220,15 @@ class Landing(Entity):
     path = models.CharField(max_length=200)
     label = models.CharField(max_length=100)
     enabled = models.BooleanField(default=True)
+    track_leads = models.BooleanField(default=False)
     description = models.TextField(blank=True)
 
     objects = LandingManager()
 
     class Meta:
         unique_together = ("module", "path")
+        verbose_name = _("Landing")
+        verbose_name_plural = _("Landings")
 
     def __str__(self) -> str:  # pragma: no cover - simple representation
         return f"{self.label} ({self.path})"
@@ -435,6 +446,39 @@ class UserManual(Entity):
     def natural_key(self):  # pragma: no cover - simple representation
         return (self.slug,)
 
+    def _ensure_pdf_is_base64(self) -> None:
+        """Normalize ``content_pdf`` so stored values are base64 strings."""
+
+        value = self.content_pdf
+        if value in {None, ""}:
+            self.content_pdf = "" if value is None else value
+            return
+
+        if isinstance(value, (bytes, bytearray, memoryview)):
+            self.content_pdf = base64.b64encode(bytes(value)).decode("ascii")
+            return
+
+        reader = getattr(value, "read", None)
+        if callable(reader):
+            data = reader()
+            if hasattr(value, "seek"):
+                try:
+                    value.seek(0)
+                except Exception:  # pragma: no cover - best effort reset
+                    pass
+            self.content_pdf = base64.b64encode(data).decode("ascii")
+            return
+
+        if isinstance(value, str):
+            stripped = value.strip()
+            if stripped.startswith("data:"):
+                _, _, encoded = stripped.partition(",")
+                self.content_pdf = encoded.strip()
+
+    def save(self, *args, **kwargs):
+        self._ensure_pdf_is_base64()
+        super().save(*args, **kwargs)
+
 
 class ViewHistory(Entity):
     """Record of public site visits."""
@@ -455,6 +499,14 @@ class ViewHistory(Entity):
     def __str__(self) -> str:  # pragma: no cover - simple representation
         return f"{self.method} {self.path} ({self.status_code})"
 
+    @classmethod
+    def purge_older_than(cls, *, days: int) -> int:
+        """Delete history entries recorded more than ``days`` days ago."""
+
+        cutoff = timezone.now() - timedelta(days=days)
+        deleted, _ = cls.objects.filter(visited_at__lt=cutoff).delete()
+        return deleted
+
 
 class Favorite(Entity):
     user = models.ForeignKey(
@@ -465,9 +517,13 @@ class Favorite(Entity):
     content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
     custom_label = models.CharField(max_length=100, blank=True)
     user_data = models.BooleanField(default=False)
+    priority = models.IntegerField(default=0)
 
     class Meta:
         unique_together = ("user", "content_type")
+        ordering = ["priority", "pk"]
+        verbose_name = _("Favorite")
+        verbose_name_plural = _("Favorites")
 
 
 class UserStory(Lead):
@@ -510,6 +566,19 @@ class UserStory(Lead):
         blank=True,
         help_text=_("Link to the GitHub issue created for this feedback."),
     )
+    screenshot = models.ForeignKey(
+        ContentSample,
+        on_delete=models.SET_NULL,
+        blank=True,
+        null=True,
+        related_name="user_stories",
+        help_text=_("Screenshot captured for this feedback."),
+    )
+    language_code = models.CharField(
+        max_length=15,
+        blank=True,
+        help_text=_("Language selected when the feedback was submitted."),
+    )
 
     class Meta:
         ordering = ["-submitted_at"]
@@ -555,6 +624,21 @@ class UserStory(Lead):
             f"**Screenshot requested:** {screenshot_requested}",
         ]
 
+        language_code = (self.language_code or "").strip()
+        if language_code:
+            normalized = language_code.replace("_", "-").lower()
+            try:
+                info = get_language_info(normalized)
+            except KeyError:
+                language_display = ""
+            else:
+                language_display = info.get("name_local") or info.get("name") or ""
+
+            if language_display:
+                lines.append(f"**Language:** {language_display} ({normalized})")
+            else:
+                lines.append(f"**Language:** {normalized}")
+
         if self.submitted_at:
             lines.append(f"**Submitted at:** {self.submitted_at.isoformat()}")
 

pages/module_defaults.py

@@ -10,15 +10,15 @@ LandingDefinition = tuple[str, str]
 
 
 ROLE_MODULE_DEFAULTS: Mapping[str, tuple[ModuleDefinition, ...]] = {
-    "Constellation": (
+    "Watchtower": (
         {
             "application": "ocpp",
             "path": "/ocpp/",
             "menu": "Chargers",
             "landings": (
-                ("/ocpp/", "CPMS Online Dashboard"),
-                ("/ocpp/simulator/", "Charge Point Simulator"),
-                ("/ocpp/rfid/", "RFID Tag Validator"),
+                ("/ocpp/cpms/dashboard/", "CPMS Online Dashboard"),
+                ("/ocpp/evcs/simulator/", "Charge Point Simulator"),
+                ("/ocpp/rfid/validator/", "RFID Tag Validator"),
             ),
         },
         {
@@ -26,7 +26,7 @@ ROLE_MODULE_DEFAULTS: Mapping[str, tuple[ModuleDefinition, ...]] = {
             "path": "/awg/",
             "menu": "",
             "landings": (
-                ("/awg/", "AWG Calculator"),
+                ("/awg/", "AWG Cable Calculator"),
                 ("/awg/energy-tariff/", "Energy Tariff Calculator"),
             ),
         },

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",
+    )