arthexis 0.1.21__py3-none-any.whl → 0.1.22__py3-none-any.whl

core/tests.py

@@ -1969,7 +1969,7 @@ class PackageReleaseAdminActionTests(TestCase):
 
     @mock.patch("core.admin.PackageRelease.dump_fixture")
     @mock.patch("core.admin.requests.get")
-    def test_refresh_from_pypi_creates_releases(self, mock_get, dump):
+    def test_refresh_from_pypi_reports_missing_releases(self, mock_get, dump):
         mock_get.return_value.raise_for_status.return_value = None
         mock_get.return_value.json.return_value = {
             "releases": {
@@ -1982,13 +1982,17 @@ class PackageReleaseAdminActionTests(TestCase):
             }
         }
         self.admin.refresh_from_pypi(self.request, PackageRelease.objects.none())
-        new_release = PackageRelease.objects.get(version="1.1.0")
-        self.assertEqual(new_release.revision, "")
-        self.assertEqual(
-            new_release.release_on,
-            datetime(2024, 2, 2, 15, 45, tzinfo=datetime_timezone.utc),
+        self.assertFalse(
+            PackageRelease.objects.filter(version="1.1.0").exists()
+        )
+        dump.assert_not_called()
+        self.assertIn(
+            (
+                "Manual creation required for 1 release: 1.1.0",
+                messages.WARNING,
+            ),
+            self.messages,
         )
-        dump.assert_called_once()
 
     @mock.patch("core.admin.PackageRelease.dump_fixture")
     @mock.patch("core.admin.requests.get")
@@ -2212,13 +2216,97 @@ class TodoDoneTests(TestCase):
         User.objects.create_superuser("admin", "admin@example.com", "pw")
         self.client.force_login(User.objects.get(username="admin"))
 
-    def test_mark_done_sets_timestamp(self):
+    @mock.patch("core.models.revision_utils.get_revision", return_value="rev123")
+    def test_mark_done_sets_timestamp(self, _get_revision):
         todo = Todo.objects.create(request="Task", is_seed_data=True)
         resp = self.client.post(reverse("todo-done", args=[todo.pk]))
         self.assertRedirects(resp, reverse("admin:index"))
         todo.refresh_from_db()
         self.assertIsNotNone(todo.done_on)
         self.assertFalse(todo.is_deleted)
+        self.assertIsNone(todo.done_node)
+        version_path = Path(settings.BASE_DIR) / "VERSION"
+        expected_version = ""
+        if version_path.exists():
+            expected_version = version_path.read_text(encoding="utf-8").strip()
+        self.assertEqual(todo.done_version, expected_version)
+        self.assertEqual(todo.done_revision, "rev123")
+        self.assertEqual(todo.done_username, "admin")
+
+    def test_mark_done_updates_seed_fixture(self):
+        todo = Todo.objects.create(request="Task", is_seed_data=True)
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            fixture_dir = base / "core" / "fixtures"
+            fixture_dir.mkdir(parents=True)
+            fixture_path = fixture_dir / "todo__task.json"
+            fixture_path.write_text(
+                json.dumps(
+                    [
+                        {
+                            "model": "core.todo",
+                            "fields": {
+                                "request": "Task",
+                                "url": "",
+                                "request_details": "",
+                            },
+                        }
+                    ],
+                    indent=2,
+                )
+                + "\n",
+                encoding="utf-8",
+            )
+
+            with override_settings(BASE_DIR=base):
+                with mock.patch(
+                    "core.models.revision_utils.get_revision", return_value="rev456"
+                ):
+                    resp = self.client.post(reverse("todo-done", args=[todo.pk]))
+
+            self.assertRedirects(resp, reverse("admin:index"))
+            data = json.loads(fixture_path.read_text(encoding="utf-8"))
+            self.assertEqual(len(data), 1)
+            fields = data[0]["fields"]
+            self.assertIn("done_on", fields)
+            self.assertTrue(fields["done_on"])
+            self.assertFalse(fields.get("is_deleted", False))
+            self.assertIn("done_version", fields)
+            self.assertEqual(fields.get("done_revision"), "rev456")
+            self.assertEqual(fields.get("done_username"), "admin")
+
+    def test_soft_delete_updates_seed_fixture(self):
+        todo = Todo.objects.create(request="Task", is_seed_data=True)
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            fixture_dir = base / "core" / "fixtures"
+            fixture_dir.mkdir(parents=True)
+            fixture_path = fixture_dir / "todo__task.json"
+            fixture_path.write_text(
+                json.dumps(
+                    [
+                        {
+                            "model": "core.todo",
+                            "fields": {
+                                "request": "Task",
+                                "url": "",
+                                "request_details": "",
+                            },
+                        }
+                    ],
+                    indent=2,
+                )
+                + "\n",
+                encoding="utf-8",
+            )
+
+            with override_settings(BASE_DIR=base):
+                todo.delete()
+
+            data = json.loads(fixture_path.read_text(encoding="utf-8"))
+            self.assertEqual(len(data), 1)
+            fields = data[0]["fields"]
+            self.assertTrue(fields.get("is_deleted"))
 
     def test_mark_done_missing_task_refreshes(self):
         todo = Todo.objects.create(request="Task", is_seed_data=True)
@@ -2324,6 +2412,61 @@ class TodoDoneTests(TestCase):
         self.assertTrue(todo.is_seed_data)
 
 
+class TodoDeleteTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User.objects.create_superuser("admin", "admin@example.com", "pw")
+        self.client.force_login(User.objects.get(username="admin"))
+
+    def test_delete_marks_task_deleted(self):
+        todo = Todo.objects.create(request="Task", is_seed_data=True)
+        resp = self.client.post(reverse("todo-delete", args=[todo.pk]))
+        self.assertRedirects(resp, reverse("admin:index"))
+        todo.refresh_from_db()
+        self.assertTrue(todo.is_deleted)
+        self.assertIsNone(todo.done_on)
+
+    def test_delete_updates_seed_fixture(self):
+        todo = Todo.objects.create(request="Task", is_seed_data=True)
+        with tempfile.TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            fixture_dir = base / "core" / "fixtures"
+            fixture_dir.mkdir(parents=True)
+            fixture_path = fixture_dir / "todo__task.json"
+            fixture_path.write_text(
+                json.dumps(
+                    [
+                        {
+                            "model": "core.todo",
+                            "fields": {
+                                "request": "Task",
+                                "url": "",
+                                "request_details": "",
+                            },
+                        }
+                    ],
+                    indent=2,
+                )
+                + "\n",
+                encoding="utf-8",
+            )
+
+            with override_settings(BASE_DIR=base):
+                resp = self.client.post(reverse("todo-delete", args=[todo.pk]))
+                self.assertRedirects(resp, reverse("admin:index"))
+                data = json.loads(fixture_path.read_text(encoding="utf-8"))
+        self.assertEqual(len(data), 1)
+        fields = data[0]["fields"]
+        self.assertTrue(fields.get("is_deleted"))
+
+    def test_delete_missing_task_redirects(self):
+        todo = Todo.objects.create(request="Task")
+        todo.is_deleted = True
+        todo.save(update_fields=["is_deleted"])
+        resp = self.client.post(reverse("todo-delete", args=[todo.pk]))
+        self.assertRedirects(resp, reverse("admin:index"))
+
+
 class TodoFocusViewTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -2341,6 +2484,7 @@ class TodoFocusViewTests(TestCase):
         self.assertEqual(resp["X-Frame-Options"], "SAMEORIGIN")
         self.assertContains(resp, f'src="{todo.url}"')
         self.assertContains(resp, "Done")
+        self.assertContains(resp, "Delete")
         self.assertContains(resp, "Back")
         self.assertContains(resp, "Take Snapshot")
         snapshot_url = reverse("todo-snapshot", args=[todo.pk])

core/views.py

@@ -365,6 +365,7 @@ def request_temp_password(request):
     )
 
 
