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

pages/admin.py

@@ -1,4 +1,5 @@
 import logging
+from collections import deque
 from pathlib import Path
 
 from django.contrib import admin, messages
@@ -6,12 +7,14 @@ 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.http import FileResponse, 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 +28,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 +45,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 +78,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 +150,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"))
@@ -230,14 +291,19 @@ class ApplicationAdmin(EntityModelAdmin):
 class LandingInline(admin.TabularInline):
     model = Landing
     extra = 0
-    fields = ("path", "label", "enabled")
+    fields = ("path", "label", "enabled", "track_leads")
     show_change_link = True
 
 
 @admin.register(Landing)
 class LandingAdmin(EntityModelAdmin):
-    list_display = ("label", "path", "module", "enabled")
-    list_filter = ("enabled", "module__node_role", "module__application")
+    list_display = ("label", "path", "module", "enabled", "track_leads")
+    list_filter = (
+        "enabled",
+        "track_leads",
+        "module__node_role",
+        "module__application",
+    )
     search_fields = (
         "label",
         "path",
@@ -246,7 +312,7 @@ class LandingAdmin(EntityModelAdmin):
         "module__application__name",
         "module__node_role__name",
     )
-    fields = ("module", "path", "label", "enabled", "description")
+    fields = ("module", "path", "label", "enabled", "track_leads", "description")
     list_select_related = ("module", "module__application", "module__node_role")
 
 
@@ -529,7 +595,23 @@ class ViewHistoryAdmin(EntityModelAdmin):
         )
 
     def traffic_data_view(self, request):
-        return JsonResponse(self._build_chart_data())
+        return JsonResponse(
+            self._build_chart_data(days=self._resolve_requested_days(request))
+        )
+
+    def _resolve_requested_days(self, request, default: int = 30) -> int:
+        raw_value = request.GET.get("days")
+        if raw_value in (None, ""):
+            return default
+
+        try:
+            days = int(raw_value)
+        except (TypeError, ValueError):
+            return default
+
+        minimum = 1
+        maximum = 90
+        return max(minimum, min(days, maximum))
 
     def _build_chart_data(self, days: int = 30, max_pages: int = 8) -> dict:
         end_date = timezone.localdate()
@@ -623,11 +705,13 @@ class UserStoryAdmin(EntityModelAdmin):
     actions = ["create_github_issues"]
     list_display = (
         "name",
+        "language_code",
         "rating",
         "path",
         "status",
         "submitted_at",
         "github_issue_display",
+        "screenshot_display",
         "take_screenshot",
         "owner",
         "assign_to",
@@ -637,6 +721,7 @@ class UserStoryAdmin(EntityModelAdmin):
         "name",
         "comments",
         "path",
+        "language_code",
         "referer",
         "github_issue_url",
         "ip_address",
@@ -649,6 +734,7 @@ class UserStoryAdmin(EntityModelAdmin):
         "path",
         "user",
         "owner",
+        "language_code",
         "referer",
         "user_agent",
         "ip_address",
@@ -656,6 +742,7 @@ class UserStoryAdmin(EntityModelAdmin):
         "submitted_at",
         "github_issue_number",
         "github_issue_url",
+        "screenshot_display",
     )
     ordering = ("-submitted_at",)
     fields = (
@@ -663,7 +750,9 @@ class UserStoryAdmin(EntityModelAdmin):
         "rating",
         "comments",
         "take_screenshot",
+        "screenshot_display",
         "path",
+        "language_code",
         "user",
         "owner",
         "status",
@@ -692,6 +781,21 @@ class UserStoryAdmin(EntityModelAdmin):
             )
         if obj.github_issue_number is not None:
             return f"#{obj.github_issue_number}"
+        return ""
+
+    @admin.display(description=_("Screenshot"), ordering="screenshot")
+    def screenshot_display(self, obj):
+        if not obj.screenshot_id:
+            return ""
+        try:
+            url = reverse("admin:nodes_contentsample_change", args=[obj.screenshot_id])
+        except NoReverseMatch:
+            return obj.screenshot.path
+        return format_html(
+            '<a href="{}" target="_blank" rel="noopener noreferrer">{}</a>',
+            url,
+            _("View screenshot"),
+        )
         return _("Not created")
 
     @admin.action(description=_("Create GitHub issues"))
@@ -708,10 +812,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
@@ -753,34 +880,93 @@ def favorite_toggle(request, ct_id):
     ct = get_object_or_404(ContentType, pk=ct_id)
     fav = Favorite.objects.filter(user=request.user, content_type=ct).first()
     next_url = request.GET.get("next")
