arthexis 0.1.9__py3-none-any.whl → 0.1.10__py3-none-any.whl

core/views.py

@@ -3,19 +3,24 @@ import shutil
 from datetime import timedelta
 
 import requests
+from django.conf import settings
 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.shortcuts import get_object_or_404, render, redirect
-from django.views.decorators.csrf import csrf_exempt
-from django.views.decorators.http import require_POST
-from django.utils.translation import gettext as _
+from django.shortcuts import get_object_or_404, redirect, render, resolve_url
 from django.utils import timezone
+from django.utils.translation import gettext as _
 from django.urls import NoReverseMatch, reverse
+from django.views.decorators.csrf import csrf_exempt
+from django.views.decorators.http import require_GET, require_POST
+from django.utils.http import url_has_allowed_host_and_scheme
 from pathlib import Path
+from urllib.parse import urlsplit, urlunsplit
 import subprocess
-import json
 
+from utils import revision
 from utils.api import api_login_required
 
 from .models import Product, EnergyAccount, PackageRelease, Todo
@@ -42,6 +47,22 @@ def odoo_products(request):
     return JsonResponse(items, safe=False)
 
 
+@require_GET
+def version_info(request):
+    """Return the running application version and Git revision."""
+
+    version = ""
+    version_path = Path(settings.BASE_DIR) / "VERSION"
+    if version_path.exists():
+        version = version_path.read_text(encoding="utf-8").strip()
+    return JsonResponse(
+        {
+            "version": version,
+            "revision": revision.get_revision(),
+        }
+    )
+
+
 from . import release as release_utils
 
 
@@ -60,6 +81,53 @@ def _clean_repo() -> None:
     subprocess.run(["git", "clean", "-fd"], check=False)
 
 
+def _sync_release_with_revision(release: PackageRelease) -> tuple[bool, str]:
+    """Ensure ``release`` matches the repository revision and version.
+
+    Returns a tuple ``(updated, previous_version)`` where ``updated`` is
+    ``True`` when any field changed and ``previous_version`` is the version
+    before synchronization.
+    """
+
+    from packaging.version import InvalidVersion, Version
+
+    previous_version = release.version
+    updated_fields: set[str] = set()
+
+    repo_version: Version | None = None
+    version_path = Path("VERSION")
+    if version_path.exists():
+        try:
+            repo_version = Version(version_path.read_text(encoding="utf-8").strip())
+        except InvalidVersion:
+            repo_version = None
+
+    try:
+        release_version = Version(release.version)
+    except InvalidVersion:
+        release_version = None
+
+    if repo_version is not None:
+        bumped_repo_version = Version(
+            f"{repo_version.major}.{repo_version.minor}.{repo_version.micro + 1}"
+        )
+        if release_version is None or release_version < bumped_repo_version:
+            release.version = str(bumped_repo_version)
+            release_version = bumped_repo_version
+            updated_fields.add("version")
+
+    current_revision = revision.get_revision()
+    if current_revision and current_revision != release.revision:
+        release.revision = current_revision
+        updated_fields.add("revision")
+
+    if updated_fields:
+        release.save(update_fields=list(updated_fields))
+        PackageRelease.dump_fixture()
+
+    return bool(updated_fields), previous_version
+
+
 def _changelog_notes(version: str) -> str:
     path = Path("CHANGELOG.rst")
     if not path.exists():
@@ -85,6 +153,46 @@ class ApprovalRequired(Exception):
     """Raised when release manager approval is required before continuing."""
 
 
+def _format_condition_failure(todo: Todo, result) -> str:
+    """Return a localized error message for a failed TODO condition."""
+
+    if result.error and result.resolved:
+        detail = _("%(condition)s (error: %(error)s)") % {
+            "condition": result.resolved,
+            "error": result.error,
+        }
+    elif result.error:
+        detail = _("Error: %(error)s") % {"error": result.error}
+    elif result.resolved:
+        detail = result.resolved
+    else:
+        detail = _("Condition evaluated to False")
+    return _("Condition failed for %(todo)s: %(detail)s") % {
+        "todo": todo.request,
+        "detail": detail,
+    }
+
+
+def _get_return_url(request) -> str:
+    """Return a safe URL to redirect back to after completing a TODO."""
+
+    candidates = [request.GET.get("next"), request.POST.get("next")]
+    referer = request.META.get("HTTP_REFERER")
+    if referer:
+        candidates.append(referer)
+
+    for candidate in candidates:
+        if not candidate:
+            continue
+        if url_has_allowed_host_and_scheme(
+            candidate,
+            allowed_hosts={request.get_host()},
+            require_https=request.is_secure(),
+        ):
+            return candidate
+    return resolve_url("admin:index")
+
+
 def _step_check_todos(release, ctx, log_path: Path) -> None:
     pending_qs = Todo.objects.filter(is_deleted=False, done_on__isnull=True)
     if pending_qs.exists():
