arthexis 0.1.12__py3-none-any.whl → 0.1.13__py3-none-any.whl

nodes/urls.py

@@ -9,5 +9,6 @@ urlpatterns = [
     path("screenshot/", views.capture, name="node-screenshot"),
     path("net-message/", views.net_message, name="net-message"),
     path("last-message/", views.last_net_message, name="last-net-message"),
+    path("rfid/export/", views.export_rfids, name="node-rfid-export"),
     path("<slug:endpoint>/", views.public_node_endpoint, name="node-public-endpoint"),
 ]

nodes/views.py

@@ -8,6 +8,7 @@ from django.http.request import split_domain_port
 from django.views.decorators.csrf import csrf_exempt
 from django.shortcuts import get_object_or_404
 from django.conf import settings
+from django.urls import reverse
 from pathlib import Path
 from django.utils.cache import patch_vary_headers
 
@@ -16,7 +17,15 @@ from utils.api import api_login_required
 from cryptography.hazmat.primitives import serialization, hashes
 from cryptography.hazmat.primitives.asymmetric import padding
 
-from .models import Node, NetMessage, NodeRole, node_information_updated
+from core.models import RFID
+
+from .models import (
+    Node,
+    NetMessage,
+    NodeFeature,
+    NodeRole,
+    node_information_updated,
+)
 from .utils import capture_screenshot, save_screenshot
 
 
@@ -80,6 +89,25 @@ def _get_host_ip(request) -> str:
     return domain
 
 
+def _get_host_domain(request) -> str:
+    """Return the domain from the host header when it isn't an IP."""
+
+    try:
+        host = request.get_host()
+    except Exception:  # pragma: no cover - defensive
+        return ""
+    if not host:
+        return ""
+    domain, _ = split_domain_port(host)
+    if not domain:
+        return ""
+    try:
+        ipaddress.ip_address(domain)
+    except ValueError:
+        return domain
+    return ""
+
+
 def _get_advertised_address(request, node) -> str:
     """Return the best address for the client to reach this node."""
 
@@ -119,9 +147,19 @@ def node_info(request):
         node, _ = Node.register_current()
 
     token = request.GET.get("token", "")
-    address = _get_advertised_address(request, node)
+    host_domain = _get_host_domain(request)
+    advertised_address = _get_advertised_address(request, node)
+    if host_domain:
+        hostname = host_domain
+        if advertised_address and advertised_address != node.address:
+            address = advertised_address
+        else:
+            address = host_domain
+    else:
+        hostname = node.hostname
+        address = advertised_address
     data = {
-        "hostname": node.hostname,
+        "hostname": hostname,
         "address": address,
         "port": node.port,
         "mac_address": node.mac_address,
@@ -167,6 +205,33 @@ def _add_cors_headers(request, response):
     return response
 
 
+def _node_display_name(node: Node) -> str:
+    """Return a human-friendly name for ``node`` suitable for messaging."""
+
+    for attr in ("hostname", "public_endpoint", "address"):
+        value = getattr(node, attr, "") or ""
+        value = value.strip()
+        if value:
+            return value
+    identifier = getattr(node, "pk", None)
+    return str(identifier or node)
+
+
+def _announce_visitor_join(new_node: Node, relation: Node.Relation | None) -> None:
+    """Emit a network message when the visitor node links to a host."""
+
+    if relation != Node.Relation.UPSTREAM:
+        return
+
+    local_node = Node.get_local()
+    if not local_node:
+        return
+
+    visitor_name = _node_display_name(local_node)
+    host_name = _node_display_name(new_node)
+    NetMessage.broadcast(subject=f"NODE {visitor_name}", body=f"JOINS {host_name}")
+
+
 @csrf_exempt
 def register_node(request):
     """Register or update a node from POSTed JSON data."""
@@ -321,6 +386,8 @@ def register_node(request):
         request=request,
     )
 
+    _announce_visitor_join(node, relation_value)
+
     response = JsonResponse({"id": node.id})
     return _add_cors_headers(request, response)
 