-    if fav:
-        return redirect(next_url or "admin:favorite_list")
     if request.method == "POST":
+        if fav and request.POST.get("remove"):
+            fav.delete()
+            return redirect(next_url or "admin:index")
         label = request.POST.get("custom_label", "").strip()
         user_data = request.POST.get("user_data") == "on"
-        Favorite.objects.create(
-            user=request.user,
-            content_type=ct,
-            custom_label=label,
-            user_data=user_data,
-        )
+        priority_raw = request.POST.get("priority", "").strip()
+        if fav:
+            default_priority = fav.priority
+        else:
+            default_priority = 0
+        if priority_raw:
+            try:
+                priority = int(priority_raw)
+            except (TypeError, ValueError):
+                priority = default_priority
+        else:
+            priority = default_priority
+
+        if fav:
+            update_fields = []
+            if fav.custom_label != label:
+                fav.custom_label = label
+                update_fields.append("custom_label")
+            if fav.user_data != user_data:
+                fav.user_data = user_data
+                update_fields.append("user_data")
+            if fav.priority != priority:
+                fav.priority = priority
+                update_fields.append("priority")
+            if update_fields:
+                fav.save(update_fields=update_fields)
+        else:
+            Favorite.objects.create(
+                user=request.user,
+                content_type=ct,
+                custom_label=label,
+                user_data=user_data,
+                priority=priority,
+            )
         return redirect(next_url or "admin:index")
     return render(
         request,
         "admin/favorite_confirm.html",
-        {"content_type": ct, "next": next_url},
+        {
+            "content_type": ct,
+            "favorite": fav,
+            "next": next_url,
+            "initial_label": fav.custom_label if fav else "",
+            "initial_priority": fav.priority if fav else 0,
+            "is_checked": fav.user_data if fav else True,
+        },
     )
 
 
 def favorite_list(request):