@@ -312,10 +420,13 @@ def _step_publish(release, ctx, log_path: Path) -> None:
     _append_log(log_path, "Upload complete")
 
 
+FIXTURE_REVIEW_STEP_NAME = "Freeze, squash and approve migrations"
+
+
 PUBLISH_STEPS = [
     ("Check version number availability", _step_check_version),
     ("Confirm release TODO completion", _step_check_todos),
-    ("Freeze, squash and approve migrations", _step_handle_migrations),
+    (FIXTURE_REVIEW_STEP_NAME, _step_handle_migrations),
     ("Compose CHANGELOG and documentation", _step_changelog_docs),
     ("Execute pre-release actions", _step_pre_release_actions),
     ("Build release artifacts", _step_promote_build),
@@ -514,12 +625,26 @@ def release_progress(request, pk: int, action: str):
     release = get_object_or_404(PackageRelease, pk=pk)
     if action != "publish":
         raise Http404("Unknown action")
-    if not release.is_current:
-        raise Http404("Release is not current")
     session_key = f"release_publish_{pk}"
     lock_path = Path("locks") / f"release_publish_{pk}.json"
     restart_path = Path("locks") / f"release_publish_{pk}.restarts"
 
+    if not release.is_current:
+        if release.is_published:
+            raise Http404("Release is not current")
+        updated, previous_version = _sync_release_with_revision(release)
+        if updated:
+            request.session.pop(session_key, None)
+            if lock_path.exists():
+                lock_path.unlink()
+            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"
+            ):
+                log_file.unlink()
+
     if request.GET.get("restart"):
         count = 0
         if restart_path.exists():
@@ -555,11 +680,11 @@ def release_progress(request, pk: int, action: str):
     if credentials_ready and ctx.get("approval_credentials_missing"):
         ctx.pop("approval_credentials_missing", None)
 
+    ack_todos_requested = bool(request.GET.get("ack_todos"))
+
     if request.GET.get("start"):
         ctx["started"] = True
         ctx["paused"] = False
