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

nodes/tests.py

@@ -48,6 +48,7 @@ from .classifiers import run_default_classifiers
 from .utils import capture_rpi_snapshot, capture_screenshot, save_screenshot
 from django.db.utils import DatabaseError
 
+from .admin import NodeAdmin
 from .models import (
     Node,
     EmailOutbox,
@@ -67,7 +68,8 @@ from .backends import OutboxEmailBackend
 from .tasks import capture_node_screenshot, poll_unreachable_upstream, sample_clipboard
 from cryptography.hazmat.primitives.asymmetric import rsa, padding
 from cryptography.hazmat.primitives import serialization, hashes
-from core.models import Package, PackageRelease, SecurityGroup, RFID, EnergyAccount
+from core.models import Package, PackageRelease, SecurityGroup, RFID, EnergyAccount, Todo
+from requests.exceptions import SSLError
 
 
 class NodeBadgeColorTests(TestCase):
@@ -742,6 +744,118 @@ class NodeGetLocalTests(TestCase):
         self.assertEqual(node.current_relation, Node.Relation.UPSTREAM)
 
 
+class NodeEnsureKeysTests(TestCase):
+    def setUp(self):
+        self.tempdir = TemporaryDirectory()
+        self.base = Path(self.tempdir.name)
+        self.override = override_settings(BASE_DIR=self.base)
+        self.override.enable()
+        self.node = Node.objects.create(
+            hostname="ensure-host",
+            address="127.0.0.1",
+            port=8000,
+            mac_address="00:11:22:33:44:55",
+        )
+
+    def tearDown(self):
+        self.override.disable()
+        self.tempdir.cleanup()
+
+    def test_regenerates_missing_keys(self):
+        self.node.ensure_keys()
+        security_dir = self.base / "security"
+        priv_path = security_dir / self.node.public_endpoint
+        pub_path = security_dir / f"{self.node.public_endpoint}.pub"
+        original_public = self.node.public_key
+        priv_path.unlink()
+        pub_path.unlink()
+
+        self.node.ensure_keys()
+
+        self.assertTrue(priv_path.exists())
+        self.assertTrue(pub_path.exists())
+        self.assertNotEqual(self.node.public_key, original_public)
+
+    def test_regenerates_outdated_keys(self):
+        self.node.ensure_keys()
+        security_dir = self.base / "security"
+        priv_path = security_dir / self.node.public_endpoint
+        pub_path = security_dir / f"{self.node.public_endpoint}.pub"
+        original_private = priv_path.read_bytes()
+        original_public = pub_path.read_bytes()
+
+        old_time = (timezone.now() - timedelta(seconds=5)).timestamp()
+        os.utime(priv_path, (old_time, old_time))
+        os.utime(pub_path, (old_time, old_time))
+
+        with override_settings(NODE_KEY_MAX_AGE=timedelta(seconds=1)):
+            self.node.ensure_keys()
+
+        self.node.refresh_from_db()
+        self.assertNotEqual(priv_path.read_bytes(), original_private)
+        self.assertNotEqual(pub_path.read_bytes(), original_public)
+        self.assertNotEqual(self.node.public_key, original_public.decode())
+
+
+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)
+
+    def test_includes_role_in_payload(self):
+        role, _ = NodeRole.objects.get_or_create(name="Terminal")
+        self.node.role = role
+        self.node.save(update_fields=["role"])
+
+        response = self.client.get(self.url)
+        self.assertEqual(response.status_code, 200)
+        payload = response.json()
+        self.assertEqual(payload.get("role"), "Terminal")
+
+
 class RegisterVisitorNodeMessageTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -1602,6 +1716,60 @@ class NodeAdminTests(TestCase):
             response, reverse("admin:nodes_node_register_current")
         )
 
+    def test_apply_remote_node_info_updates_role(self):
+        terminal, _ = NodeRole.objects.get_or_create(name="Terminal")
+        control, _ = NodeRole.objects.get_or_create(name="Control")
+        node = Node.objects.create(
+            hostname="remote-node",
+            address="10.0.0.20",
+            port=8001,
+            mac_address="00:11:22:33:44:aa",
+            role=terminal,
+        )
+        admin_instance = NodeAdmin(Node, admin.site)
+
+        payload = {
+            "hostname": node.hostname,
+            "address": node.address,
+            "port": node.port,
+            "role": "Control",
+        }
+
+        changed = admin_instance._apply_remote_node_info(node, payload)
+        node.refresh_from_db()
+
+        self.assertIn("role", changed)
+        self.assertEqual(node.role, control)
+        self.assertTrue(control.node_set.filter(pk=node.pk).exists())
+        self.assertFalse(terminal.node_set.filter(pk=node.pk).exists())
+
+    def test_apply_remote_node_info_accepts_role_name_key(self):
+        terminal, _ = NodeRole.objects.get_or_create(name="Terminal")
+        control, _ = NodeRole.objects.get_or_create(name="Control")
+        node = Node.objects.create(
+            hostname="role-name-node",
+            address="10.0.0.21",
+            port=8002,
+            mac_address="00:11:22:33:44:bb",
+            role=terminal,
+        )
+        admin_instance = NodeAdmin(Node, admin.site)
+
+        payload = {
+            "hostname": node.hostname,
+            "address": node.address,
+            "port": node.port,
+            "role_name": "Control",
+        }
+
+        changed = admin_instance._apply_remote_node_info(node, payload)
+        node.refresh_from_db()
+
+        self.assertIn("role", changed)
+        self.assertEqual(node.role, control)
+        self.assertTrue(control.node_set.filter(pk=node.pk).exists())
+        self.assertFalse(terminal.node_set.filter(pk=node.pk).exists())
+
     @pytest.mark.feature("screenshot-poll")
     @patch("nodes.admin.capture_screenshot")
     def test_capture_site_screenshot_from_admin(self, mock_capture_screenshot):