-    favorites = Favorite.objects.filter(user=request.user).select_related(
-        "content_type"
+    favorites = (
+        Favorite.objects.filter(user=request.user)
+        .select_related("content_type")
+        .order_by("priority", "pk")
     )
     if request.method == "POST":
-        selected = request.POST.getlist("user_data")
+        selected = set(request.POST.getlist("user_data"))
         for fav in favorites:
-            fav.user_data = str(fav.pk) in selected
-            fav.save(update_fields=["user_data"])
+            update_fields = []
+            user_selected = str(fav.pk) in selected
+            if fav.user_data != user_selected:
+                fav.user_data = user_selected
+                update_fields.append("user_data")
+
+            priority_raw = request.POST.get(f"priority_{fav.pk}", "").strip()
+            if priority_raw:
+                try:
+                    priority = int(priority_raw)
+                except (TypeError, ValueError):
+                    priority = fav.priority
+                else:
+                    if fav.priority != priority:
+                        fav.priority = priority
+                        update_fields.append("priority")
+            else:
+                if fav.priority != 0:
+                    fav.priority = 0
+                    update_fields.append("priority")
+
+            if update_fields:
+                fav.save(update_fields=update_fields)
         return redirect("admin:favorite_list")
     return render(request, "admin/favorite_list.html", {"favorites": favorites})
 
@@ -796,6 +982,13 @@ def favorite_clear(request):
     return redirect("admin:favorite_list")
 
 
+def _read_log_tail(path: Path, limit: int) -> str:
+    """Return the last ``limit`` lines from ``path`` preserving newlines."""
+
+    with path.open("r", encoding="utf-8") as handle:
+        return "".join(deque(handle, maxlen=limit))
+
+
 def log_viewer(request):
     logs_dir = Path(settings.BASE_DIR) / "logs"
     logs_exist = logs_dir.exists() and logs_dir.is_dir()
@@ -813,16 +1006,50 @@ def log_viewer(request):
     selected_log = request.GET.get("log", "")
     log_content = ""
     log_error = ""
+    limit_options = [
+        {"value": "20", "label": "20"},
+        {"value": "40", "label": "40"},
+        {"value": "100", "label": "100"},
+        {"value": "all", "label": _("All")},
+    ]
+    allowed_limits = [item["value"] for item in limit_options]
+    limit_choice = request.GET.get("limit", "20")
+    if limit_choice not in allowed_limits:
+        limit_choice = "20"
+    limit_index = allowed_limits.index(limit_choice)
+    download_requested = request.GET.get("download") == "1"
 
     if selected_log:
         if selected_log in available_logs:
             selected_path = logs_dir / selected_log
             try:
-                log_content = selected_path.read_text(encoding="utf-8")
-            except UnicodeDecodeError:
-                log_content = selected_path.read_text(
-                    encoding="utf-8", errors="replace"
-                )
+                if download_requested:
+                    return FileResponse(
+                        selected_path.open("rb"),
+                        as_attachment=True,
+                        filename=selected_log,
+                    )
+                if limit_choice == "all":
+                    try:
+                        log_content = selected_path.read_text(encoding="utf-8")
+                    except UnicodeDecodeError:
+                        log_content = selected_path.read_text(
+                            encoding="utf-8", errors="replace"
+                        )
+                else:
+                    try:
+                        limit_value = int(limit_choice)
+                    except (TypeError, ValueError):
+                        limit_value = 20
+                        limit_choice = "20"
+                        limit_index = allowed_limits.index(limit_choice)
+                    try:
+                        log_content = _read_log_tail(selected_path, limit_value)
+                    except UnicodeDecodeError:
+                        with selected_path.open(
+                            "r", encoding="utf-8", errors="replace"
+                        ) as handle:
+                            log_content = "".join(deque(handle, maxlen=limit_value))
             except OSError as exc:  # pragma: no cover - filesystem edge cases
                 logger.warning("Unable to read log file %s", selected_path, exc_info=exc)
                 log_error = _(
@@ -840,6 +1067,7 @@ def log_viewer(request):
     else:
         log_notice = ""
 
+    limit_label = limit_options[limit_index]["label"]
     context = {**admin.site.each_context(request)}
     context.update(
         {
@@ -850,6 +1078,10 @@ def log_viewer(request):
             "log_error": log_error,
             "log_notice": log_notice,
             "logs_directory": logs_dir,
+            "log_limit_options": limit_options,
+            "log_limit_index": limit_index,
+            "log_limit_choice": limit_choice,
+            "log_limit_label": limit_label,
         }
     )
     return TemplateResponse(request, "admin/log_viewer.html", context)

pages/apps.py

@@ -1,10 +1,45 @@
+import logging
+
 from django.apps import AppConfig
+from django.db import DatabaseError
+from django.db.backends.signals import connection_created
+
+
+logger = logging.getLogger(__name__)
 
 
 class PagesConfig(AppConfig):
     default_auto_field = "django.db.models.BigAutoField"
     name = "pages"
     verbose_name = "7. Experience"
+    _view_history_purged = False
 
     def ready(self):  # pragma: no cover - import for side effects
         from . import checks  # noqa: F401
+        from . import site_config
+
+        site_config.ready()
+        connection_created.connect(
+            self._handle_connection_created,
+            dispatch_uid="pages_view_history_connection_created",
+            weak=False,
+        )
+
+    def _handle_connection_created(self, sender, connection, **kwargs):
+        if self._view_history_purged:
+            return
+        self._view_history_purged = True
+        self._purge_view_history()
+
+    def _purge_view_history(self, days: int = 15) -> None:
+        """Remove stale :class:`pages.models.ViewHistory` entries."""
+
+        from .models import ViewHistory
+
+        try:
+            deleted = ViewHistory.purge_older_than(days=days)
+        except DatabaseError:
+            logger.debug("Skipping view history purge; database unavailable", exc_info=True)
+        else:
+            if deleted:
+                logger.info("Purged %s view history entries older than %s days", deleted, days)

pages/context_processors.py

@@ -1,8 +1,8 @@
 from utils.sites import get_site
 from django.urls import Resolver404, resolve
+from django.shortcuts import resolve_url
 from django.conf import settings
 from pathlib import Path
-from types import SimpleNamespace
 from nodes.models import Node
 from core.models import Reference
 from core.reference_utils import filter_visible_references
@@ -11,7 +11,8 @@ from .models import Module
 _FAVICON_DIR = Path(settings.BASE_DIR) / "pages" / "fixtures" / "data"
 _FAVICON_FILENAMES = {
     "default": "favicon.txt",
-    "Constellation": "favicon_constellation.txt",
+    "Watchtower": "favicon_watchtower.txt",
+    "Constellation": "favicon_watchtower.txt",
     "Control": "favicon_control.txt",
     "Satellite": "favicon_satellite.txt",
 }
@@ -48,7 +49,6 @@ def nav_links(request):
         modules = []
 
     valid_modules = []
-    datasette_enabled = False
     current_module = None
     user = getattr(request, "user", None)
     user_is_authenticated = getattr(user, "is_authenticated", False)
@@ -72,24 +72,40 @@ def nav_links(request):
             required_groups = getattr(
                 view_func, "required_security_groups", frozenset()
             )
+            blocked_reason = None
             if required_groups:
                 requires_login = True
-                setattr(landing, "requires_login", True)
                 if not user_is_authenticated:
-                    continue
-                if not user_is_superuser and not (
+                    blocked_reason = "login"
+                elif not user_is_superuser and not (
                     user_group_names & set(required_groups)
                 ):
-                    continue
+                    blocked_reason = "permission"
             elif requires_login and not user_is_authenticated:
-                setattr(landing, "requires_login", True)
-            if staff_only and not request.user.is_staff:
-                continue
+                blocked_reason = "login"
+
+            if staff_only and not getattr(request.user, "is_staff", False):
+                if blocked_reason != "login":
+                    blocked_reason = "permission"
+
+            landing.nav_is_locked = bool(blocked_reason)
+            landing.nav_lock_reason = blocked_reason
             landings.append(landing)
         if landings:
+            normalized_module_path = module.path.rstrip("/") or "/"
+            if normalized_module_path == "/read":
+                primary_landings = [
+                    landing
+                    for landing in landings
+                    if landing.path.rstrip("/") == normalized_module_path
+                ]
+                if primary_landings:
+                    landings = primary_landings
+                else:
+                    landings = [landings[0]]
             app_name = getattr(module.application, "name", "").lower()
             if app_name == "awg":
-                module.menu = "Calculate"
+                module.menu = "Calculators"
             elif module.path.rstrip("/").lower() == "/man":
                 module.menu = "Manual"
             module.enabled_landings = landings
@@ -100,15 +116,6 @@ def nav_links(request):
                 ):
                     current_module = module
 
-    datasette_lock = Path(settings.BASE_DIR) / "locks" / "datasette.lck"
-    if datasette_lock.exists():
-        datasette_enabled = True
-        datasette_module = SimpleNamespace(
-            menu_label="Data",
-            path="/data/",
-            enabled_landings=[SimpleNamespace(path="/data/", label="Datasette")],
-        )
-        valid_modules.append(datasette_module)
 
     valid_modules.sort(key=lambda m: m.menu_label.lower())
 
@@ -142,5 +149,5 @@ def nav_links(request):
         "nav_modules": valid_modules,
         "favicon_url": favicon_url,
         "header_references": header_references,
-        "datasette_enabled": datasette_enabled,
+        "login_url": resolve_url(settings.LOGIN_URL),
     }

pages/defaults.py

@@ -7,7 +7,7 @@ DEFAULT_APPLICATION_DESCRIPTIONS: Dict[str, str] = {
     "awg": "Power, Energy and Cost calculations.",
     "core": "Support for Business Processes and monetization.",
     "ocpp": "Compatibility with Standards and Good Practices.",
-    "nodes": "System and Node-level operations,",
+    "nodes": "System and Node-level operations.",
     "pages": "User QA, Continuity Design and Chaos Testing.",
     "teams": "Identity, Entitlements and Access Controls.",
 }

pages/forms.py

@@ -171,15 +171,35 @@ class UserStoryForm(forms.ModelForm):
             "comments": forms.Textarea(attrs={"rows": 4, "maxlength": 400}),
         }
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, user=None, **kwargs):
+        self.user = user
         super().__init__(*args, **kwargs)