@@ -340,6 +407,64 @@ def capture(request):
     return JsonResponse({"screenshot": str(path), "node": node_id})
 
 
+@csrf_exempt
+def export_rfids(request):
+    """Return serialized RFID records for authenticated peers."""
+
+    if request.method != "POST":
+        return JsonResponse({"detail": "POST required"}, status=405)
+
+    try:
+        payload = json.loads(request.body.decode() or "{}")
+    except json.JSONDecodeError:
+        return JsonResponse({"detail": "invalid json"}, status=400)
+
+    requester = payload.get("requester")
+    signature = request.headers.get("X-Signature")
+    if not requester:
+        return JsonResponse({"detail": "requester required"}, status=400)
+    if not signature:
+        return JsonResponse({"detail": "signature required"}, status=403)
+
+    node = Node.objects.filter(uuid=requester).first()
+    if not node or not node.public_key:
+        return JsonResponse({"detail": "unknown requester"}, status=403)
+
+    try:
+        public_key = serialization.load_pem_public_key(node.public_key.encode())
+        public_key.verify(
+            base64.b64decode(signature),
+            request.body,
+            padding.PKCS1v15(),
+            hashes.SHA256(),
+        )
+    except Exception:
+        return JsonResponse({"detail": "invalid signature"}, status=403)
+
+    tags = []
+    for tag in RFID.objects.all().order_by("label_id"):
+        tags.append(
+            {
+                "rfid": tag.rfid,
+                "custom_label": tag.custom_label,
+                "key_a": tag.key_a,
+                "key_b": tag.key_b,
+                "data": tag.data,
+                "key_a_verified": tag.key_a_verified,
+                "key_b_verified": tag.key_b_verified,
+                "allowed": tag.allowed,
+                "color": tag.color,
+                "kind": tag.kind,
+                "released": tag.released,
+                "last_seen_on": tag.last_seen_on.isoformat()
+                if tag.last_seen_on
+                else None,
+            }
+        )
+
+    return JsonResponse({"rfids": tags})
+
+
 @csrf_exempt
 @api_login_required
 def public_node_endpoint(request, endpoint):
@@ -409,6 +534,25 @@ def net_message(request):
     reach_role = None
     if reach_name:
         reach_role = NodeRole.objects.filter(name=reach_name).first()
+    filter_node_uuid = data.get("filter_node")
+    filter_node = None
+    if filter_node_uuid:
+        filter_node = Node.objects.filter(uuid=filter_node_uuid).first()
+    filter_feature_slug = data.get("filter_node_feature")
+    filter_feature = None
+    if filter_feature_slug:
+        filter_feature = NodeFeature.objects.filter(slug=filter_feature_slug).first()
+    filter_role_name = data.get("filter_node_role")
+    filter_role = None
+    if filter_role_name:
+        filter_role = NodeRole.objects.filter(name=filter_role_name).first()
+    filter_relation_value = data.get("filter_current_relation")
+    filter_relation = ""
+    if filter_relation_value:
+        relation = Node.normalize_relation(filter_relation_value)
+        filter_relation = relation.value if relation else ""
+    filter_installed_version = (data.get("filter_installed_version") or "")[:20]
+    filter_installed_revision = (data.get("filter_installed_revision") or "")[:40]
     seen = data.get("seen", [])
     origin_id = data.get("origin")
     origin_node = None
@@ -425,6 +569,12 @@ def net_message(request):
             "body": body[:256],
             "reach": reach_role,
             "node_origin": origin_node,
+            "filter_node": filter_node,
+            "filter_node_feature": filter_feature,
+            "filter_node_role": filter_role,
+            "filter_current_relation": filter_relation,
+            "filter_installed_version": filter_installed_version,
+            "filter_installed_revision": filter_installed_revision,
         },
     )
     if not created:
@@ -437,6 +587,18 @@ def net_message(request):
         if msg.node_origin_id is None and origin_node:
             msg.node_origin = origin_node
             update_fields.append("node_origin")
+        field_updates = {
+            "filter_node": filter_node,
+            "filter_node_feature": filter_feature,
+            "filter_node_role": filter_role,
+            "filter_current_relation": filter_relation,
+            "filter_installed_version": filter_installed_version,
+            "filter_installed_revision": filter_installed_revision,
+        }
+        for field, value in field_updates.items():
+            if getattr(msg, field) != value:
+                setattr(msg, field, value)
+                update_fields.append(field)
         msg.save(update_fields=update_fields)
     msg.propagate(seen=seen)
     return JsonResponse({"status": "propagated", "complete": msg.complete})
@@ -447,5 +609,11 @@ def last_net_message(request):
 
     msg = NetMessage.objects.order_by("-created").first()
     if not msg:
-        return JsonResponse({"subject": "", "body": ""})
-    return JsonResponse({"subject": msg.subject, "body": msg.body})
+        return JsonResponse({"subject": "", "body": "", "admin_url": ""})
+    return JsonResponse(
+        {
+            "subject": msg.subject,
+            "body": msg.body,
+            "admin_url": reverse("admin:nodes_netmessage_change", args=[msg.pk]),
+        }
+    )

ocpp/admin.py

@@ -28,6 +28,8 @@ from .transactions_io import (
     export_transactions,
     import_transactions as import_transactions_data,
 )
+from .status_display import STATUS_BADGE_MAP, ERROR_OK_VALUES
+from core.admin import SaveBeforeChangeAction
 from core.user_data import EntityModelAdmin
 
 
@@ -255,6 +257,8 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
         "change_availability_inoperative",
         "set_availability_state_operative",
         "set_availability_state_inoperative",
+        "remote_stop_transaction",
+        "reset_chargers",
         "delete_selected",
     ]
 
@@ -314,10 +318,35 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
             args=[obj.charger_id, obj.connector_slug],
         )
         label = (obj.last_status or "status").strip() or "status"
+        status_key = label.lower()
+        error_code = (obj.last_error_code or "").strip().lower()
+        if (
+            self._has_active_session(obj)
+            and error_code in ERROR_OK_VALUES
+            and (status_key not in STATUS_BADGE_MAP or status_key == "available")
+        ):
+            label = STATUS_BADGE_MAP["charging"][0]
         return format_html('<a href="{}" target="_blank">{}</a>', url, label)
 
     status_link.short_description = "Status"
 
+    def _has_active_session(self, charger: Charger) -> bool:
+        """Return whether ``charger`` currently has an active session."""
+
+        if store.get_transaction(charger.charger_id, charger.connector_id):
+            return True
+        if charger.connector_id is not None:
+            return False
+        sibling_connectors = (
+            Charger.objects.filter(charger_id=charger.charger_id)
+            .exclude(pk=charger.pk)
+            .values_list("connector_id", flat=True)
+        )
+        for connector_id in sibling_connectors:
+            if store.get_transaction(charger.charger_id, connector_id):
+                return True
+        return False
+
     def location_name(self, obj):
         return obj.location.name if obj.location else ""
 
@@ -475,6 +504,112 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
     def set_availability_state_inoperative(self, request, queryset):
         self._set_availability_state(request, queryset, "Inoperative")
 
