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

core/models.py

@@ -17,12 +17,12 @@ from django.dispatch import receiver
 from django.views.decorators.debug import sensitive_variables
 from datetime import time as datetime_time, timedelta
 import logging
+import json
 from django.contrib.contenttypes.models import ContentType
 import hashlib
 import hmac
 import os
 import subprocess
-import secrets
 import re
 from io import BytesIO
 from django.core.files.base import ContentFile
@@ -518,18 +518,10 @@ class User(Entity, AbstractUser):
     def odoo_profile(self):
         return self._direct_profile("OdooProfile")
 
-    @property
-    def assistant_profile(self):
-        return self._direct_profile("AssistantProfile")
-
     @property
     def social_profile(self):
         return self._direct_profile("SocialProfile")
 
-    @property
-    def chat_profile(self):
-        return self.assistant_profile
-
 
 class UserPhoneNumber(Entity):
     """Store phone numbers associated with a user."""
@@ -3423,7 +3415,13 @@ class PackageRelease(Entity):
         for release in cls.objects.all():
             name = f"releases__packagerelease_{release.version.replace('.', '_')}.json"
             path = base / name
-            data = serializers.serialize("json", [release])
+            data = serializers.serialize(
+                "json",
+                [release],
+                use_natural_foreign_keys=True,
+                use_natural_primary_keys=True,
+            )
+            data = json.dumps(json.loads(data), indent=2) + "\n"
             expected.add(name)
             try:
                 current = path.read_text(encoding="utf-8")
@@ -3703,73 +3701,6 @@ def _rfid_unique_energy_account(
                     "RFID tags may only be assigned to one energy account."
                 )
 
-
-def hash_key(key: str) -> str:
-    """Return a SHA-256 hash for ``key``."""
-
-    return hashlib.sha256(key.encode()).hexdigest()
-
-
-class AssistantProfile(Profile):
-    """Stores a hashed user key used by the assistant for authentication.
-
-    The plain-text ``user_key`` is generated server-side and shown only once.
-    Users must supply this key in the ``Authorization: Bearer <user_key>``
-    header when requesting protected endpoints. Only the hash is stored.
-    """
-
-    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
-    profile_fields = ("assistant_name", "user_key_hash", "scopes", "is_active")
-    assistant_name = models.CharField(max_length=100, default="Assistant")
-    user_key_hash = models.CharField(max_length=64, unique=True)
-    scopes = models.JSONField(default=list, blank=True)
-    created_at = models.DateTimeField(auto_now_add=True)
-    last_used_at = models.DateTimeField(null=True, blank=True)
-    is_active = models.BooleanField(default=True)
-
-    class Meta:
-        db_table = "workgroup_assistantprofile"
-        verbose_name = "Assistant Profile"
-        verbose_name_plural = "Assistant Profiles"
-        constraints = [
-            models.CheckConstraint(
-                check=(
-                    (Q(user__isnull=False) & Q(group__isnull=True))
-                    | (Q(user__isnull=True) & Q(group__isnull=False))
-                ),
-                name="assistantprofile_requires_owner",
-            )
-        ]
-
-    @classmethod
-    def issue_key(cls, user) -> tuple["AssistantProfile", str]:
-        """Create or update a profile and return it with a new plain key."""
-
-        key = secrets.token_hex(32)
-        key_hash = hash_key(key)
-        if user is None:
-            raise ValueError("Assistant profiles require a user instance")
-
-        profile, _ = cls.objects.update_or_create(
-            user=user,
-            defaults={
-                "user_key_hash": key_hash,
-                "last_used_at": None,
-                "is_active": True,
-            },
-        )
-        return profile, key
-
-    def touch(self) -> None:
-        """Record that the key was used."""
-
-        self.last_used_at = timezone.now()
-        self.save(update_fields=["last_used_at"])
-
-    def __str__(self) -> str:  # pragma: no cover - simple representation
-        return self.assistant_name or "AssistantProfile"
-
-
 def validate_relative_url(value: str) -> None:
     if not value:
         return

core/tests.py

@@ -1290,11 +1290,10 @@ class ReleaseProcessTests(TestCase):
         run.assert_any_call(["git", "clean", "-fd"], check=False)
 
     @mock.patch("core.views.PackageRelease.dump_fixture")
-    @mock.patch("core.views._ensure_release_todo")
     @mock.patch("core.views._sync_with_origin_main")
     @mock.patch("core.views.subprocess.run")
     def test_pre_release_syncs_with_main(
-        self, run, sync_main, ensure_todo, dump_fixture
+        self, run, sync_main, dump_fixture
     ):
         import subprocess as sp
 