+@staff_member_required
 @require_GET
 def version_info(request):
     """Return the running application version and Git revision."""
@@ -495,6 +496,16 @@ def _sync_with_origin_main(log_path: Path) -> None:
         if stderr:
             _append_log(log_path, "git errors:\n" + stderr)
 
+        status = subprocess.run(
+            ["git", "status"], capture_output=True, text=True, check=False
+        )
+        status_output = (status.stdout or "").strip()
+        status_errors = (status.stderr or "").strip()
+        if status_output:
+            _append_log(log_path, "git status:\n" + status_output)
+        if status_errors:
+            _append_log(log_path, "git status errors:\n" + status_errors)
+
         branch = _current_branch() or "(detached HEAD)"
         instructions = [
             "Manual intervention required to finish syncing with origin/main.",
@@ -2360,6 +2371,7 @@ def todo_focus(request, pk: int):
         "focus_auth": focus_auth,
         "next_url": _get_return_url(request),
         "done_url": reverse("todo-done", args=[todo.pk]),
+        "delete_url": reverse("todo-delete", args=[todo.pk]),
         "snapshot_url": reverse("todo-snapshot", args=[todo.pk]),
     }
     return render(request, "core/todo_focus.html", context)
@@ -2378,7 +2390,29 @@ def todo_done(request, pk: int):
         messages.error(request, _format_condition_failure(todo, result))
         return redirect(redirect_to)
     todo.done_on = timezone.now()
