arthexis 0.1.21__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,59 @@ 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"
@@ -790,6 +845,16 @@ class NodeInfoViewTests(TestCase):
         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):
@@ -1651,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):
@@ -1726,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",
@@ -1737,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"])
@@ -3412,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

@@ -320,6 +320,7 @@ def node_info(request):
         "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

@@ -112,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",
@@ -132,6 +139,8 @@ class ChargerConfigurationAdmin(admin.ModelAdmin):
                 "fields": (
                     "charger_identifier",
                     "connector_id",
+                    "origin_display",
+                    "evcs_snapshot_at",
                     "linked_chargers",
                     "created_at",
                     "updated_at",
@@ -185,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):

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")
@@ -663,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,
@@ -1023,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"],

ocpp/tasks.py

@@ -1,7 +1,10 @@
+import json
 import logging
+import uuid
 from datetime import date, datetime, time, timedelta
 from pathlib import Path
 
+from asgiref.sync import async_to_sync
 from celery import shared_task
 from django.conf import settings
 from django.contrib.auth import get_user_model
@@ -11,11 +14,106 @@ from django.db.models import Q
 from core import mailer
 from nodes.models import Node
 
-from .models import MeterValue, Transaction
+from . import store
+from .models import Charger, MeterValue, Transaction
 
 logger = logging.getLogger(__name__)
 
 
+@shared_task
+def check_charge_point_configuration(charger_pk: int) -> bool:
+    """Request the latest configuration from a connected charge point."""
+
+    try:
+        charger = Charger.objects.get(pk=charger_pk)
+    except Charger.DoesNotExist:
+        logger.warning(
+            "Unable to request configuration for missing charger %s",
+            charger_pk,
+        )
+        return False
+
+    connector_value = charger.connector_id
+    if connector_value is not None:
+        logger.debug(
+            "Skipping charger %s: connector %s is not eligible for automatic configuration checks",
+            charger.charger_id,
+            connector_value,
+        )
+        return False
+
+    ws = store.get_connection(charger.charger_id, connector_value)
+    if ws is None:
+        logger.info(
+            "Charge point %s is not connected; configuration request skipped",
+            charger.charger_id,
+        )
+        return False
+
+    message_id = uuid.uuid4().hex
+    payload: dict[str, object] = {}
+    msg = json.dumps([2, message_id, "GetConfiguration", payload])
+
+    try:
+        async_to_sync(ws.send)(msg)
+    except Exception as exc:  # pragma: no cover - network error
+        logger.warning(
+            "Failed to send GetConfiguration to %s (%s)",
+            charger.charger_id,
+            exc,
+        )
+        return False
+
+    log_key = store.identity_key(charger.charger_id, connector_value)
+    store.add_log(log_key, f"< {msg}", log_type="charger")
+    store.register_pending_call(
+        message_id,
+        {
+            "action": "GetConfiguration",
+            "charger_id": charger.charger_id,
+            "connector_id": connector_value,
+            "log_key": log_key,
+            "requested_at": timezone.now(),
+        },
+    )
+    store.schedule_call_timeout(
+        message_id,
+        timeout=5.0,
+        action="GetConfiguration",
+        log_key=log_key,
+        message=(
+            "GetConfiguration timed out: charger did not respond"
+            " (operation may not be supported)"
+        ),
+    )
+    logger.info(
+        "Requested configuration from charge point %s",
+        charger.charger_id,
+    )
+    return True
+
+
+@shared_task
+def schedule_daily_charge_point_configuration_checks() -> int:
+    """Dispatch configuration requests for eligible charge points."""
+
+    charger_ids = list(
+        Charger.objects.filter(connector_id__isnull=True).values_list("pk", flat=True)
+    )
+    if not charger_ids:
+        logger.debug("No eligible charge points available for configuration check")
+        return 0
+
+    scheduled = 0
+    for charger_pk in charger_ids:
+        check_charge_point_configuration.delay(charger_pk)
+        scheduled += 1
+    logger.info(
+        "Scheduled configuration checks for %s charge point(s)", scheduled
+    )
+    return scheduled
+
+
 @shared_task
 def purge_meter_values() -> int:
     """Delete meter values older than 7 days.