arthexis 0.1.10__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,
@@ -26,7 +35,10 @@ from .models import (
     NodeFeatureAssignment,
     ContentSample,
     NetMessage,
+    NodeManager,
+    DNSRecord,
 )
+from . import dns as dns_utils
 from core.user_data import EntityModelAdmin
 
 
@@ -43,6 +55,147 @@ class NodeFeatureAssignmentInline(admin.TabularInline):
     autocomplete_fields = ("feature",)
 
 
+class DeployDNSRecordsForm(forms.Form):
+    manager = forms.ModelChoiceField(
+        label="Node Manager",
+        queryset=NodeManager.objects.none(),
+        help_text="Credentials used to authenticate with the DNS provider.",
+    )
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.fields["manager"].queryset = NodeManager.objects.filter(
+            provider=NodeManager.Provider.GODADDY, is_enabled=True
+        )
+
+
+@admin.register(NodeManager)
+class NodeManagerAdmin(EntityModelAdmin):
+    list_display = ("__str__", "provider", "is_enabled", "default_domain")
+    list_filter = ("provider", "is_enabled")
+    search_fields = (
+        "default_domain",
+        "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)
+class DNSRecordAdmin(EntityModelAdmin):
+    list_display = (
+        "record_type",
+        "fqdn",
+        "data",
+        "ttl",
+        "node_manager",
+        "last_synced_at",
+        "last_verified_at",
+    )
+    list_filter = ("record_type", "provider", "node_manager")
+    search_fields = ("domain", "name", "data")
+    autocomplete_fields = ("node_manager",)
+    actions = ["deploy_selected_records", "validate_selected_records"]
+
+    def _default_manager_for_queryset(self, queryset):
+        manager_ids = list(
+            queryset.exclude(node_manager__isnull=True)
+            .values_list("node_manager_id", flat=True)
+            .distinct()
+        )
+        if len(manager_ids) == 1:
+            return manager_ids[0]
+        available = list(
+            NodeManager.objects.filter(
+                provider=NodeManager.Provider.GODADDY, is_enabled=True
+            ).values_list("pk", flat=True)
+        )
+        if len(available) == 1:
+            return available[0]
+        return None
+
+    @admin.action(description="Deploy Selected records")
+    def deploy_selected_records(self, request, queryset):
+        unsupported = queryset.exclude(provider=DNSRecord.Provider.GODADDY)
+        for record in unsupported:
+            self.message_user(
+                request,
+                f"{record} uses unsupported provider {record.get_provider_display()}",
+                messages.WARNING,
+            )
+        queryset = queryset.filter(provider=DNSRecord.Provider.GODADDY)
+        if not queryset:
+            self.message_user(request, "No GoDaddy records selected.", messages.WARNING)
+            return None
+
+        if "apply" in request.POST:
+            form = DeployDNSRecordsForm(request.POST)
+            if form.is_valid():
+                manager = form.cleaned_data["manager"]
+                result = manager.publish_dns_records(list(queryset))
+                for record, reason in result.skipped.items():
+                    self.message_user(request, f"{record}: {reason}", messages.WARNING)
+                for record, reason in result.failures.items():
+                    self.message_user(request, f"{record}: {reason}", messages.ERROR)
+                if result.deployed:
+                    self.message_user(
+                        request,
+                        f"Deployed {len(result.deployed)} DNS record(s) via {manager}.",
+                        messages.SUCCESS,
+                    )
+                return None
+        else:
+            initial_manager = self._default_manager_for_queryset(queryset)
+            form = DeployDNSRecordsForm(initial={"manager": initial_manager})
+
+        context = {
+            **self.admin_site.each_context(request),
+            "opts": self.model._meta,
+            "form": form,
+            "queryset": queryset,
+            "title": "Deploy DNS records",
+        }
+        return render(
+            request,
+            "admin/nodes/dnsrecord/deploy_records.html",
+            context,
+        )
+
+    @admin.action(description="Validate Selected records")
+    def validate_selected_records(self, request, queryset):
+        resolver = dns_utils.create_resolver()
+        successes = 0
+        for record in queryset:
+            ok, message = dns_utils.validate_record(record, resolver=resolver)
+            if ok:
+                successes += 1
+            else:
+                self.message_user(request, f"{record}: {message}", messages.WARNING)
+        if successes:
+            self.message_user(
+                request,
+                f"Validated {successes} DNS record(s).",
+                messages.SUCCESS,
+            )
+
+
 @admin.register(Node)
 class NodeAdmin(EntityModelAdmin):
     list_display = (
@@ -232,21 +385,31 @@ class NodeAdmin(EntityModelAdmin):
 
 @admin.register(EmailOutbox)
 class EmailOutboxAdmin(EntityModelAdmin):
-    list_display = ("owner_label", "host", "port", "username", "use_tls", "use_ssl")
+    form = EmailOutboxAdminForm
+    list_display = (
+        "owner_label",
+        "host",
+        "port",
+        "username",
+        "use_tls",
+        "use_ssl",
+        "is_enabled",
+    )
     change_form_template = "admin/nodes/emailoutbox/change_form.html"
     fieldsets = (
-        ("Owner", {"fields": ("user", "group", "node")}),
+        ("Owner", {"fields": ("user", "group")}),
+        ("Credentials", {"fields": ("username", "password")}),
         (
-            None,
+            "Configuration",
             {
                 "fields": (
+                    "node",
                     "host",
                     "port",
-                    "username",
-                    "password",
                     "use_tls",
                     "use_ssl",
                     "from_email",
+                    "is_enabled",
                 )
             },
         ),
@@ -337,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")
 
@@ -350,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/backends.py

@@ -38,11 +38,12 @@ class OutboxEmailBackend(BaseEmailBackend):
         user_id = self._resolve_identifier(message, "user")
         group_id = self._resolve_identifier(message, "group")
 
+        enabled_outboxes = EmailOutbox.objects.filter(is_enabled=True)
         match_sets: list[tuple[str, list[EmailOutbox]]] = []
 
         if from_email:
             email_matches = list(
-                EmailOutbox.objects.filter(
+                enabled_outboxes.filter(
                     Q(from_email__iexact=from_email) | Q(username__iexact=from_email)
                 )
             )
@@ -50,22 +51,25 @@ class OutboxEmailBackend(BaseEmailBackend):
                 match_sets.append(("from_email", email_matches))
 
         if node_id:
-            node_matches = list(EmailOutbox.objects.filter(node_id=node_id))
+            node_matches = list(enabled_outboxes.filter(node_id=node_id))
             if node_matches:
                 match_sets.append(("node", node_matches))
 
         if user_id:
-            user_matches = list(EmailOutbox.objects.filter(user_id=user_id))
+            user_matches = list(enabled_outboxes.filter(user_id=user_id))
             if user_matches:
                 match_sets.append(("user", user_matches))
 
         if group_id:
-            group_matches = list(EmailOutbox.objects.filter(group_id=group_id))
+            group_matches = list(enabled_outboxes.filter(group_id=group_id))
             if group_matches:
                 match_sets.append(("group", group_matches))
 
         if not match_sets:
-            return EmailOutbox.objects.first(), []
+            fallback = self._fallback_outbox(enabled_outboxes)
+            if fallback:
+                return fallback, []
+            return None, []
 
         candidates: dict[int, EmailOutbox] = {}
         scores: defaultdict[int, int] = defaultdict(int)
@@ -76,7 +80,10 @@ class OutboxEmailBackend(BaseEmailBackend):
                 scores[outbox.pk] += 1
 
         if not candidates:
-            return EmailOutbox.objects.first(), []
+            fallback = self._fallback_outbox(enabled_outboxes)
+            if fallback:
+                return fallback, []
+            return None, []
 
         selected: EmailOutbox | None = None
         fallbacks: list[EmailOutbox] = []
@@ -93,6 +100,14 @@ class OutboxEmailBackend(BaseEmailBackend):
 
         return selected, fallbacks
 
+    def _fallback_outbox(self, queryset):
+        ownerless = queryset.filter(
+            node__isnull=True, user__isnull=True, group__isnull=True
+        ).order_by("pk").first()
+        if ownerless:
+            return ownerless
+        return queryset.order_by("pk").first()
+
     def send_messages(self, email_messages):
         sent = 0
         for message in email_messages: