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

core/views.py

@@ -1,4 +1,5 @@
 import json
+import logging
 import shutil
 from datetime import timedelta
 
@@ -8,7 +9,7 @@ from django.contrib.admin.views.decorators import staff_member_required
 from django.contrib.auth import authenticate, login
 from django.contrib import messages
 from django.contrib.sites.models import Site
-from django.http import Http404, JsonResponse
+from django.http import Http404, JsonResponse, HttpResponse
 from django.shortcuts import get_object_or_404, redirect, render, resolve_url
 from django.utils import timezone
 from django.utils.text import slugify
@@ -22,9 +23,14 @@ from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
 import errno
 import subprocess
 
+from django.template.loader import get_template
+from django.test import signals
+
 from utils import revision
 from utils.api import api_login_required
 
+logger = logging.getLogger(__name__)
+
 from .models import Product, EnergyAccount, PackageRelease, Todo
 from .models import RFID
 
@@ -44,6 +50,13 @@ def odoo_products(request):
             {"fields": ["name"], "limit": 50},
         )
     except Exception:
+        logger.exception(
+            "Failed to fetch Odoo products via API for user %s (profile_id=%s, host=%s, database=%s)",
+            getattr(request.user, "pk", None),
+            getattr(profile, "pk", None),
+            getattr(profile, "host", None),
+            getattr(profile, "database", None),
+        )
         return JsonResponse({"detail": "Unable to fetch products"}, status=502)
     items = [{"id": p.get("id"), "name": p.get("name", "")} for p in products]
     return JsonResponse(items, safe=False)
@@ -77,6 +90,10 @@ def _append_log(path: Path, message: str) -> None:
         fh.write(message + "\n")
 
 
+def _release_log_name(package_name: str, version: str) -> str:
+    return f"pr.{package_name}.v{version}.log"
+
+
 def _clean_repo() -> None:
     """Return the git repository to a clean state."""
     subprocess.run(["git", "reset", "--hard"], check=False)
@@ -599,9 +616,14 @@ def _step_promote_build(release, ctx, log_path: Path) -> None:
     except Exception:
         _clean_repo()
         raise
-    release_name = f"{release.package.name}-{release.version}"
-    new_log = log_path.with_name(f"{release_name}.log")
-    log_path.rename(new_log)
+    target_name = _release_log_name(release.package.name, release.version)
+    new_log = log_path.with_name(target_name)
+    if log_path != new_log:
+        if new_log.exists():
+            new_log.unlink()
+        log_path.rename(new_log)
+    else:
+        new_log = log_path
     ctx["log"] = new_log.name
     _append_log(new_log, "Build complete")
 
@@ -880,9 +902,8 @@ def release_progress(request, pk: int, action: str):
             if restart_path.exists():
                 restart_path.unlink()
             log_dir = Path("logs")
-            for log_file in log_dir.glob(
-                f"{release.package.name}-{previous_version}*.log"
-            ):
+            pattern = f"pr.{release.package.name}.v{previous_version}*.log"
+            for log_file in log_dir.glob(pattern):
                 log_file.unlink()
         if not release.is_current:
             raise Http404("Release is not current")
@@ -904,7 +925,8 @@ def release_progress(request, pk: int, action: str):
         if lock_path.exists():
             lock_path.unlink()
         log_dir = Path("logs")
-        for f in log_dir.glob(f"{release.package.name}-{release.version}*.log"):
+        pattern = f"pr.{release.package.name}.v{release.version}*.log"
+        for f in log_dir.glob(pattern):
             f.unlink()
         return redirect(request.path)
     ctx = request.session.get(session_key)
@@ -979,8 +1001,7 @@ def release_progress(request, pk: int, action: str):
     else:
         ctx.pop("todos", None)
 
