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

nodes/views.py

@@ -1,7 +1,10 @@
-import json
 import base64
+import ipaddress
+import json
+import socket
 
 from django.http import JsonResponse
+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
@@ -13,10 +16,83 @@ 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
+from .models import Node, NetMessage, NodeRole, node_information_updated
 from .utils import capture_screenshot, save_screenshot
 
 
+def _get_client_ip(request):
+    """Return the client IP from the request headers."""
+
+    forwarded_for = request.META.get("HTTP_X_FORWARDED_FOR", "")
+    if forwarded_for:
+        for value in forwarded_for.split(","):
+            candidate = value.strip()
+            if candidate:
+                return candidate
+    return request.META.get("REMOTE_ADDR", "")
+
+
+def _get_route_address(remote_ip: str, port: int) -> str:
+    """Return the local address used to reach ``remote_ip``."""
+
+    if not remote_ip:
+        return ""
+    try:
+        parsed = ipaddress.ip_address(remote_ip)
+    except ValueError:
+        return ""
+
+    try:
+        target_port = int(port)
+    except (TypeError, ValueError):
+        target_port = 1
+    if target_port <= 0 or target_port > 65535:
+        target_port = 1
+
+    family = socket.AF_INET6 if parsed.version == 6 else socket.AF_INET
+    try:
+        with socket.socket(family, socket.SOCK_DGRAM) as sock:
+            if family == socket.AF_INET6:
+                sock.connect((remote_ip, target_port, 0, 0))
+            else:
+                sock.connect((remote_ip, target_port))
+            return sock.getsockname()[0]
+    except OSError:
+        return ""
+
+
+def _get_host_ip(request) -> str:
+    """Return the IP address from the host header if available."""
+
+    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 ""
+    return domain
+
+
+def _get_advertised_address(request, node) -> str:
+    """Return the best address for the client to reach this node."""
+
+    client_ip = _get_client_ip(request)
+    route_address = _get_route_address(client_ip, node.port)
+    if route_address:
+        return route_address
+    host_ip = _get_host_ip(request)
+    if host_ip:
+        return host_ip
+    return node.address
+
+
 @api_login_required
 def node_list(request):
     """Return a JSON list of all known nodes."""
@@ -43,9 +119,10 @@ def node_info(request):
         node, _ = Node.register_current()
 
     token = request.GET.get("token", "")
+    address = _get_advertised_address(request, node)
     data = {
         "hostname": node.hostname,
-        "address": node.address,
+        "address": address,
         "port": node.port,
         "mac_address": node.mac_address,
         "public_key": node.public_key,
@@ -91,7 +168,6 @@ def _add_cors_headers(request, response):
 
 
 @csrf_exempt
-@api_login_required
 def register_node(request):
     """Register or update a node from POSTed JSON data."""
 
@@ -126,6 +202,17 @@ def register_node(request):
     public_key = data.get("public_key")
     token = data.get("token")
     signature = data.get("signature")
+    installed_version = data.get("installed_version")
+    installed_revision = data.get("installed_revision")
+    relation_present = False
+    if hasattr(data, "getlist"):
+        relation_present = "current_relation" in data
+    else:
+        relation_present = "current_relation" in data
+    raw_relation = data.get("current_relation")
+    relation_value = (
+        Node.normalize_relation(raw_relation) if relation_present else None
+    )
 
     if not hostname or not address or not mac_address:
         response = JsonResponse(
@@ -148,6 +235,10 @@ def register_node(request):
             response = JsonResponse({"detail": "invalid signature"}, status=403)
             return _add_cors_headers(request, response)
 
+    if not verified and not request.user.is_authenticated:
+        response = JsonResponse({"detail": "authentication required"}, status=401)
+        return _add_cors_headers(request, response)
+
     mac_address = mac_address.lower()
     defaults = {
         "hostname": hostname,
@@ -156,12 +247,20 @@ def register_node(request):
     }
     if verified:
         defaults["public_key"] = public_key
+    if installed_version is not None:
+        defaults["installed_version"] = str(installed_version)[:20]
+    if installed_revision is not None:
+        defaults["installed_revision"] = str(installed_revision)[:40]
+    if relation_value is not None:
+        defaults["current_relation"] = relation_value
 
     node, created = Node.objects.get_or_create(
         mac_address=mac_address,
         defaults=defaults,
     )
     if not created:
+        previous_version = (node.installed_version or "").strip()
+        previous_revision = (node.installed_revision or "").strip()
         node.hostname = hostname
         node.address = address
         node.port = port
@@ -169,8 +268,30 @@ def register_node(request):
         if verified:
             node.public_key = public_key
             update_fields.append("public_key")
+        if installed_version is not None:
+            node.installed_version = str(installed_version)[:20]
+            if "installed_version" not in update_fields:
+                update_fields.append("installed_version")
+        if installed_revision is not None:
+            node.installed_revision = str(installed_revision)[:40]
+            if "installed_revision" not in update_fields:
+                update_fields.append("installed_revision")
+        if relation_value is not None and node.current_relation != relation_value:
+            node.current_relation = relation_value
+            update_fields.append("current_relation")
         node.save(update_fields=update_fields)
-        if features is not None:
+        current_version = (node.installed_version or "").strip()
+        current_revision = (node.installed_revision or "").strip()
+        node_information_updated.send(
+            sender=Node,
+            node=node,
+            previous_version=previous_version,
+            previous_revision=previous_revision,
+            current_version=current_version,
+            current_revision=current_revision,
+            request=request,
+        )
+        if features is not None and (verified or request.user.is_authenticated):
             if isinstance(features, (str, bytes)):
                 feature_list = [features]
             else:
@@ -181,13 +302,25 @@ def register_node(request):
         )
         return _add_cors_headers(request, response)
 
-    if features is not None:
+    if features is not None and (verified or request.user.is_authenticated):
         if isinstance(features, (str, bytes)):
             feature_list = [features]
         else:
             feature_list = list(features)
         node.update_manual_features(feature_list)
 
+    current_version = (node.installed_version or "").strip()
+    current_revision = (node.installed_revision or "").strip()
+    node_information_updated.send(
+        sender=Node,
+        node=node,
+        previous_version="",
+        previous_revision="",
+        current_version=current_version,
+        current_revision=current_revision,
+        request=request,
+    )
+
     response = JsonResponse({"id": node.id})
     return _add_cors_headers(request, response)
 
@@ -277,11 +410,22 @@ def net_message(request):
     if reach_name:
         reach_role = NodeRole.objects.filter(name=reach_name).first()
     seen = data.get("seen", [])
+    origin_id = data.get("origin")
+    origin_node = None
+    if origin_id:
+        origin_node = Node.objects.filter(uuid=origin_id).first()
+    if not origin_node:
+        origin_node = node
     if not msg_uuid:
         return JsonResponse({"detail": "uuid required"}, status=400)
     msg, created = NetMessage.objects.get_or_create(
         uuid=msg_uuid,
-        defaults={"subject": subject[:64], "body": body[:256], "reach": reach_role},
+        defaults={
+            "subject": subject[:64],
+            "body": body[:256],
+            "reach": reach_role,
+            "node_origin": origin_node,
+        },
     )
     if not created:
         msg.subject = subject[:64]
@@ -290,6 +434,9 @@ def net_message(request):
         if reach_role and msg.reach_id != reach_role.id:
             msg.reach = reach_role
             update_fields.append("reach")
+        if msg.node_origin_id is None and origin_node:
+            msg.node_origin = origin_node
+            update_fields.append("node_origin")
         msg.save(update_fields=update_fields)
     msg.propagate(seen=seen)
     return JsonResponse({"status": "propagated", "complete": msg.complete})

ocpp/admin.py

@@ -140,7 +140,7 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
         ),
         (
             "Configuration",
-            {"fields": ("require_rfid",)},
+            {"fields": ("public_display", "require_rfid")},
         ),
         (
             "References",
@@ -161,6 +161,7 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
         "connector_id",
         "location_name",
         "require_rfid_display",
+        "public_display",
         "last_heartbeat",
         "firmware_status",
         "firmware_timestamp",
@@ -276,18 +277,75 @@ class SimulatorAdmin(LogViewAdminMixin, EntityModelAdmin):
         "rfid",
         ("duration", "interval", "pre_charge_delay"),
         "kw_max",
-        "repeat",
+        ("repeat", "door_open"),
         ("username", "password"),
     )