-        self.fields["name"].required = False
-        self.fields["name"].widget.attrs.update(
-            {
-                "maxlength": 40,
-                "placeholder": _("Name, email or pseudonym"),
-            }
-        )
+
+        if user is not None and user.is_authenticated:
+            name_field = self.fields["name"]
+            name_field.required = False
+            name_field.label = _("Username")
+            name_field.initial = (user.get_username() or "")[:40]
+            name_field.widget.attrs.update(
+                {
+                    "maxlength": 40,
+                    "readonly": "readonly",
+                }
+            )
+        else:
+            self.fields["name"] = forms.EmailField(
+                label=_("Email address"),
+                max_length=40,
+                required=True,
+                widget=forms.EmailInput(
+                    attrs={
+                        "maxlength": 40,
+                        "placeholder": _("name@example.com"),
+                        "autocomplete": "email",
+                        "inputmode": "email",
+                    }
+                ),
+            )
         self.fields["take_screenshot"].initial = True
         self.fields["rating"].widget = forms.RadioSelect(
             choices=[(i, str(i)) for i in range(1, 6)]
@@ -194,5 +214,8 @@ class UserStoryForm(forms.ModelForm):
         return comments
 
     def clean_name(self):
+        if self.user is not None and self.user.is_authenticated:
+            return (self.user.get_username() or "")[:40]
+
         name = (self.cleaned_data.get("name") or "").strip()
         return name[:40]