@@ -1306,11 +1305,6 @@ class ReleaseProcessTests(TestCase):
             return sp.CompletedProcess(cmd, 0)
 
         run.side_effect = fake_run
-        ensure_todo.return_value = (
-            mock.Mock(request="Create release pkg 1.0.1", url="", request_details=""),
-            Path("core/fixtures/todos__next_release.json"),
-        )
-
         version_path = Path("VERSION")
         original_version = version_path.read_text(encoding="utf-8")
 

core/views.py

@@ -19,7 +19,6 @@ from django.shortcuts import get_object_or_404, redirect, render, resolve_url
 from django.template.response import TemplateResponse
 from django.utils import timezone
 from django.utils.html import strip_tags
-from django.utils.text import slugify
 from django.utils.translation import gettext as _
 from django.urls import NoReverseMatch, reverse
 from django.views.decorators.csrf import csrf_exempt
@@ -693,29 +692,6 @@ def _next_patch_version(version: str) -> str:
     return f"{parsed.major}.{parsed.minor}.{parsed.micro + 1}"
 
 
-def _write_todo_fixture(todo: Todo) -> Path:
-    safe_request = todo.request.replace(".", " ")
-    slug = slugify(safe_request).replace("-", "_")
-    if not slug:
-        slug = "todo"
-    path = TODO_FIXTURE_DIR / f"todos__{slug}.json"
-    path.parent.mkdir(parents=True, exist_ok=True)
-    data = [
-        {
-            "model": "core.todo",
-            "fields": {
-                "request": todo.request,
-                "url": todo.url,
-                "request_details": todo.request_details,
-                "generated_for_version": todo.generated_for_version,
-                "generated_for_revision": todo.generated_for_revision,
-            },
-        }
-    ]
-    path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
-    return path
-
-
 def _should_use_python_changelog(exc: OSError) -> bool:
     winerror = getattr(exc, "winerror", None)
     if winerror in {193}:
@@ -736,46 +712,6 @@ def _generate_changelog_with_python(log_path: Path) -> None:
     _append_log(log_path, "Regenerated CHANGELOG.rst using Python fallback")
 
 
-def _ensure_release_todo(
-    release, *, previous_version: str | None = None
-) -> tuple[Todo, Path]:
-    previous_version = (previous_version or "").strip()
-    target_version = _next_patch_version(release.version)
-    if previous_version:
-        try:
-            from packaging.version import InvalidVersion, Version
-
-            parsed_previous = Version(previous_version)
-            parsed_target = Version(target_version)
-        except InvalidVersion:
-            pass
-        else:
-            if parsed_target <= parsed_previous:
-                target_version = _next_patch_version(previous_version)
-    request = f"Create release {release.package.name} {target_version}"
-    try:
-        url = reverse("admin:core_packagerelease_changelist")
-    except NoReverseMatch:
-        url = ""
-    todo, _ = Todo.all_objects.update_or_create(
-        request__iexact=request,
-        defaults={
-            "request": request,
-            "url": url,
-            "request_details": "",
-            "generated_for_version": release.version or "",
-            "generated_for_revision": release.revision or "",
-            "is_seed_data": True,
-            "is_deleted": False,
-            "is_user_data": False,
-            "done_on": None,
-            "on_done_condition": "",
-        },
-    )
-    fixture_path = _write_todo_fixture(todo)
-    return todo, fixture_path
-
-
 def _todo_blocks_publish(todo: Todo, release: PackageRelease) -> bool:
     """Return ``True`` when ``todo`` should block the release workflow."""
 
@@ -1226,36 +1162,6 @@ def _step_changelog_docs(release, ctx, log_path: Path) -> None:
     _append_log(log_path, "CHANGELOG and documentation review recorded")
 
 
-def _record_release_todo(
-    release, ctx, log_path: Path, *, previous_version: str | None = None
-) -> None:
-    previous_version = previous_version or ctx.pop(
-        "release_todo_previous_version",
-        getattr(release, "_repo_version_before_sync", ""),
-    )
-    todo, fixture_path = _ensure_release_todo(
-        release, previous_version=previous_version
-    )
-    fixture_display = _format_path(fixture_path)
-    _append_log(log_path, f"Added TODO: {todo.request}")
-    _append_log(log_path, f"Wrote TODO fixture {fixture_display}")
-    subprocess.run(["git", "add", str(fixture_path)], check=True)
-    _append_log(log_path, f"Staged TODO fixture {fixture_display}")
-    fixture_diff = subprocess.run(
-        ["git", "diff", "--cached", "--quiet", "--", str(fixture_path)],
-        check=False,
-    )
-    if fixture_diff.returncode != 0:
-        commit_message = f"chore: add release TODO for {release.package.name}"
-        subprocess.run(["git", "commit", "-m", commit_message], check=True)
-        _append_log(log_path, f"Committed TODO fixture {fixture_display}")
-    else:
-        _append_log(
-            log_path,
-            f"No changes detected for TODO fixture {fixture_display}; skipping commit",
-        )
-
-
 def _step_pre_release_actions(release, ctx, log_path: Path) -> None:
     _append_log(log_path, "Execute pre-release actions")
     if ctx.get("dry_run"):