-    todo.save(update_fields=["done_on"])
+    todo.populate_done_metadata(request.user)
+    todo.save(
+        update_fields=[
+            "done_on",
+            "done_node",
+            "done_version",
+            "done_revision",
+            "done_username",
+        ]
+    )
+    return redirect(redirect_to)
+
+
+@staff_member_required
+@require_POST
+def todo_delete(request, pk: int):
+    redirect_to = reverse("admin:index")
+    try:
+        todo = Todo.objects.get(pk=pk, is_deleted=False)
+    except Todo.DoesNotExist:
+        return redirect(redirect_to)
+    todo.is_deleted = True
+    todo.save(update_fields=["is_deleted"])
     return redirect(redirect_to)
 
 

nodes/admin.py

@@ -18,8 +18,10 @@ from django.utils.dateparse import parse_datetime
 from django.utils.html import format_html, format_html_join
 from django.utils.translation import gettext_lazy as _
 from pathlib import Path
-from urllib.parse import urlsplit, urlunsplit
+from types import SimpleNamespace
+from urllib.parse import urlparse, urlsplit, urlunsplit
 import base64
+import ipaddress
 import json
 import subprocess
 import uuid
@@ -85,7 +87,7 @@ class NodeFeatureAssignmentInline(admin.TabularInline):
 
 class DeployDNSRecordsForm(forms.Form):
     manager = forms.ModelChoiceField(
-        label="Node Manager",
+        label="Node Profile",
         queryset=NodeManager.objects.none(),
         help_text="Credentials used to authenticate with the DNS provider.",
     )
@@ -234,6 +236,7 @@ class NodeAdmin(EntityModelAdmin):
         "role",
         "relation",
         "last_seen",
+        "visit_link",
         "proxy_link",
     )
     search_fields = ("hostname", "address", "mac_address")
@@ -284,7 +287,6 @@ class NodeAdmin(EntityModelAdmin):
         "register_visitor",
         "run_task",
         "take_screenshots",
-        "fetch_rfids_from_selected",
         "import_rfids_from_selected",
         "export_rfids_to_selected",
     ]
@@ -304,6 +306,49 @@ class NodeAdmin(EntityModelAdmin):
             return ""
         return format_html('<a class="button" href="{}">{}</a>', url, _("Proxy"))
 