-    identifier = f"{release.package.name}-{release.version}"
-    log_name = f"{identifier}.log"
+    log_name = _release_log_name(release.package.name, release.version)
     if ctx.get("log") != log_name:
         ctx = {
             "step": 0,
@@ -1186,7 +1207,18 @@ def release_progress(request, pk: int, action: str):
     else:
         lock_path.parent.mkdir(parents=True, exist_ok=True)
         lock_path.write_text(json.dumps(ctx), encoding="utf-8")
-    return render(request, "core/release_progress.html", context)
+    template = get_template("core/release_progress.html")
+    content = template.render(context, request)
+    signals.template_rendered.send(
+        sender=template.__class__,
+        template=template,
+        context=context,
+        using=getattr(getattr(template, "engine", None), "name", None),
+    )
+    response = HttpResponse(content)
+    response.context = context
+    response.templates = [template]
+    return response
 
 
 def _dedupe_preserve_order(values):
@@ -1371,8 +1403,11 @@ def todo_focus(request, pk: int):
 @staff_member_required
 @require_POST
 def todo_done(request, pk: int):
-    todo = get_object_or_404(Todo, pk=pk, is_deleted=False, done_on__isnull=True)
     redirect_to = _get_return_url(request)
+    try:
+        todo = Todo.objects.get(pk=pk, is_deleted=False, done_on__isnull=True)
+    except Todo.DoesNotExist:
+        return redirect(redirect_to)
     result = todo.check_on_done_condition()
     if not result.passed:
         messages.error(request, _format_condition_failure(todo, result))

core/widgets.py

@@ -1,4 +1,5 @@
 from django import forms
+from django.forms.widgets import ClearableFileInput
 import json
 
 
@@ -49,3 +50,45 @@ class OdooProductWidget(forms.Select):
             return json.loads(raw)
         except Exception:
             return {}
+
+
+class AdminBase64FileWidget(ClearableFileInput):
+    """Clearable file input that exposes base64 data for downloads."""
+
+    template_name = "widgets/admin_base64_file.html"
+
+    def __init__(
+        self,
+        *,
+        download_name: str | None = None,
+        content_type: str = "application/octet-stream",
+        **kwargs,
+    ) -> None:
+        self.download_name = download_name
+        self.content_type = content_type
+        super().__init__(**kwargs)
+
+    def is_initial(self, value):
+        if isinstance(value, str):
+            return bool(value)
+        return super().is_initial(value)
+
+    def format_value(self, value):
+        if isinstance(value, str):
+            return value
+        return super().format_value(value)
+
+    def get_context(self, name, value, attrs):
+        if isinstance(value, str):
+            base64_value = value.strip()
+            rendered_value = None
+        else:
+            base64_value = None
+            rendered_value = value
+        context = super().get_context(name, rendered_value, attrs)
+        widget_context = context["widget"]
+        widget_context["is_initial"] = bool(base64_value)
+        widget_context["base64_value"] = base64_value
+        widget_context["download_name"] = self.download_name or f"{name}.bin"
+        widget_context["content_type"] = self.content_type
+        return context

nodes/admin.py

@@ -2,7 +2,7 @@ from django.contrib import admin, messages
 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.utils.html import format_html, format_html_join
 from django import forms
 from django.contrib.admin.widgets import FilteredSelectMultiple
 from core.widgets import CopyColorWidget
@@ -12,11 +12,20 @@ from pathlib import Path
 from django.http import HttpResponse
 from django.utils import timezone
 from django.utils.translation import gettext_lazy as _
+from urllib.parse import urlsplit, urlunsplit
+from django.core.exceptions import PermissionDenied
+from django.utils.dateparse import parse_datetime
 import base64
+import json
 import pyperclip
 from pyperclip import PyperclipException
 import uuid
 import subprocess
+
+import requests
+from requests import RequestException
+from cryptography.hazmat.primitives import hashes, serialization
+from cryptography.hazmat.primitives.asymmetric import padding
 from .utils import capture_rpi_snapshot, capture_screenshot, save_screenshot
 from .actions import NodeAction
 from .reports import (
@@ -39,6 +48,7 @@ from .models import (
     DNSRecord,
 )
 from . import dns as dns_utils
+from core.models import RFID
 from core.user_data import EntityModelAdmin
 
 
@@ -210,7 +220,12 @@ class NodeAdmin(EntityModelAdmin):
     change_list_template = "admin/nodes/node/change_list.html"
     change_form_template = "admin/nodes/node/change_form.html"
     form = NodeAdminForm
-    actions = ["register_visitor", "run_task", "take_screenshots"]
+    actions = [
+        "register_visitor",
+        "run_task",
+        "take_screenshots",
+        "fetch_rfids",
+    ]
     inlines = [NodeFeatureAssignmentInline]
 
     def get_urls(self):
@@ -241,6 +256,8 @@ class NodeAdmin(EntityModelAdmin):
 
     def register_current(self, request):
         """Create or update this host and offer browser node registration."""
+        if not request.user.is_superuser:
+            raise PermissionDenied
         node, created = Node.register_current()
         if created:
             self.message_user(
@@ -346,6 +363,151 @@ class NodeAdmin(EntityModelAdmin):
                     count += 1
         self.message_user(request, f"{count} screenshots captured", messages.SUCCESS)
 
+    @admin.action(description="Fetch RFIDs from selected")
+    def fetch_rfids(self, request, queryset):
+        local_node = Node.get_local()
+        if not local_node:
+            self.message_user(
+                request,
+                "Local node is not registered.",
+                messages.ERROR,
+            )
+            return None
+
+        security_dir = Path(local_node.base_path or settings.BASE_DIR) / "security"
+        priv_path = security_dir / f"{local_node.public_endpoint}"
+        if not priv_path.exists():
+            self.message_user(
+                request,
+                "Local node private key not found.",
+                messages.ERROR,
+            )
+            return None
+
+        try:
+            private_key = serialization.load_pem_private_key(
+                priv_path.read_bytes(), password=None
+            )
+        except Exception as exc:  # pragma: no cover - unexpected key errors
+            self.message_user(
+                request,
+                f"Failed to load private key: {exc}",
+                messages.ERROR,
+            )
+            return None
+
+        payload = json.dumps(
+            {"requester": str(local_node.uuid)},
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        signature = base64.b64encode(
+            private_key.sign(
+                payload.encode(),
+                padding.PKCS1v15(),
+                hashes.SHA256(),
+            )
+        ).decode()
+        headers = {
+            "Content-Type": "application/json",
+            "X-Signature": signature,
+        }
+
+        processed = 0
+        total_created = 0
+        total_updated = 0
+        errors = 0
+
+        for node in queryset:
+            if local_node.pk and node.pk == local_node.pk:
+                continue
+            url = f"http://{node.address}:{node.port}/nodes/rfid/export/"
+            try:
+                response = requests.post(
+                    url,
+                    data=payload,
+                    headers=headers,
+                    timeout=5,
+                )
+            except RequestException as exc:
+                self.message_user(request, f"{node}: {exc}", messages.ERROR)
+                errors += 1
+                continue
+
+            if response.status_code != 200:
+                self.message_user(
+                    request,
+                    f"{node}: {response.status_code} {response.text}",
+                    messages.ERROR,
+                )
+                errors += 1
+                continue
+
+            try:
+                data = response.json()
+            except ValueError:
+                self.message_user(
+                    request,
+                    f"{node}: invalid JSON response",
+                    messages.ERROR,
+                )
+                errors += 1
+                continue
+
+            created = 0
+            updated = 0
+            rfids = data.get("rfids", []) or []
+            for entry in rfids:
+                rfid_value = entry.get("rfid")
+                if not rfid_value:
+                    continue
+                defaults = {
+                    "custom_label": entry.get("custom_label", ""),
+                    "key_a": entry.get(
+                        "key_a", RFID._meta.get_field("key_a").default
+                    ),
+                    "key_b": entry.get(
+                        "key_b", RFID._meta.get_field("key_b").default
+                    ),
+                    "data": entry.get("data", []),
+                    "key_a_verified": bool(entry.get("key_a_verified", False)),
+                    "key_b_verified": bool(entry.get("key_b_verified", False)),
+                    "allowed": bool(entry.get("allowed", True)),
+                    "color": entry.get("color", RFID.BLACK),
+                    "kind": entry.get("kind", RFID.CLASSIC),
+                    "released": bool(entry.get("released", False)),
+                    "origin_node": node,
+                }
+                if "last_seen_on" in entry:
+                    last_seen_raw = entry.get("last_seen_on")
+                    if last_seen_raw:
+                        defaults["last_seen_on"] = parse_datetime(last_seen_raw)
+                    else:
+                        defaults["last_seen_on"] = None
+
+                obj, created_flag = RFID.objects.update_or_create(
+                    rfid=rfid_value,
+                    defaults=defaults,
+                )
+                if created_flag:
+                    created += 1
+                else:
+                    updated += 1
+
+            processed += 1
+            total_created += created
+            total_updated += updated
+
+        if processed:
+            message = (
+                f"Fetched RFIDs from {processed} node(s); "
+                f"{total_created} created, {total_updated} updated."
+            )
+            level = messages.SUCCESS if not errors else messages.WARNING
+            self.message_user(request, message, level)
+        elif not errors:
+            self.message_user(request, "No remote nodes selected.", messages.INFO)
+
     def changeform_view(self, request, object_id=None, form_url="", extra_context=None):
         extra_context = extra_context or {}
         extra_context["node_actions"] = NodeAction.get_actions()
@@ -505,7 +667,7 @@ class NodeFeatureAdmin(EntityModelAdmin):
         "slug",
         "default_roles",
         "is_enabled_display",
-        "default_action",
+        "available_actions",
     )
     actions = ["check_features_for_eligibility", "enable_selected_features"]
     readonly_fields = ("is_enabled",)
@@ -524,18 +686,26 @@ class NodeFeatureAdmin(EntityModelAdmin):
     def is_enabled_display(self, obj):
         return obj.is_enabled
 
-    @admin.display(description="Default Action")
-    def default_action(self, obj):
+    @admin.display(description="Actions")
+    def available_actions(self, obj):
         if not obj.is_enabled:
             return "—"
-        action = obj.get_default_action()
-        if not action:
+        actions = obj.get_default_actions()
+        if not actions:
             return "—"
-        try:
-            url = reverse(action.url_name)
-        except NoReverseMatch:
-            return action.label
-        return format_html('<a href="{}">{}</a>', url, action.label)
+
+        links = []
+        for action in actions:
+            try:
+                url = reverse(action.url_name)
+            except NoReverseMatch:
+                links.append(action.label)
+            else:
+                links.append(format_html('<a href="{}">{}</a>', url, action.label))
+
+        if not links:
+            return "—"
+        return format_html_join(" | ", "{}", ((link,) for link in links))
 
     def _manual_enablement_message(self, feature, node):
         if node is None:
@@ -667,6 +837,11 @@ class NodeFeatureAdmin(EntityModelAdmin):
                 self.admin_site.admin_view(self.take_snapshot),
                 name="nodes_nodefeature_take_snapshot",
             ),
+            path(
+                "view-stream/",
+                self.admin_site.admin_view(self.view_stream),
+                name="nodes_nodefeature_view_stream",
+            ),
         ]
         return custom + urls
 
@@ -795,6 +970,33 @@ class NodeFeatureAdmin(EntityModelAdmin):
             return redirect("..")
         return redirect(change_url)
 
+    def view_stream(self, request):
+        feature = self._ensure_feature_enabled(request, "rpi-camera", "View stream")
+        if not feature:
+            return redirect("..")
+
+        configured_stream = getattr(settings, "RPI_CAMERA_STREAM_URL", "").strip()
+        if configured_stream:
+            stream_url = configured_stream
+        else:
+            base_uri = request.build_absolute_uri("/")
+            parsed = urlsplit(base_uri)
+            hostname = parsed.hostname or "127.0.0.1"
+            port = getattr(settings, "RPI_CAMERA_STREAM_PORT", 8554)
+            scheme = getattr(settings, "RPI_CAMERA_STREAM_SCHEME", "http")
+            netloc = f"{hostname}:{port}" if port else hostname
+            stream_url = urlunsplit((scheme, netloc, "/", "", ""))
+        context = {
+            **self.admin_site.each_context(request),
+            "title": _("Raspberry Pi Camera Stream"),
+            "stream_url": stream_url,
+        }
+        return TemplateResponse(
+            request,
+            "admin/nodes/nodefeature/view_stream.html",
+            context,
+        )
+
 
 @admin.register(ContentSample)
 class ContentSampleAdmin(EntityModelAdmin):
@@ -876,19 +1078,80 @@ class ContentSampleAdmin(EntityModelAdmin):
 
 @admin.register(NetMessage)
 class NetMessageAdmin(EntityModelAdmin):
+    class NetMessageAdminForm(forms.ModelForm):
+        class Meta:
+            model = NetMessage
+            fields = "__all__"
+            widgets = {"body": forms.Textarea(attrs={"rows": 4})}
+
+    form = NetMessageAdminForm
+    change_form_template = "admin/nodes/netmessage/change_form.html"
     list_display = (
         "subject",
         "body",
-        "reach",
+        "filter_node",
+        "filter_node_role",
         "node_origin",
         "created",
+        "target_limit",
         "complete",
     )
     search_fields = ("subject", "body")
-    list_filter = ("complete", "reach")
+    list_filter = ("complete", "filter_node_role", "filter_current_relation")
     ordering = ("-created",)
     readonly_fields = ("complete",)
     actions = ["send_messages"]
+    fieldsets = (
+        (None, {"fields": ("subject", "body")}),
+        (
+            "Filters",
+            {
+                "fields": (
+                    "filter_node",
+                    "filter_node_feature",
+                    "filter_node_role",
+                    "filter_current_relation",
+                    "filter_installed_version",
+                    "filter_installed_revision",
+                )
+            },
+        ),
+        (
+            "Propagation",
+            {
+                "fields": (
+                    "node_origin",
+                    "target_limit",
+                    "propagated_to",
+                    "complete",
+                )
+            },
+        ),
+    )
+
+    def get_changeform_initial_data(self, request):
+        initial = super().get_changeform_initial_data(request)
+        initial = dict(initial) if initial else {}
+        reply_to = request.GET.get("reply_to")
+        if reply_to:
+            try:
+                message = (
+                    NetMessage.objects.select_related("node_origin__role")
+                    .get(pk=reply_to)
+                )
+            except (NetMessage.DoesNotExist, ValueError, TypeError):
+                message = None
+            if message:
+                subject = (message.subject or "").strip()
+                if subject:
+                    if not subject.lower().startswith("re:"):
+                        subject = f"Re: {subject}"
+                else:
+                    subject = "Re:"
+                initial.setdefault("subject", subject[:64])
+                if message.node_origin and "filter_node" not in initial:
+                    initial["filter_node"] = message.node_origin.pk
+        return initial
 
     def send_messages(self, request, queryset):
         for msg in queryset:

nodes/apps.py

@@ -31,6 +31,21 @@ def _startup_notification() -> None:
     rev_short = revision_value[-6:] if revision_value else ""
 
     body = version
+    if body:
+        normalized = body.lstrip("vV") or body
+        base_version = normalized.rstrip("+")
+        needs_marker = False
+        if base_version and revision_value:
+            try:  # pragma: no cover - defensive guard
+                from core.models import PackageRelease
+
+                needs_marker = not PackageRelease.matches_revision(
+                    base_version, revision_value
+                )
+            except Exception:
+                logger.debug("Startup release comparison failed", exc_info=True)
+        if needs_marker and not normalized.endswith("+"):
+            body = f"{body}+"
     if rev_short:
         body = f"{body} r{rev_short}" if body else f"r{rev_short}"