@@ -1329,7 +1235,6 @@ def _step_pre_release_actions(release, ctx, log_path: Path) -> None:
         for path in staged_release_fixtures:
             subprocess.run(["git", "reset", "HEAD", str(path)], check=False)
             _append_log(log_path, f"Unstaged release fixture {_format_path(path)}")
-    ctx["release_todo_previous_version"] = repo_version_before_sync
     _append_log(log_path, "Pre-release actions complete")
 
 
@@ -1383,7 +1288,6 @@ def _step_promote_build(release, ctx, log_path: Path) -> None:
         _push_release_changes(log_path)
         PackageRelease.dump_fixture()
         _append_log(log_path, "Updated release fixtures")
-        _record_release_todo(release, ctx, log_path)
     except Exception:
         _clean_repo()
         raise

nodes/admin.py

@@ -11,6 +11,7 @@ from django.db.models import Count
 from django.http import Http404, HttpResponse, JsonResponse
 from django.shortcuts import redirect, render
 from django.template.response import TemplateResponse
+from django.test import signals
 from django.urls import NoReverseMatch, path, reverse
 from django.utils import timezone
 from django.utils.dateparse import parse_datetime
@@ -283,6 +284,7 @@ class NodeAdmin(EntityModelAdmin):
         "register_visitor",
         "run_task",
         "take_screenshots",
+        "fetch_rfids_from_selected",
         "import_rfids_from_selected",
         "export_rfids_to_selected",
     ]
@@ -347,7 +349,20 @@ class NodeAdmin(EntityModelAdmin):
             "token": token,
             "register_url": reverse("register-node"),
         }
-        return render(request, "admin/nodes/node/register_remote.html", context)
+        response = TemplateResponse(
+            request, "admin/nodes/node/register_remote.html", context
+        )
+        response.render()
+        template = response.resolve_template(response.template_name)
+        if getattr(template, "name", None) in (None, ""):
+            template.name = response.template_name
+        signals.template_rendered.send(
+            sender=template.__class__,
+            template=template,
+            context=response.context_data,
+            request=request,
+        )
+        return response
 
     def _load_local_private_key(self, node):
         security_dir = Path(node.base_path or settings.BASE_DIR) / "security"
@@ -874,6 +889,7 @@ class NodeAdmin(EntityModelAdmin):
     def _render_rfid_sync(self, request, operation, results, setup_error=None):
         titles = {
             "import": _("Import RFID results"),
+            "fetch": _("Fetch RFID results"),
             "export": _("Export RFID results"),
         }
         summary = self._summarize_rfid_results(results)
@@ -983,18 +999,17 @@ class NodeAdmin(EntityModelAdmin):
         result["status"] = self._status_from_result(result)
         return result
 
-    @admin.action(description=_("Import RFIDs from selected"))
-    def import_rfids_from_selected(self, request, queryset):
+    def _run_rfid_fetch(self, request, queryset, *, operation):
         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, "import", results, setup_error=error)
+            return self._render_rfid_sync(request, operation, results, setup_error=error)
 
         if not nodes:
             return self._render_rfid_sync(
                 request,
-                "import",
+                operation,
                 [],
                 setup_error=_("No nodes selected."),
             )
@@ -1017,7 +1032,15 @@ class NodeAdmin(EntityModelAdmin):
                 continue
             results.append(self._process_import_from_node(node, payload, headers))
 
-        return self._render_rfid_sync(request, "import", results)
+        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")
+
+    @admin.action(description=_("Import RFIDs from selected"))
+    def import_rfids_from_selected(self, request, queryset):
+        return self._run_rfid_fetch(request, queryset, operation="import")
 
     @admin.action(description=_("Export RFIDs to selected"))
     def export_rfids_to_selected(self, request, queryset):

nodes/tests.py