+    @admin.display(description=_("Visit"))
+    def visit_link(self, obj):
+        if not obj:
+            return ""
+        if obj.is_local:
+            try:
+                url = reverse("admin:index")
+            except NoReverseMatch:
+                return ""
+            return format_html(
+                '<a href="{}" target="_blank" rel="noopener noreferrer">{}</a>',
+                url,
+                _("Visit"),
+            )
+
+        host_values: list[str] = []
+        for attr in ("hostname", "address", "public_endpoint"):
+            value = getattr(obj, attr, "") or ""
+            cleaned = value.strip()
+            if cleaned and cleaned not in host_values:
+                host_values.append(cleaned)
+
+        remote_url = ""
+        for host in host_values:
+            temp_node = SimpleNamespace(
+                public_endpoint=host,
+                address="",
+                hostname="",
+                port=obj.port,
+            )
+            remote_url = next(self._iter_remote_urls(temp_node, "/admin/"), "")
+            if remote_url:
+                break
+
+        if not remote_url:
+            return ""
+
+        return format_html(
+            '<a href="{}" target="_blank" rel="noopener noreferrer">{}</a>',
+            remote_url,
+            _("Visit"),
+        )
+
     def get_urls(self):
         urls = super().get_urls()
         custom = [
@@ -598,6 +643,17 @@ class NodeAdmin(EntityModelAdmin):
                 setattr(node, field, value)
                 changed.append(field)
 
+        role_value = payload.get("role") or payload.get("role_name")
+        if role_value is not None:
+            role_name = str(role_value).strip()
+            if role_name:
+                desired_role = NodeRole.objects.filter(name=role_name).first()
+            else:
+                desired_role = None
+            if desired_role and node.role_id != desired_role.id:
+                node.role = desired_role
+                changed.append("role")
+
         node.last_seen = timezone.now()
         if "last_seen" not in changed:
             changed.append("last_seen")
@@ -677,40 +733,96 @@ class NodeAdmin(EntityModelAdmin):
         return {"ok": False, "message": last_error or "Unable to reach remote node."}
 
     def _iter_remote_urls(self, node, path):
-        host_candidates = []
+        host_candidates: list[str] = []
         for attr in ("public_endpoint", "address", "hostname"):
             value = getattr(node, attr, "") or ""
-            value = value.strip()
-            if value and value not in host_candidates:
-                host_candidates.append(value)
+            cleaned = value.strip()
+            if cleaned and cleaned not in host_candidates:
+                host_candidates.append(cleaned)
 
-        port = node.port or 8000
+        default_port = node.port or 8000
         normalized_path = path if path.startswith("/") else f"/{path}"
-        seen = set()
+        seen: set[str] = set()
 
         for host in host_candidates:
+            base_path = ""
             formatted_host = host
-            if ":" in host and not host.startswith("["):
-                formatted_host = f"[{host}]"
-
-            candidates = []
-            if port == 80:
-                candidates = [
-                    f"http://{formatted_host}{normalized_path}",
-                    f"https://{formatted_host}{normalized_path}",
-                ]
-            elif port == 443:
-                candidates = [
-                    f"https://{formatted_host}{normalized_path}",
-                    f"http://{formatted_host}:{port}{normalized_path}",
-                ]
-            else:
-                candidates = [
-                    f"http://{formatted_host}:{port}{normalized_path}",
-                    f"https://{formatted_host}:{port}{normalized_path}",
-                ]
+            port_override: int | None = None
+
+            if "://" in host:
+                parsed = urlparse(host)
+                netloc = parsed.netloc or parsed.path
+                base_path = (parsed.path or "").rstrip("/")
+                combined_path = (
+                    f"{base_path}{normalized_path}" if base_path else normalized_path
+                )
+                primary = urlunsplit((parsed.scheme, netloc, combined_path, "", ""))
+                if primary not in seen:
+                    seen.add(primary)
+                    yield primary
+                if parsed.scheme == "https":
+                    fallback = urlunsplit(("http", netloc, combined_path, "", ""))
+                    if fallback not in seen:
+                        seen.add(fallback)
+                        yield fallback
+                elif parsed.scheme == "http":
+                    alternate = urlunsplit(("https", netloc, combined_path, "", ""))
+                    if alternate not in seen:
+                        seen.add(alternate)
+                        yield alternate
+                continue
 
-            for candidate in candidates:
+            if host.startswith("[") and "]" in host:
+                end = host.index("]")
+                core_host = host[1:end]
+                remainder = host[end + 1 :]
+                if remainder.startswith(":"):
+                    remainder = remainder[1:]
+                    port_part, sep, path_tail = remainder.partition("/")
+                    if port_part:
+                        try:
+                            port_override = int(port_part)
+                        except ValueError:
+                            port_override = None
+                    if sep:
+                        base_path = f"/{path_tail}".rstrip("/")
+                elif "/" in remainder:
+                    _, _, path_tail = remainder.partition("/")
+                    base_path = f"/{path_tail}".rstrip("/")
+                formatted_host = f"[{core_host}]"
+            else:
+                if "/" in host:
+                    host_only, _, path_tail = host.partition("/")
+                    formatted_host = host_only or host
+                    base_path = f"/{path_tail}".rstrip("/")
+                try:
+                    ip_obj = ipaddress.ip_address(formatted_host)
+                except ValueError:
+                    parts = formatted_host.rsplit(":", 1)
+                    if len(parts) == 2 and parts[1].isdigit():
+                        formatted_host = parts[0]
+                        port_override = int(parts[1])
+                    try:
+                        ip_obj = ipaddress.ip_address(formatted_host)
+                    except ValueError:
+                        ip_obj = None
+                else:
+                    if ip_obj.version == 6 and not formatted_host.startswith("["):
+                        formatted_host = f"[{formatted_host}]"
+
+            effective_port = port_override if port_override is not None else default_port
+            combined_path = f"{base_path}{normalized_path}" if base_path else normalized_path
+
+            for scheme, scheme_default_port in (("https", 443), ("http", 80)):
+                base = f"{scheme}://{formatted_host}"
+                if effective_port and (
+                    port_override is not None or effective_port != scheme_default_port
+                ):
+                    explicit = f"{base}:{effective_port}{combined_path}"
+                    if explicit not in seen:
+                        seen.add(explicit)
+                        yield explicit
+                candidate = f"{base}{combined_path}"
                 if candidate not in seen:
                     seen.add(candidate)
                     yield candidate
@@ -999,17 +1111,19 @@ class NodeAdmin(EntityModelAdmin):
         result["status"] = self._status_from_result(result)
         return result
 
-    def _run_rfid_fetch(self, request, queryset, *, operation):
+    def _run_rfid_import(self, request, queryset):
         nodes = list(queryset)
         local_node, private_key, error = self._load_local_node_credentials()
         if error:
             results = [self._skip_result(node, error) for node in nodes]
-            return self._render_rfid_sync(request, operation, results, setup_error=error)
+            return self._render_rfid_sync(
+                request, "import", results, setup_error=error
+            )
 
         if not nodes:
             return self._render_rfid_sync(
                 request,
-                operation,
+                "import",
                 [],
                 setup_error=_("No nodes selected."),
             )
@@ -1032,15 +1146,11 @@ class NodeAdmin(EntityModelAdmin):
                 continue
             results.append(self._process_import_from_node(node, payload, headers))
 
-        return self._render_rfid_sync(request, operation, results)
-
-    @admin.action(description=_("Fetch RFIDs from selected"))
-    def fetch_rfids_from_selected(self, request, queryset):
-        return self._run_rfid_fetch(request, queryset, operation="fetch")
+        return self._render_rfid_sync(request, "import", results)
 
     @admin.action(description=_("Import RFIDs from selected"))
     def import_rfids_from_selected(self, request, queryset):
-        return self._run_rfid_fetch(request, queryset, operation="import")
+        return self._run_rfid_import(request, queryset)
 
     @admin.action(description=_("Export RFIDs to selected"))
     def export_rfids_to_selected(self, request, queryset):

nodes/apps.py

@@ -1,6 +1,7 @@
 import logging
 import os
 import socket
+import sys
 import threading
 import time
 from pathlib import Path
@@ -66,6 +67,10 @@ def _startup_notification() -> None:
 def _trigger_startup_notification(**_: object) -> None:
     """Attempt to send the startup notification in the background."""
 
+    if _is_running_migration_command():
+        logger.debug("Startup notification skipped: running migration command")
+        return
+
     try:
         connections["default"].ensure_connection()
     except OperationalError:
@@ -74,6 +79,12 @@ def _trigger_startup_notification(**_: object) -> None:
     _startup_notification()
 
 
+def _is_running_migration_command() -> bool:
+    """Return ``True`` when Django's ``migrate`` command is executing."""
+
+    return len(sys.argv) > 1 and sys.argv[1] == "migrate"
+
+
 class NodesConfig(AppConfig):
     default_auto_field = "django.db.models.BigAutoField"
     name = "nodes"

nodes/models.py

@@ -16,7 +16,7 @@ import base64
 from django.utils import timezone
 from django.utils.text import slugify
 from django.conf import settings
-from datetime import timedelta
+from datetime import datetime, timedelta, timezone as datetime_timezone
 import uuid
 import os
 import shutil
@@ -481,7 +481,24 @@ class Node(Entity):
         security_dir.mkdir(parents=True, exist_ok=True)
         priv_path = security_dir / f"{self.public_endpoint}"
         pub_path = security_dir / f"{self.public_endpoint}.pub"
-        if not priv_path.exists() or not pub_path.exists():
+        regenerate = not priv_path.exists() or not pub_path.exists()
+        if not regenerate:
+            key_max_age = getattr(settings, "NODE_KEY_MAX_AGE", timedelta(days=90))
+            if key_max_age is not None:
+                try:
+                    priv_mtime = datetime.fromtimestamp(
+                        priv_path.stat().st_mtime, tz=datetime_timezone.utc
+                    )
+                    pub_mtime = datetime.fromtimestamp(
+                        pub_path.stat().st_mtime, tz=datetime_timezone.utc
+                    )
+                except OSError:
+                    regenerate = True
+                else:
+                    cutoff = timezone.now() - key_max_age
+                    if priv_mtime < cutoff or pub_mtime < cutoff:
+                        regenerate = True
+        if regenerate:
             private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
             private_bytes = private_key.private_bytes(
                 encoding=serialization.Encoding.PEM,
@@ -494,8 +511,10 @@ class Node(Entity):
             )
             priv_path.write_bytes(private_bytes)
             pub_path.write_bytes(public_bytes)
-            self.public_key = public_bytes.decode()
-            self.save(update_fields=["public_key"])
+            public_text = public_bytes.decode()
+            if self.public_key != public_text:
+                self.public_key = public_text
+                self.save(update_fields=["public_key"])
         elif not self.public_key:
             self.public_key = pub_path.read_text()
             self.save(update_fields=["public_key"])
@@ -1088,8 +1107,8 @@ class NodeManager(Profile):
     )
 
     class Meta:
-        verbose_name = "Node Manager"
-        verbose_name_plural = "Node Managers"
+        verbose_name = "Node Profile"
+        verbose_name_plural = "Node Profiles"
 
     def __str__(self) -> str:
         owner = self.owner_display()
@@ -1542,6 +1561,7 @@ class NetMessage(Entity):
         payload = attachments if attachments is not None else self.attachments or []
         if not payload:
             return
+
         try:
             objects = list(
                 serializers.deserialize(