+    @admin.action(description="Remote stop active transaction")
+    def remote_stop_transaction(self, request, queryset):
+        stopped = 0
+        for charger in queryset:
+            connector_value = charger.connector_id
+            ws = store.get_connection(charger.charger_id, connector_value)
+            if ws is None:
+                self.message_user(
+                    request,
+                    f"{charger}: no active connection",
+                    level=messages.ERROR,
+                )
+                continue
+            tx_obj = store.get_transaction(charger.charger_id, connector_value)
+            if tx_obj is None:
+                self.message_user(
+                    request,
+                    f"{charger}: no active transaction",
+                    level=messages.ERROR,
+                )
+                continue
+            message_id = uuid.uuid4().hex
+            payload = {"transactionId": tx_obj.pk}
+            msg = json.dumps([
+                2,
+                message_id,
+                "RemoteStopTransaction",
+                payload,
+            ])
+            try:
+                async_to_sync(ws.send)(msg)
+            except Exception as exc:  # pragma: no cover - network error
+                self.message_user(
+                    request,
+                    f"{charger}: failed to send RemoteStopTransaction ({exc})",
+                    level=messages.ERROR,
+                )
+                continue
+            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": "RemoteStopTransaction",
+                    "charger_id": charger.charger_id,
+                    "connector_id": connector_value,
+                    "transaction_id": tx_obj.pk,
+                    "log_key": log_key,
+                    "requested_at": timezone.now(),
+                },
+            )
+            stopped += 1
+        if stopped:
+            self.message_user(
+                request,
+                f"Sent RemoteStopTransaction to {stopped} charger(s)",
+            )
+
+    @admin.action(description="Reset charger (soft)")
+    def reset_chargers(self, request, queryset):
+        reset = 0
+        for charger in queryset:
+            connector_value = charger.connector_id
+            ws = store.get_connection(charger.charger_id, connector_value)
+            if ws is None:
+                self.message_user(
+                    request,
+                    f"{charger}: no active connection",
+                    level=messages.ERROR,
+                )
+                continue
+            message_id = uuid.uuid4().hex
+            msg = json.dumps([
+                2,
+                message_id,
+                "Reset",
+                {"type": "Soft"},
+            ])
+            try:
+                async_to_sync(ws.send)(msg)
+            except Exception as exc:  # pragma: no cover - network error
+                self.message_user(
+                    request,
+                    f"{charger}: failed to send Reset ({exc})",
+                    level=messages.ERROR,
+                )
+                continue
+            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": "Reset",
+                    "charger_id": charger.charger_id,
+                    "connector_id": connector_value,
+                    "log_key": log_key,
+                    "requested_at": timezone.now(),
+                },
+            )
+            reset += 1
+        if reset:
+            self.message_user(
+                request,
+                f"Sent Reset to {reset} charger(s)",
+            )
+
     def delete_queryset(self, request, queryset):
         for obj in queryset:
             obj.delete()
@@ -494,7 +629,7 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
 
 
 @admin.register(Simulator)
-class SimulatorAdmin(LogViewAdminMixin, EntityModelAdmin):
+class SimulatorAdmin(SaveBeforeChangeAction, LogViewAdminMixin, EntityModelAdmin):
     list_display = (
         "name",
         "cp_path",
@@ -538,6 +673,7 @@ class SimulatorAdmin(LogViewAdminMixin, EntityModelAdmin):
         ),
     )
     actions = ("start_simulator", "stop_simulator", "send_open_door")
+    change_actions = ["start_simulator_action", "stop_simulator_action"]
 
     log_type = "simulator"
 
@@ -650,6 +786,14 @@ class SimulatorAdmin(LogViewAdminMixin, EntityModelAdmin):
 
     stop_simulator.short_description = "Stop selected simulators"
 
+    def start_simulator_action(self, request, obj):
+        queryset = type(obj).objects.filter(pk=obj.pk)
+        self.start_simulator(request, queryset)
+
+    def stop_simulator_action(self, request, obj):
+        queryset = type(obj).objects.filter(pk=obj.pk)
+        self.stop_simulator(request, queryset)
+
     def log_link(self, obj):
         from django.utils.html import format_html
         from django.urls import reverse
@@ -694,7 +838,7 @@ class TransactionAdmin(EntityModelAdmin):
         "stop_time",
         "kw",
     )
-    readonly_fields = ("kw",)
+    readonly_fields = ("kw", "received_start_time", "received_stop_time")
     list_filter = ("charger", "account")
     date_hierarchy = "start_time"
     inlines = [MeterValueInline]

ocpp/consumers.py

@@ -5,6 +5,7 @@ from datetime import datetime
 import asyncio
 import inspect
 import json
+from urllib.parse import parse_qs
 from django.utils import timezone
 from core.models import EnergyAccount, Reference, RFID as CoreRFID
 from nodes.models import NetMessage
