arthexis 0.1.11__py3-none-any.whl → 0.1.12__py3-none-any.whl

nodes/admin.py

@@ -1,6 +1,7 @@
 from django.contrib import admin, messages
-from django.urls import path, reverse
+from django.urls import NoReverseMatch, path, reverse
 from django.shortcuts import redirect, render
+from django.template.response import TemplateResponse
 from django.utils.html import format_html
 from django import forms
 from django.contrib.admin.widgets import FilteredSelectMultiple
@@ -9,15 +10,23 @@ from django.db.models import Count
 from django.conf import settings
 from pathlib import Path
 from django.http import HttpResponse
+from django.utils import timezone
 from django.utils.translation import gettext_lazy as _
 import base64
 import pyperclip
 from pyperclip import PyperclipException
 import uuid
 import subprocess
-from .utils import capture_screenshot, save_screenshot
+from .utils import capture_rpi_snapshot, capture_screenshot, save_screenshot
 from .actions import NodeAction
+from .reports import (
+    collect_celery_log_entries,
+    collect_scheduled_tasks,
+    iter_report_periods,
+    resolve_period,
+)
 
+from core.admin import EmailOutboxAdminForm
 from .models import (
     Node,
     EmailOutbox,
@@ -69,6 +78,24 @@ class NodeManagerAdmin(EntityModelAdmin):
         "user__username",
         "group__name",
     )
+    fieldsets = (
+        (_("Owner"), {"fields": ("user", "group")}),
+        (
+            _("Credentials"),
+            {"fields": ("api_key", "api_secret", "customer_id")},
+        ),
+        (
+            _("Configuration"),
+            {
+                "fields": (
+                    "provider",
+                    "default_domain",
+                    "use_sandbox",
+                    "is_enabled",
+                )
+            },
+        ),
+    )
 
 
 @admin.register(DNSRecord)
@@ -358,6 +385,7 @@ class NodeAdmin(EntityModelAdmin):
 
 @admin.register(EmailOutbox)
 class EmailOutboxAdmin(EntityModelAdmin):