@@ -1677,6 +1845,44 @@ class NodeAdminTests(TestCase):
         payload = json.loads(mock_post.call_args[1]["data"])
         self.assertEqual(payload.get("requester"), str(local_node.uuid))
 
+    @patch("nodes.admin.requests.post")
+    def test_proxy_view_falls_back_to_http_after_ssl_error(self, mock_post):
+        self.client.get(reverse("admin:nodes_node_register_current"))
+        remote = Node.objects.create(
+            hostname="remote-https",
+            address="198.51.100.20",
+            port=443,
+            mac_address="aa:bb:cc:dd:ee:10",
+        )
+        local_node = Node.get_local()
+        success_response = SimpleNamespace(
+            ok=True,
+            json=lambda: {
+                "login_url": "http://remote.example/nodes/proxy/login/token",
+                "expires": "2025-01-01T00:00:00",
+            },
+            status_code=200,
+            text="ok",
+        )
+        mock_post.side_effect = [
+            SSLError("wrong version number"),
+            success_response,
+        ]
+
+        response = self.client.get(
+            reverse("admin:nodes_node_proxy", args=[remote.pk])
+        )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(mock_post.call_count, 2)
+        first_url = mock_post.call_args_list[0].args[0]
+        second_url = mock_post.call_args_list[1].args[0]
+        self.assertTrue(first_url.startswith("https://"))
+        self.assertTrue(second_url.startswith("http://"))
+        self.assertIn("/nodes/proxy/session/", second_url)
+        payload = json.loads(mock_post.call_args_list[-1].kwargs["data"])
+        self.assertEqual(payload.get("requester"), str(local_node.uuid))
+
     def test_proxy_link_displayed_for_remote_nodes(self):
         Node.objects.create(
             hostname="remote",
@@ -1688,6 +1894,51 @@ class NodeAdminTests(TestCase):
         proxy_url = reverse("admin:nodes_node_proxy", args=[1])
         self.assertContains(response, proxy_url)
 
+    def test_visit_link_uses_local_admin_dashboard_for_local_node(self):
+        node_admin = admin.site._registry[Node]
+        local_node = self._create_local_node()
+
+        link_html = node_admin.visit_link(local_node)
+
+        self.assertIn(reverse("admin:index"), link_html)
+        self.assertIn("target=\"_blank\"", link_html)
+
+    def test_visit_link_prefers_remote_hostname_for_dashboard(self):
+        node_admin = admin.site._registry[Node]
+        remote = Node.objects.create(
+            hostname="remote.example.com",
+            address="198.51.100.20",
+            port=8443,
+            mac_address="aa:bb:cc:dd:ee:ff",
+        )
+
+        link_html = node_admin.visit_link(remote)
+
+        self.assertIn("https://remote.example.com:8443/admin/", link_html)
+        self.assertIn("target=\"_blank\"", link_html)
+
+    def test_iter_remote_urls_handles_hostname_with_path_and_port(self):
+        node_admin = admin.site._registry[Node]
+        remote = SimpleNamespace(
+            public_endpoint="",
+            address="",
+            hostname="example.com/interface",
+            port=8443,
+        )
+
+        urls = list(node_admin._iter_remote_urls(remote, "/nodes/proxy/session/"))
+
+        self.assertIn(
+            "https://example.com:8443/interface/nodes/proxy/session/",
+            urls,
+        )
+        self.assertIn(
+            "http://example.com:8443/interface/nodes/proxy/session/",
+            urls,
+        )
+        combined = "".join(urls)
+        self.assertNotIn("interface:8443", combined)
+
 
     @pytest.mark.feature("screenshot-poll")
     @override_settings(SCREENSHOT_SOURCES=["/one", "/two"])
@@ -3363,6 +3614,17 @@ class StartupHandlerTests(TestCase):
 
         mock_start.assert_called_once()
 
+    def test_handler_skips_during_migrate_command(self):
+        import sys
+
+        from nodes.apps import _trigger_startup_notification
+
+        with patch("nodes.apps._startup_notification") as mock_start:
+            with patch.object(sys, "argv", ["manage.py", "migrate"]):
+                _trigger_startup_notification()
+
+        mock_start.assert_not_called()
+
 
 class NotificationManagerTests(TestCase):
     def test_send_writes_trimmed_lines(self):

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,10 +316,11 @@ 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)),
+        "role": node.role.name if node.role_id else "",
     }
 
     if token:

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
@@ -111,12 +112,19 @@ class LogViewAdminMixin:
 
 @admin.register(ChargerConfiguration)
 class ChargerConfigurationAdmin(admin.ModelAdmin):
-    list_display = ("charger_identifier", "connector_display", "created_at")
+    list_display = (
+        "charger_identifier",
+        "connector_display",
+        "origin_display",
+        "created_at",
+    )
     list_filter = ("connector_id",)
     search_fields = ("charger_identifier",)
     readonly_fields = (
         "charger_identifier",
         "connector_id",
+        "origin_display",
+        "evcs_snapshot_at",
         "created_at",
         "updated_at",
         "linked_chargers",
@@ -131,6 +139,8 @@ class ChargerConfigurationAdmin(admin.ModelAdmin):
                 "fields": (
                     "charger_identifier",
                     "connector_id",
+                    "origin_display",
+                    "evcs_snapshot_at",
                     "linked_chargers",
                     "created_at",
                     "updated_at",
@@ -184,6 +194,16 @@ class ChargerConfigurationAdmin(admin.ModelAdmin):
     def raw_payload_display(self, obj):
         return self._render_json(obj.raw_payload)
 
+    @admin.display(description="Origin")
+    def origin_display(self, obj):
+        if obj.evcs_snapshot_at:
+            return "EVCS"
+        return "Local"
+
+    def save_model(self, request, obj, form, change):
+        obj.evcs_snapshot_at = None
+        super().save_model(request, obj, form, change)
+
 
 @admin.register(Location)
 class LocationAdmin(EntityModelAdmin):
@@ -318,7 +338,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 +449,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 +823,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/consumers.py

@@ -791,6 +791,7 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             connector_id=connector_value,
             configuration_keys=normalized_entries,
             unknown_keys=unknown_values,
+            evcs_snapshot_at=timezone.now(),
             raw_payload=raw_payload,
         )
         Charger.objects.filter(charger_id=self.charger_id).update(

ocpp/models.py

@@ -48,6 +48,7 @@ class Charger(Entity):
     """Known charge point."""
 
     _PLACEHOLDER_SERIAL_RE = re.compile(r"^<[^>]+>$")
+    _AUTO_LOCATION_SANITIZE_RE = re.compile(r"[^0-9A-Za-z_-]+")
 
     OPERATIVE_STATUSES = {
         "Available",
@@ -324,6 +325,16 @@ class Charger(Entity):
             )
         return normalized
 
+    @classmethod
+    def sanitize_auto_location_name(cls, value: str) -> str:
+        """Return a location name containing only safe characters."""
+
+        sanitized = cls._AUTO_LOCATION_SANITIZE_RE.sub("_", value)
+        sanitized = re.sub(r"_+", "_", sanitized).strip("_")
+        if not sanitized:
+            return "Charger"
+        return sanitized
+
     AGGREGATE_CONNECTOR_SLUG = "all"
 
     def identity_tuple(self) -> tuple[str, int | None]:
@@ -459,7 +470,8 @@ class Charger(Entity):
             if existing:
                 self.location = existing.location
             else:
-                location, _ = Location.objects.get_or_create(name=self.charger_id)
+                auto_name = type(self).sanitize_auto_location_name(self.charger_id)
+                location, _ = Location.objects.get_or_create(name=auto_name)
                 self.location = location
             if update_list is not None and "location" not in update_list:
                 update_list.append("location")
@@ -544,6 +556,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 +590,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
 
@@ -615,6 +675,14 @@ class ChargerConfiguration(models.Model):
         blank=True,
         help_text=_("Keys returned in the unknownKey list."),
     )
+    evcs_snapshot_at = models.DateTimeField(
+        _("EVCS snapshot at"),
+        null=True,
+        blank=True,
+        help_text=_(
+            "Timestamp when this configuration was received from the charge point."
+        ),
+    )
     raw_payload = models.JSONField(
         default=dict,
         blank=True,
@@ -975,6 +1043,8 @@ class DataTransferMessage(models.Model):
 
     class Meta:
         ordering = ["-created_at"]
+        verbose_name = _("Data Message")
+        verbose_name_plural = _("Data Messages")
         indexes = [
             models.Index(
                 fields=["ocpp_message_id"],