@@ -31,6 +32,18 @@ from .evcs_discovery import (
 FORWARDED_PAIR_RE = re.compile(r"for=(?:\"?)(?P<value>[^;,\"\s]+)(?:\"?)", re.IGNORECASE)
 
 
+# Query parameter keys that may contain the charge point serial. Keys are
+# matched case-insensitively and trimmed before use.
+SERIAL_QUERY_PARAM_NAMES = (
+    "cid",
+    "chargepointid",
+    "charge_point_id",
+    "chargeboxid",
+    "charge_box_id",
+    "chargerid",
+)
+
+
 def _parse_ip(value: str | None):
     """Return an :mod:`ipaddress` object for the provided value, if valid."""
 
@@ -105,6 +118,22 @@ def _resolve_client_ip(scope: dict) -> str | None:
     return fallback
 
 
+def _parse_ocpp_timestamp(value) -> datetime | None:
+    """Return an aware :class:`~datetime.datetime` for OCPP timestamps."""
+
+    if not value:
+        return None
+    if isinstance(value, datetime):
+        timestamp = value
+    else:
+        timestamp = parse_datetime(str(value))
+    if not timestamp:
+        return None
+    if timezone.is_naive(timestamp):
+        timestamp = timezone.make_aware(timestamp, timezone.get_current_timezone())
+    return timestamp
+
+
 class SinkConsumer(AsyncWebsocketConsumer):
     """Accept any message without validation."""
 
@@ -137,15 +166,53 @@ class CSMSConsumer(AsyncWebsocketConsumer):
 
     consumption_update_interval = 300
 
+    def _extract_serial_identifier(self) -> str:
+        """Return the charge point serial from the query string or path."""
+
+        self.serial_source = None
+        query_bytes = self.scope.get("query_string") or b""
+        self._raw_query_string = query_bytes.decode("utf-8", "ignore") if query_bytes else ""
+        if query_bytes:
+            try:
+                parsed = parse_qs(
+                    self._raw_query_string,
+                    keep_blank_values=False,
+                )
+            except Exception:
+                parsed = {}
+            if parsed:
+                normalized = {
+                    key.lower(): values for key, values in parsed.items() if values
+                }
+                for candidate in SERIAL_QUERY_PARAM_NAMES:
+                    values = normalized.get(candidate)
+                    if not values:
+                        continue
+                    for value in values:
+                        if not value:
+                            continue
+                        trimmed = value.strip()
+                        if trimmed:
+                            return trimmed
+                          
+        return self.scope["url_route"]["kwargs"].get("cid", "")
+
     @requires_network
     async def connect(self):
-        raw_serial = self.scope["url_route"]["kwargs"].get("cid", "")
+        raw_serial = self._extract_serial_identifier()
         try:
             self.charger_id = Charger.validate_serial(raw_serial)
         except ValidationError as exc:
             serial = Charger.normalize_serial(raw_serial)
             store_key = store.pending_key(serial)
             message = exc.messages[0] if exc.messages else "Invalid Serial Number"
+            details: list[str] = []
+            if getattr(self, "serial_source", None):
+                details.append(f"serial_source={self.serial_source}")
+            if getattr(self, "_raw_query_string", ""):
+                details.append(f"query_string={self._raw_query_string!r}")
+            if details:
+                message = f"{message} ({'; '.join(details)})"
             store.add_log(
                 store_key,
                 f"Rejected connection: {message}",
@@ -218,6 +285,37 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             ).first
         )()
 
+    async def _ensure_rfid_seen(self, id_tag: str) -> CoreRFID | None:
+        """Ensure an RFID record exists and update its last seen timestamp."""
+
+        if not id_tag:
+            return None
+
+        normalized = id_tag.upper()
+
+        def _ensure() -> CoreRFID:
+            now = timezone.now()
+            tag, created = CoreRFID.objects.get_or_create(
+                rfid=normalized,
+                defaults={"allowed": False, "last_seen_on": now},
+            )
+            if created:
+                updates = []
+                if tag.allowed:
+                    tag.allowed = False
+                    updates.append("allowed")
+                if tag.last_seen_on != now:
+                    tag.last_seen_on = now
+                    updates.append("last_seen_on")
+                if updates:
+                    tag.save(update_fields=updates)
+            else:
+                tag.last_seen_on = now
+                tag.save(update_fields=["last_seen_on"])
+            return tag
+
+        return await database_sync_to_async(_ensure)()
+
     async def _assign_connector(self, connector: int | str | None) -> None:
         """Ensure ``self.charger`` matches the provided connector id."""
         if connector in (None, "", "-"):