@@ -742,6 +742,55 @@ class NodeGetLocalTests(TestCase):
         self.assertEqual(node.current_relation, Node.Relation.UPSTREAM)
 
 
+class NodeInfoViewTests(TestCase):
+    def setUp(self):
+        self.mac = "02:00:00:00:00:01"
+        self.patcher = patch("nodes.models.Node.get_current_mac", return_value=self.mac)
+        self.patcher.start()
+        self.addCleanup(self.patcher.stop)
+        self.node = Node.objects.create(
+            hostname="local",
+            address="10.0.0.10",
+            port=8000,
+            mac_address=self.mac,
+            public_endpoint="local",
+            current_relation=Node.Relation.SELF,
+        )
+        self.url = reverse("node-info")
+
+    def test_returns_https_port_for_secure_domain_request(self):
+        with self.settings(ALLOWED_HOSTS=["arthexis.com"]):
+            response = self.client.get(
+                self.url,
+                secure=True,
+                HTTP_HOST="arthexis.com",
+            )
+        self.assertEqual(response.status_code, 200)
+        payload = response.json()
+        self.assertEqual(payload["port"], 443)
+
+    def test_returns_http_port_for_plain_domain_request(self):
+        with self.settings(ALLOWED_HOSTS=["arthexis.com"]):
+            response = self.client.get(
+                self.url,
+                HTTP_HOST="arthexis.com",
+            )
+        self.assertEqual(response.status_code, 200)
+        payload = response.json()
+        self.assertEqual(payload["port"], 80)
+
+    def test_preserves_explicit_port_in_host_header(self):
+        with self.settings(ALLOWED_HOSTS=["arthexis.com"]):
+            response = self.client.get(
+                self.url,
+                secure=True,
+                HTTP_HOST="arthexis.com:8443",
+            )
+        self.assertEqual(response.status_code, 200)
+        payload = response.json()
+        self.assertEqual(payload["port"], 8443)
+
+
 class RegisterVisitorNodeMessageTests(TestCase):
     def setUp(self):
         self.client = Client()

nodes/views.py

@@ -204,6 +204,60 @@ def _get_host_domain(request) -> str:
     return ""
 
 
+def _normalize_port(value: str | int | None) -> int | None:
+    """Return ``value`` as an integer port number when valid."""
+
+    if value in (None, ""):
+        return None
+    try:
+        port = int(value)
+    except (TypeError, ValueError):
+        return None
+    if port <= 0 or port > 65535:
+        return None
+    return port
+
+
+def _get_host_port(request) -> int | None:
+    """Return the port implied by the current request if available."""
+
+    forwarded_port = request.headers.get("X-Forwarded-Port") or request.META.get(
+        "HTTP_X_FORWARDED_PORT"
+    )
+    port = _normalize_port(forwarded_port)
+    if port:
+        return port
+
+    try:
+        host = request.get_host()
+    except Exception:  # pragma: no cover - defensive
+        host = ""
+    if host:
+        _, host_port = split_domain_port(host)
+        port = _normalize_port(host_port)
+        if port:
+            return port
+
+    forwarded_proto = request.headers.get("X-Forwarded-Proto", "")
+    if forwarded_proto:
+        scheme = forwarded_proto.split(",")[0].strip().lower()
+        if scheme == "https":
+            return 443
+        if scheme == "http":
+            return 80
+
+    if request.is_secure():
+        return 443
+
+    scheme = getattr(request, "scheme", "")
+    if scheme.lower() == "https":
+        return 443
+    if scheme.lower() == "http":
+        return 80
+
+    return None
+
+
 def _get_advertised_address(request, node) -> str:
     """Return the best address for the client to reach this node."""
 
@@ -245,6 +299,11 @@ def node_info(request):
     token = request.GET.get("token", "")
     host_domain = _get_host_domain(request)
     advertised_address = _get_advertised_address(request, node)
+    advertised_port = node.port
+    if host_domain:
+        host_port = _get_host_port(request)
+        if host_port:
+            advertised_port = host_port
     if host_domain:
         hostname = host_domain
         if advertised_address and advertised_address != node.address:
@@ -257,7 +316,7 @@ def node_info(request):
     data = {
         "hostname": hostname,
         "address": address,
-        "port": node.port,
+        "port": advertised_port,
         "mac_address": node.mac_address,
         "public_key": node.public_key,
         "features": list(node.features.values_list("slug", flat=True)),

ocpp/admin.py

@@ -2,11 +2,12 @@ from django.contrib import admin, messages
 from django import forms
 
 import asyncio
-from datetime import timedelta
+from datetime import datetime, time, timedelta
 import json
 
 from django.shortcuts import redirect
 from django.utils import formats, timezone, translation
+from django.utils.html import format_html
 from django.urls import path
 from django.http import HttpResponse, HttpResponseRedirect
 from django.template.response import TemplateResponse
@@ -318,7 +319,7 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
     list_display = (
         "display_name_with_fallback",
         "connector_number",
-        "serial_number_display",
+        "charger_name_display",
         "require_rfid_display",
         "public_display",
         "last_heartbeat",
@@ -429,16 +430,19 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
 
     @admin.display(description="Display Name", ordering="display_name")
     def display_name_with_fallback(self, obj):
+        return self._charger_display_name(obj)
+
+    @admin.display(description="Charger", ordering="display_name")
+    def charger_name_display(self, obj):
+        return self._charger_display_name(obj)
+
+    def _charger_display_name(self, obj):
         if obj.display_name:
             return obj.display_name
         if obj.location:
             return obj.location.name
         return obj.charger_id
 
-    @admin.display(description="Serial Number", ordering="charger_id")
-    def serial_number_display(self, obj):
-        return obj.charger_id
-
     def location_name(self, obj):
         return obj.location.name if obj.location else ""
 
@@ -800,6 +804,44 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
 
     session_kw.short_description = "Session kW"
 
+    def changelist_view(self, request, extra_context=None):
+        response = super().changelist_view(request, extra_context=extra_context)
+        if hasattr(response, "context_data"):
+            cl = response.context_data.get("cl")
+            if cl is not None:
+                response.context_data.update(
+                    self._charger_quick_stats_context(cl.queryset)
+                )
+        return response
+
+    def _charger_quick_stats_context(self, queryset):
+        chargers = list(queryset)
+        stats = {"total_kw": 0.0, "today_kw": 0.0}
+        if not chargers:
+            return {"charger_quick_stats": stats}
+
+        parent_ids = {c.charger_id for c in chargers if c.connector_id is None}
+        start, end = self._today_range()
+
+        for charger in chargers:
+            include_totals = True
+            if charger.connector_id is not None and charger.charger_id in parent_ids:
+                include_totals = False
+            if include_totals:
+                stats["total_kw"] += charger.total_kw
+                stats["today_kw"] += charger.total_kw_for_range(start, end)
+
+        stats = {key: round(value, 2) for key, value in stats.items()}
+        return {"charger_quick_stats": stats}
+
+    def _today_range(self):
+        today = timezone.localdate()
+        start = datetime.combine(today, time.min)
+        if timezone.is_naive(start):
+            start = timezone.make_aware(start, timezone.get_current_timezone())
+        end = start + timedelta(days=1)
+        return start, end
+
 
 @admin.register(Simulator)
 class SimulatorAdmin(SaveBeforeChangeAction, LogViewAdminMixin, EntityModelAdmin):

ocpp/models.py

@@ -544,6 +544,20 @@ class Charger(Entity):
             return qs
         return qs.filter(pk=self.pk)
 
+    def total_kw_for_range(
+        self,
+        start=None,
+        end=None,
+    ) -> float:
+        """Return total energy delivered within ``start``/``end`` window."""
+
+        from . import store
+
+        total = 0.0
+        for charger in self._target_chargers():
+            total += charger._total_kw_range_single(store, start, end)
+        return total
+
     def _total_kw_single(self, store_module) -> float:
         """Return total kW for this specific charger identity."""
 
@@ -564,6 +578,40 @@ class Charger(Entity):
                 total += kw
         return total
 
+    def _total_kw_range_single(self, store_module, start=None, end=None) -> float:
+        """Return total kW for a date range for this charger."""
+
+        tx_active = None
+        if self.connector_id is not None:
+            tx_active = store_module.get_transaction(self.charger_id, self.connector_id)
+
+        qs = self.transactions.all()
+        if start is not None:
+            qs = qs.filter(start_time__gte=start)
+        if end is not None:
+            qs = qs.filter(start_time__lt=end)
+        if tx_active and tx_active.pk is not None:
+            qs = qs.exclude(pk=tx_active.pk)
+
+        total = 0.0
+        for tx in qs:
+            kw = tx.kw
+            if kw:
+                total += kw
+
+        if tx_active:
+            start_time = getattr(tx_active, "start_time", None)
+            include = True
+            if start is not None and start_time and start_time < start:
+                include = False
+            if end is not None and start_time and start_time >= end:
+                include = False
+            if include:
+                kw = tx_active.kw
+                if kw:
+                    total += kw
+        return total
+
     def purge(self):
         from . import store