-    if request.GET.get("ack_todos"):
-        ctx["todos_ack"] = True
     if (
         ctx.get("awaiting_approval")
         and not ctx.get("approval_credentials_missing")
@@ -580,9 +705,34 @@ def release_progress(request, pk: int, action: str):
     step_count = ctx.get("step", 0)
     step_param = request.GET.get("step")
 
-    pending = Todo.objects.filter(is_deleted=False, done_on__isnull=True)
-    if pending.exists() and not ctx.get("todos_ack"):
-        ctx["todos"] = list(pending.values("id", "request", "url", "request_details"))
+    pending_qs = Todo.objects.filter(is_deleted=False, done_on__isnull=True)
+    pending_items = list(pending_qs)
+    if ack_todos_requested:
+        if pending_items:
+            failures = []
+            for todo in pending_items:
+                result = todo.check_on_done_condition()
+                if not result.passed:
+                    failures.append((todo, result))
+            if failures:
+                ctx.pop("todos_ack", None)
+                for todo, result in failures:
+                    messages.error(request, _format_condition_failure(todo, result))
+            else:
+                ctx["todos_ack"] = True
+        else:
+            ctx["todos_ack"] = True
+
+    if pending_items and not ctx.get("todos_ack"):
+        ctx["todos"] = [
+            {
+                "id": todo.pk,
+                "request": todo.request,
+                "url": todo.url,
+                "request_details": todo.request_details,
+            }
+            for todo in pending_items
+        ]
     else:
         ctx.pop("todos", None)
 
@@ -608,6 +758,14 @@ def release_progress(request, pk: int, action: str):
             log_path.unlink()
 
     steps = PUBLISH_STEPS
+    fixtures_step_index = next(
+        (
+            index
+            for index, (name, _) in enumerate(steps)
+            if name == FIXTURE_REVIEW_STEP_NAME
+        ),
+        None,
+    )
     error = ctx.get("error")
 
     if (
@@ -742,6 +900,14 @@ def release_progress(request, pk: int, action: str):
             "admin:core_user_change", args=[request.user.pk]
         )
 
+    fixtures_summary = ctx.get("fixtures")
+    if (
+        fixtures_summary
+        and fixtures_step_index is not None
+        and step_count > fixtures_step_index
+    ):
+        fixtures_summary = None
+
     context = {
         "release": release,
         "action": "publish",
@@ -753,7 +919,7 @@ def release_progress(request, pk: int, action: str):
         "log_content": log_content,
         "log_path": str(log_path),
         "cert_log": ctx.get("cert_log"),
-        "fixtures": ctx.get("fixtures"),
+        "fixtures": fixtures_summary,
         "todos": ctx.get("todos"),
         "restart_count": restart_count,
         "started": ctx.get("started", False),
@@ -780,10 +946,86 @@ def release_progress(request, pk: int, action: str):
     return render(request, "core/release_progress.html", context)
 
 
+def _todo_iframe_url(request, todo: Todo) -> str:
+    """Return a safe iframe URL for ``todo`` scoped to the current host."""
+
+    fallback = reverse("admin:core_todo_change", args=[todo.pk])
+    raw_url = (todo.url or "").strip()
+    if not raw_url:
+        return fallback
+
+    parsed = urlsplit(raw_url)
+    if not parsed.scheme and not parsed.netloc:
+        return raw_url
+
+    if parsed.scheme and parsed.scheme.lower() not in {"http", "https"}:
+        return fallback
+
+    request_host = request.get_host().strip().lower()
+    host_without_port = request_host.split(":", 1)[0]
+    allowed_hosts = {
+        request_host,
+        host_without_port,
+        "localhost",
+        "127.0.0.1",
+        "0.0.0.0",
+        "::1",
+    }
+
+    site_domain = ""
+    try:
+        site_domain = Site.objects.get_current().domain.strip().lower()
+    except Site.DoesNotExist:
+        site_domain = ""
+    if site_domain:
+        allowed_hosts.add(site_domain)
+        allowed_hosts.add(site_domain.split(":", 1)[0])
+
+    for host in getattr(settings, "ALLOWED_HOSTS", []):
+        if not isinstance(host, str):
+            continue
+        normalized = host.strip().lower()
+        if not normalized or normalized.startswith("*"):
+            continue
+        allowed_hosts.add(normalized)
+        allowed_hosts.add(normalized.split(":", 1)[0])
+
+    hostname = (parsed.hostname or "").strip().lower()
+    netloc = parsed.netloc.strip().lower()
+    if hostname in allowed_hosts or netloc in allowed_hosts:
+        path = parsed.path or "/"
+        if not path.startswith("/"):
+            path = f"/{path}"
+        return urlunsplit(("", "", path, parsed.query, parsed.fragment)) or fallback
+
+    return fallback
+
+
+@staff_member_required
+def todo_focus(request, pk: int):
+    todo = get_object_or_404(Todo, pk=pk, is_deleted=False)
+    if todo.done_on:
+        return redirect(_get_return_url(request))
+
+    iframe_url = _todo_iframe_url(request, todo)
+    context = {
+        "todo": todo,
+        "iframe_url": iframe_url,
+        "next_url": _get_return_url(request),
+        "done_url": reverse("todo-done", args=[todo.pk]),
+    }
+    return render(request, "core/todo_focus.html", context)
+
+
 @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)
+    result = todo.check_on_done_condition()
+    if not result.passed:
+        messages.error(request, _format_condition_failure(todo, result))
+        return redirect(redirect_to)
     todo.done_on = timezone.now()
     todo.save(update_fields=["done_on"])
-    return redirect("admin:index")
+    return redirect(redirect_to)

nodes/admin.py

@@ -9,6 +9,7 @@ from django.db.models import Count
 from django.conf import settings
 from pathlib import Path
 from django.http import HttpResponse
+from django.utils.translation import gettext_lazy as _
 import base64
 import pyperclip
 from pyperclip import PyperclipException
@@ -114,6 +115,9 @@ class NodeAdmin(EntityModelAdmin):
 
         token = uuid.uuid4().hex
         context = {
+            **self.admin_site.each_context(request),
+            "opts": self.model._meta,
+            "title": _("Register Visitor Node"),
             "token": token,
             "info_url": reverse("node-info"),
             "register_url": reverse("register-node"),
@@ -280,9 +284,6 @@ class EmailOutboxAdmin(EntityModelAdmin):
             self.message_user(request, str(exc), messages.ERROR)
         return redirect("..")
 
-    def get_model_perms(self, request):  # pragma: no cover - hide from index
-        return {}
-
     def changeform_view(self, request, object_id=None, form_url="", extra_context=None):
         extra_context = extra_context or {}
         if object_id:
@@ -430,7 +431,14 @@ class ContentSampleAdmin(EntityModelAdmin):
 
 @admin.register(NetMessage)
 class NetMessageAdmin(EntityModelAdmin):
-    list_display = ("subject", "body", "reach", "created", "complete")
+    list_display = (
+        "subject",
+        "body",
+        "reach",
+        "node_origin",
+        "created",
+        "complete",
+    )
     search_fields = ("subject", "body")
     list_filter = ("complete", "reach")
     ordering = ("-created",)

nodes/backends.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+import random
+from collections import defaultdict
+
 from django.core.mail.backends.base import BaseEmailBackend
 from django.core.mail import get_connection
 from django.conf import settings
@@ -13,41 +16,130 @@ class OutboxEmailBackend(BaseEmailBackend):
 
     If a matching outbox exists for the message's ``from_email`` (matching
     either ``from_email`` or ``username``), that outbox's SMTP credentials are
-    used. Otherwise, the first available outbox is used. When no outboxes are
-    configured, the system falls back to Django's default SMTP settings.
+    used. ``EmailOutbox`` associations to ``node``, ``user`` and ``group`` are
+    also considered and preferred when multiple criteria match. When no
+    outboxes are configured, the system falls back to Django's default SMTP
+    settings.
     """
 
-    def _select_outbox(self, from_email: str | None) -> EmailOutbox | None:
+    def _resolve_identifier(self, message, attr: str):
+        value = getattr(message, attr, None)
+        if value is None:
+            value = getattr(message, f"{attr}_id", None)
+        if value is None:
+            return None
+        return getattr(value, "pk", value)
+
+    def _select_outbox(
+        self, message
+    ) -> tuple[EmailOutbox | None, list[EmailOutbox]]:
+        from_email = getattr(message, "from_email", None)
+        node_id = self._resolve_identifier(message, "node")
+        user_id = self._resolve_identifier(message, "user")
+        group_id = self._resolve_identifier(message, "group")
+
+        match_sets: list[tuple[str, list[EmailOutbox]]] = []
+
         if from_email:
-            return (
+            email_matches = list(
                 EmailOutbox.objects.filter(
                     Q(from_email__iexact=from_email) | Q(username__iexact=from_email)
-                ).first()
-                or EmailOutbox.objects.first()
+                )
             )
-        return EmailOutbox.objects.first()
+            if email_matches:
+                match_sets.append(("from_email", email_matches))
+
+        if node_id:
+            node_matches = list(EmailOutbox.objects.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))
+            if user_matches:
+                match_sets.append(("user", user_matches))
+
+        if group_id:
+            group_matches = list(EmailOutbox.objects.filter(group_id=group_id))
+            if group_matches:
+                match_sets.append(("group", group_matches))
+
+        if not match_sets:
+            return EmailOutbox.objects.first(), []
+
+        candidates: dict[int, EmailOutbox] = {}
+        scores: defaultdict[int, int] = defaultdict(int)
+
+        for _, matches in match_sets:
+            for outbox in matches:
+                candidates[outbox.pk] = outbox
+                scores[outbox.pk] += 1
+
+        if not candidates:
+            return EmailOutbox.objects.first(), []
+
+        selected: EmailOutbox | None = None
+        fallbacks: list[EmailOutbox] = []
+
+        for score in sorted(set(scores.values()), reverse=True):
+            group = [candidates[pk] for pk, value in scores.items() if value == score]
+            if len(group) > 1:
+                random.shuffle(group)
+            if selected is None:
+                selected = group[0]
+                fallbacks.extend(group[1:])
+            else:
+                fallbacks.extend(group)
+
+        return selected, fallbacks
 
     def send_messages(self, email_messages):
         sent = 0
         for message in email_messages:
-            outbox = self._select_outbox(message.from_email)
+            original_from_email = message.from_email
+            outbox, fallbacks = self._select_outbox(message)
+            tried_outboxes = []
             if outbox:
-                connection = outbox.get_connection()
-                if not message.from_email:
+                tried_outboxes.append(outbox)
+            tried_outboxes.extend(fallbacks)
+
+            last_error: Exception | None = None
+
+            if tried_outboxes:
+                for candidate in tried_outboxes:
+                    connection = candidate.get_connection()
                     message.from_email = (
-                        outbox.from_email or settings.DEFAULT_FROM_EMAIL
+                        original_from_email
+                        or candidate.from_email
+                        or settings.DEFAULT_FROM_EMAIL
                     )
+                    try:
+                        sent += connection.send_messages([message]) or 0
+                        last_error = None
+                        break
+                    except Exception as exc:  # pragma: no cover - retry on error
+                        last_error = exc
+                    finally:
+                        try:
+                            connection.close()
+                        except Exception:  # pragma: no cover - close errors shouldn't fail send
+                            pass
+                if last_error is not None:
+                    message.from_email = original_from_email
+                    raise last_error
             else:
                 connection = get_connection(
                     "django.core.mail.backends.smtp.EmailBackend"
                 )
                 if not message.from_email:
                     message.from_email = settings.DEFAULT_FROM_EMAIL
-            try:
-                sent += connection.send_messages([message]) or 0
-            finally:
                 try:
-                    connection.close()
-                except Exception:  # pragma: no cover - close errors shouldn't fail send
-                    pass
+                    sent += connection.send_messages([message]) or 0
+                finally:
+                    try:
+                        connection.close()
+                    except Exception:  # pragma: no cover - close errors shouldn't fail send
+                        pass
+
+            message.from_email = original_from_email
         return sent