@@ -1133,6 +1231,12 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                     )(**update_kwargs)
                 _update_instance(self.aggregate_charger)
                 _update_instance(self.charger)
+                if connector_value is not None and status.lower() == "available":
+                    tx_obj = store.transactions.pop(self.store_key, None)
+                    if tx_obj:
+                        await self._cancel_consumption_message()
+                        store.end_session_log(self.store_key)
+                        store.stop_session_lock()
                 store.add_log(
                     self.store_key,
                     f"StatusNotification processed: {json.dumps(payload, sort_keys=True)}",
@@ -1145,7 +1249,8 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                     )
                 reply_payload = {}
             elif action == "Authorize":
-                account = await self._get_account(payload.get("idTag"))
+                id_tag = payload.get("idTag")
+                account = await self._get_account(id_tag)
                 if self.charger.require_rfid:
                     status = (
                         "Accepted"
@@ -1154,6 +1259,7 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                         else "Invalid"
                     )
                 else:
+                    await self._ensure_rfid_seen(id_tag)
                     status = "Accepted"
                 reply_payload = {"idTagInfo": {"status": status}}
             elif action == "MeterValues":
@@ -1227,9 +1333,12 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                 id_tag = payload.get("idTag")
                 account = await self._get_account(id_tag)
                 if id_tag:
-                    await database_sync_to_async(CoreRFID.objects.get_or_create)(
-                        rfid=id_tag.upper()
-                    )
+                    if self.charger.require_rfid:
+                        await database_sync_to_async(CoreRFID.objects.get_or_create)(
+                            rfid=id_tag.upper()
+                        )
+                    else:
+                        await self._ensure_rfid_seen(id_tag)
                 await self._assign_connector(payload.get("connectorId"))
                 if self.charger.require_rfid:
                     authorized = (
@@ -1239,6 +1348,8 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                 else:
                     authorized = True
                 if authorized:
+                    start_timestamp = _parse_ocpp_timestamp(payload.get("timestamp"))
+                    received_start = timezone.now()
                     tx_obj = await database_sync_to_async(Transaction.objects.create)(
                         charger=self.charger,
                         account=account,
@@ -1246,7 +1357,8 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                         vin=(payload.get("vin") or ""),
                         connector_id=payload.get("connectorId"),
                         meter_start=payload.get("meterStart"),
-                        start_time=timezone.now(),
+                        start_time=start_timestamp or received_start,
+                        received_start_time=received_start,
                     )
                     store.transactions[self.store_key] = tx_obj
                     store.start_session_log(self.store_key, tx_obj.pk)
@@ -1267,17 +1379,22 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                         Transaction.objects.filter(pk=tx_id, charger=self.charger).first
                     )()
                 if not tx_obj and tx_id is not None:
+                    received_start = timezone.now()
                     tx_obj = await database_sync_to_async(Transaction.objects.create)(
                         pk=tx_id,
                         charger=self.charger,
-                        start_time=timezone.now(),
+                        start_time=received_start,
+                        received_start_time=received_start,
                         meter_start=payload.get("meterStart")
                         or payload.get("meterStop"),
                         vin=(payload.get("vin") or ""),
                     )
                 if tx_obj:
+                    stop_timestamp = _parse_ocpp_timestamp(payload.get("timestamp"))
+                    received_stop = timezone.now()
                     tx_obj.meter_stop = payload.get("meterStop")
-                    tx_obj.stop_time = timezone.now()
+                    tx_obj.stop_time = stop_timestamp or received_stop
+                    tx_obj.received_stop_time = received_stop
                     await database_sync_to_async(tx_obj.save)()
                     await self._update_consumption_message(tx_obj.pk)
                 await self._cancel_consumption_message()