-    actions = ("start_simulator", "stop_simulator")
+    actions = ("start_simulator", "stop_simulator", "send_open_door")
 
     log_type = "simulator"
 
+    def save_model(self, request, obj, form, change):
+        previous_door_open = False
+        if change and obj.pk:
+            previous_door_open = (
+                type(obj)
+                .objects.filter(pk=obj.pk)
+                .values_list("door_open", flat=True)
+                .first()
+                or False
+            )
+        super().save_model(request, obj, form, change)
+        if obj.door_open and not previous_door_open:
+            triggered = self._queue_door_open(request, obj)
+            if not triggered:
+                type(obj).objects.filter(pk=obj.pk).update(door_open=False)
+                obj.door_open = False
+
+    def _queue_door_open(self, request, obj) -> bool:
+        sim = store.simulators.get(obj.pk)
+        if not sim:
+            self.message_user(
+                request,
+                f"{obj.name}: simulator is not running",
+                level=messages.ERROR,
+            )
+            return False
+        type(obj).objects.filter(pk=obj.pk).update(door_open=True)
+        obj.door_open = True
+        store.add_log(
+            obj.cp_path,
+            "Door open event requested from admin",
+            log_type="simulator",
+        )
+        if hasattr(sim, "trigger_door_open"):
+            sim.trigger_door_open()
+        else:  # pragma: no cover - unexpected condition
+            self.message_user(
+                request,
+                f"{obj.name}: simulator cannot send door open event",
+                level=messages.ERROR,
+            )
+            type(obj).objects.filter(pk=obj.pk).update(door_open=False)
+            obj.door_open = False
+            return False
+        type(obj).objects.filter(pk=obj.pk).update(door_open=False)
+        obj.door_open = False
+        self.message_user(
+            request,
+            f"{obj.name}: DoorOpen status notification sent",
+        )
+        return True
+
     def running(self, obj):
         return obj.pk in store.simulators
 
     running.boolean = True
 
+    @admin.action(description="Send Open Door")
+    def send_open_door(self, request, queryset):
+        for obj in queryset:
+            self._queue_door_open(request, obj)
+
     def start_simulator(self, request, queryset):
         from django.urls import reverse
         from django.utils.html import format_html
@@ -296,6 +354,8 @@ class SimulatorAdmin(LogViewAdminMixin, EntityModelAdmin):
             if obj.pk in store.simulators:
                 self.message_user(request, f"{obj.name}: already running")
                 continue
+            type(obj).objects.filter(pk=obj.pk).update(door_open=False)
+            obj.door_open = False
             store.register_log_name(obj.cp_path, obj.name, log_type="simulator")
             sim = ChargePointSimulator(obj.as_config())
             started, status, log_file = sim.start()