+    form = EmailOutboxAdminForm
     list_display = (
         "owner_label",
         "host",
@@ -369,15 +397,15 @@ class EmailOutboxAdmin(EntityModelAdmin):
     )
     change_form_template = "admin/nodes/emailoutbox/change_form.html"
     fieldsets = (
-        ("Owner", {"fields": ("user", "group", "node")}),
+        ("Owner", {"fields": ("user", "group")}),
+        ("Credentials", {"fields": ("username", "password")}),
         (
             "Configuration",
             {
                 "fields": (
+                    "node",
                     "host",
                     "port",
-                    "username",
-                    "password",
                     "use_tls",
                     "use_ssl",
                     "from_email",
@@ -472,7 +500,14 @@ class NodeRoleAdmin(EntityModelAdmin):
 @admin.register(NodeFeature)
 class NodeFeatureAdmin(EntityModelAdmin):
     filter_horizontal = ("roles",)
-    list_display = ("display", "slug", "default_roles", "is_enabled")
+    list_display = (
+        "display",
+        "slug",
+        "default_roles",
+        "is_enabled_display",
+        "default_action",
+    )
+    actions = ["check_features_for_eligibility", "enable_selected_features"]
     readonly_fields = ("is_enabled",)
     search_fields = ("display", "slug")
 
@@ -485,6 +520,281 @@ class NodeFeatureAdmin(EntityModelAdmin):
         roles = [role.name for role in obj.roles.all()]
         return ", ".join(roles) if roles else "—"
 
+    @admin.display(description="Is Enabled", boolean=True, ordering="is_enabled")
+    def is_enabled_display(self, obj):
+        return obj.is_enabled
+
+    @admin.display(description="Default Action")
+    def default_action(self, obj):
+        if not obj.is_enabled:
+            return "—"
+        action = obj.get_default_action()
+        if not action:
+            return "—"
+        try:
+            url = reverse(action.url_name)
+        except NoReverseMatch:
+            return action.label
+        return format_html('<a href="{}">{}</a>', url, action.label)
+
+    def _manual_enablement_message(self, feature, node):
+        if node is None:
+            return (
+                "Manual enablement is unavailable without a registered local node."
+            )
+        if feature.slug in Node.MANUAL_FEATURE_SLUGS:
+            return "This feature can be enabled manually."
+        return "This feature cannot be enabled manually."
+
+    @admin.action(description="Check features for eligibility")
+    def check_features_for_eligibility(self, request, queryset):
+        from .feature_checks import feature_checks
+
+        features = list(queryset)
+        total = len(features)
+        successes = 0
+        node = Node.get_local()
+        for feature in features:
+            enablement_message = self._manual_enablement_message(feature, node)
+            try:
+                result = feature_checks.run(feature, node=node)
+            except Exception as exc:  # pragma: no cover - defensive
+                self.message_user(
+                    request,
+                    f"{feature.display}: {exc} {enablement_message}",
+                    level=messages.ERROR,
+                )
+                continue
+            if result is None:
+                self.message_user(
+                    request,
+                    f"No check is configured for {feature.display}. {enablement_message}",
+                    level=messages.WARNING,
+                )
+                continue
+            message = result.message or (
+                f"{feature.display} check {'passed' if result.success else 'failed'}."
+            )
+            self.message_user(
+                request, f"{message} {enablement_message}", level=result.level
+            )
+            if result.success:
+                successes += 1
+        if total:
+            self.message_user(
+                request,
+                f"Completed {successes} of {total} feature check(s) successfully.",
+                level=messages.INFO,
+            )
+
+    @admin.action(description="Enable selected action")
+    def enable_selected_features(self, request, queryset):
+        node = Node.get_local()
+        if node is None:
+            self.message_user(
+                request,
+                "No local node is registered; unable to enable features manually.",
+                level=messages.ERROR,
+            )
+            return
+
+        manual_features = [
+            feature
+            for feature in queryset
+            if feature.slug in Node.MANUAL_FEATURE_SLUGS
+        ]
+        non_manual_features = [
+            feature
+            for feature in queryset
+            if feature.slug not in Node.MANUAL_FEATURE_SLUGS
+        ]
+        for feature in non_manual_features:
+            self.message_user(
+                request,
+                f"{feature.display} cannot be enabled manually.",
+                level=messages.WARNING,
+            )
+
+        if not manual_features:
+            self.message_user(
+                request,
+                "None of the selected features can be enabled manually.",
+                level=messages.WARNING,
+            )
+            return
+
+        current_manual = set(
+            node.features.filter(slug__in=Node.MANUAL_FEATURE_SLUGS).values_list(
+                "slug", flat=True
+            )
+        )
+        desired_manual = current_manual | {feature.slug for feature in manual_features}
+        newly_enabled = desired_manual - current_manual
+        if not newly_enabled:
+            self.message_user(
+                request,
+                "Selected manual features are already enabled.",
+                level=messages.INFO,
+            )
+            return
+
+        node.update_manual_features(desired_manual)
+        display_map = {feature.slug: feature.display for feature in manual_features}
+        newly_enabled_names = [display_map[slug] for slug in sorted(newly_enabled)]
+        self.message_user(
+            request,
+            "Enabled {} feature(s): {}".format(
+                len(newly_enabled), ", ".join(newly_enabled_names)
+            ),
+            level=messages.SUCCESS,
+        )
+
+    def get_urls(self):
+        urls = super().get_urls()
+        custom = [
+            path(
+                "celery-report/",
+                self.admin_site.admin_view(self.celery_report),
+                name="nodes_nodefeature_celery_report",
+            ),
+            path(
+                "take-screenshot/",
+                self.admin_site.admin_view(self.take_screenshot),
+                name="nodes_nodefeature_take_screenshot",
+            ),
+            path(
+                "take-snapshot/",
+                self.admin_site.admin_view(self.take_snapshot),
+                name="nodes_nodefeature_take_snapshot",
+            ),
+        ]
+        return custom + urls
+
+    def celery_report(self, request):
+        period = resolve_period(request.GET.get("period"))
+        now = timezone.now()
+        window_end = now + period.delta
+        log_window_start = now - period.delta
+
+        scheduled_tasks = collect_scheduled_tasks(now, window_end)
+        log_collection = collect_celery_log_entries(log_window_start, now)
+
+        period_options = [
+            {
+                "key": candidate.key,
+                "label": candidate.label,
+                "selected": candidate.key == period.key,
+                "url": f"?period={candidate.key}",
+            }
+            for candidate in iter_report_periods()
+        ]
+
+        context = {
+            **self.admin_site.each_context(request),
+            "title": _("Celery Report"),
+            "period": period,
+            "period_options": period_options,
+            "current_time": now,
+            "window_end": window_end,
+            "log_window_start": log_window_start,
+            "scheduled_tasks": scheduled_tasks,
+            "log_entries": log_collection.entries,
+            "log_sources": log_collection.checked_sources,
+        }
+        return TemplateResponse(
+            request,
+            "admin/nodes/nodefeature/celery_report.html",
+            context,
+        )
+
+    def _ensure_feature_enabled(self, request, slug: str, action_label: str):
+        try:
+            feature = NodeFeature.objects.get(slug=slug)
+        except NodeFeature.DoesNotExist:
+            self.message_user(
+                request,
+                f"{action_label} is unavailable because the feature is not configured.",
+                level=messages.ERROR,
+            )
+            return None
+        if not feature.is_enabled:
+            self.message_user(
+                request,
+                f"{feature.display} feature is not enabled on this node.",
+                level=messages.WARNING,
+            )
+            return None
+        return feature
+
+    def take_screenshot(self, request):
+        feature = self._ensure_feature_enabled(
+            request, "screenshot-poll", "Take Screenshot"
+        )
+        if not feature:
+            return redirect("..")
+        url = request.build_absolute_uri("/")
+        try:
+            path = capture_screenshot(url)
+        except Exception as exc:  # pragma: no cover - depends on selenium setup
+            self.message_user(request, str(exc), level=messages.ERROR)
+            return redirect("..")
+        node = Node.get_local()
+        sample = save_screenshot(path, node=node, method="DEFAULT_ACTION")
+        if not sample:
+            self.message_user(
+                request, "Duplicate screenshot; not saved", level=messages.INFO
+            )
+            return redirect("..")
+        self.message_user(
+            request, f"Screenshot saved to {sample.path}", level=messages.SUCCESS
+        )
+        try:
+            change_url = reverse(
+                "admin:nodes_contentsample_change", args=[sample.pk]
+            )
+        except NoReverseMatch:  # pragma: no cover - admin URL always registered
+            self.message_user(
+                request,
+                "Screenshot saved but the admin page could not be resolved.",
+                level=messages.WARNING,
+            )
+            return redirect("..")
+        return redirect(change_url)
+
+    def take_snapshot(self, request):
+        feature = self._ensure_feature_enabled(
+            request, "rpi-camera", "Take a Snapshot"
+        )
+        if not feature:
+            return redirect("..")
+        try:
+            path = capture_rpi_snapshot()
+        except Exception as exc:  # pragma: no cover - depends on camera stack
+            self.message_user(request, str(exc), level=messages.ERROR)
+            return redirect("..")
+        node = Node.get_local()
+        sample = save_screenshot(path, node=node, method="RPI_CAMERA")
+        if not sample:
+            self.message_user(
+                request, "Duplicate snapshot; not saved", level=messages.INFO
+            )
+            return redirect("..")
+        self.message_user(
+            request, f"Snapshot saved to {sample.path}", level=messages.SUCCESS
+        )
+        try:
+            change_url = reverse(
+                "admin:nodes_contentsample_change", args=[sample.pk]
+            )
+        except NoReverseMatch:  # pragma: no cover - admin URL always registered
+            self.message_user(
+                request,
+                "Snapshot saved but the admin page could not be resolved.",
+                level=messages.WARNING,
+            )
+            return redirect("..")
+        return redirect(change_url)
+
 
 @admin.register(ContentSample)
 class ContentSampleAdmin(EntityModelAdmin):

nodes/feature_checks.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, Iterable, Optional
+
+from django.contrib import messages
+
+if False:  # pragma: no cover - typing imports only
+    from .models import Node, NodeFeature
+
+
+@dataclass(frozen=True)
+class FeatureCheckResult:
+    """Outcome of a feature validation."""
+
+    success: bool
+    message: str
+    level: int = messages.INFO
+
+
+FeatureCheck = Callable[["NodeFeature", Optional["Node"]], Any]
+
+
+class FeatureCheckRegistry:
+    """Registry for feature validation callbacks."""
+
+    def __init__(self) -> None:
+        self._checks: Dict[str, FeatureCheck] = {}
+        self._default_check: Optional[FeatureCheck] = None
+
+    def register(self, slug: str) -> Callable[[FeatureCheck], FeatureCheck]:
+        """Register ``func`` as the validator for ``slug``."""
+
+        def decorator(func: FeatureCheck) -> FeatureCheck:
+            self._checks[slug] = func
+            return func
+
+        return decorator
+
+    def register_default(self, func: FeatureCheck) -> FeatureCheck:
+        """Register ``func`` as the fallback validator."""
+
+        self._default_check = func
+        return func
+
+    def get(self, slug: str) -> Optional[FeatureCheck]:
+        return self._checks.get(slug)
+
+    def items(self) -> Iterable[tuple[str, FeatureCheck]]:
+        return self._checks.items()
+
+    def run(
+        self, feature: "NodeFeature", *, node: Optional["Node"] = None
+    ) -> Optional[FeatureCheckResult]:
+        check = self._checks.get(feature.slug)
+        if check is None:
+            check = self._default_check
+            if check is None:
+                return None
+        result = check(feature, node)
+        return self._normalize_result(feature, result)
+
+    def _normalize_result(
+        self, feature: "NodeFeature", result: Any
+    ) -> FeatureCheckResult:
+        if isinstance(result, FeatureCheckResult):
+            return result
+        if result is None:
+            return FeatureCheckResult(
+                True,
+                f"{feature.display} check completed successfully.",
+                messages.SUCCESS,
+            )
+        if isinstance(result, tuple) and len(result) >= 2:
+            success, message, *rest = result
+            level = rest[0] if rest else (
+                messages.SUCCESS if success else messages.ERROR
+            )
+            return FeatureCheckResult(bool(success), str(message), int(level))
+        if isinstance(result, bool):
+            message = (
+                f"{feature.display} check {'passed' if result else 'failed'}."
+            )
+            level = messages.SUCCESS if result else messages.ERROR
+            return FeatureCheckResult(result, message, level)
+        raise TypeError(
+            f"Unsupported feature check result type: {type(result)!r}"
+        )
+
+
+feature_checks = FeatureCheckRegistry()
+
+
+@feature_checks.register_default
+def _default_feature_check(
+    feature: "NodeFeature", node: Optional["Node"]
+) -> FeatureCheckResult:
+    from .models import Node
+
+    target: Optional["Node"] = node or Node.get_local()
+    if target is None:
+        return FeatureCheckResult(
+            False,
+            f"No local node is registered; cannot verify {feature.display}.",
+            messages.WARNING,
+        )
+    try:
+        enabled = feature.is_enabled
+    except Exception as exc:  # pragma: no cover - defensive
+        return FeatureCheckResult(
+            False,
+            f"{feature.display} check failed: {exc}",
+            messages.ERROR,
+        )
+    if enabled:
+        return FeatureCheckResult(
+            True,
+            f"{feature.display} is enabled on {target.hostname}.",
+            messages.SUCCESS,
+        )
+    return FeatureCheckResult(
+        False,
+        f"{feature.display} is not enabled on {target.hostname}.",
+        messages.WARNING,
+    )
+
+
+__all__ = [
+    "FeatureCheck",
+    "FeatureCheckRegistry",
+    "FeatureCheckResult",
+    "feature_checks",
+]