arthexis 0.1.16__py3-none-any.whl → 0.1.28__py3-none-any.whl

nodes/admin.py

@@ -8,27 +8,33 @@ from django.contrib.admin import helpers
 from django.contrib.admin.widgets import FilteredSelectMultiple
 from django.core.exceptions import PermissionDenied
 from django.db.models import Count
-from django.http import HttpResponse, JsonResponse
+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
 from django.utils.html import format_html, format_html_join
-from django.utils.translation import gettext_lazy as _
+from django.utils.translation import gettext_lazy as _, ngettext
 from pathlib import Path
-from urllib.parse import urlsplit, urlunsplit
+from types import SimpleNamespace
+from urllib.parse import urlsplit, urlunsplit, quote
 import base64
+import binascii
 import json
 import subprocess
 import uuid
 
+import asyncio
 import pyperclip
 import requests
 from cryptography.hazmat.primitives import hashes, serialization
 from cryptography.hazmat.primitives.asymmetric import padding
 from pyperclip import PyperclipException
 from requests import RequestException
+import websockets
+from asgiref.sync import async_to_sync
 
 from .classifiers import run_default_classifiers, suppress_default_classifiers
 from .rfid_sync import apply_rfid_payload, serialize_rfid
@@ -57,6 +63,15 @@ from .models import (
 )
 from . import dns as dns_utils
 from core.models import RFID
+from ocpp import store
+from ocpp.models import (
+    Charger,
+    CPFirmware,
+    CPFirmwareDeployment,
+    DataTransferMessage,
+)
+from ocpp.network import serialize_charger_for_network
+from ocpp.tasks import push_forwarded_charge_points
 from core.user_data import EntityModelAdmin
 
 
@@ -84,7 +99,7 @@ class NodeFeatureAssignmentInline(admin.TabularInline):
 
 class DeployDNSRecordsForm(forms.Form):
     manager = forms.ModelChoiceField(
-        label="Node Manager",
+        label="Node Profile",
         queryset=NodeManager.objects.none(),
         help_text="Credentials used to authenticate with the DNS provider.",
     )
@@ -227,31 +242,35 @@ class DNSRecordAdmin(EntityModelAdmin):
 class NodeAdmin(EntityModelAdmin):
     list_display = (
         "hostname",
-        "mac_address",
-        "address",
+        "primary_ip",
         "port",
         "role",
         "relation",
         "last_seen",
+        "visit_link",
     )
-    search_fields = ("hostname", "address", "mac_address")
+    search_fields = ("hostname", "network_hostname", "address", "mac_address")
     change_list_template = "admin/nodes/node/change_list.html"
     change_form_template = "admin/nodes/node/change_form.html"
     form = NodeAdminForm
     fieldsets = (
         (
-            _("Node"),
+            _("Network"),
             {
                 "fields": (
                     "hostname",
+                    "network_hostname",
+                    "ipv4_address",
+                    "ipv6_address",
                     "address",
                     "mac_address",
                     "port",
-                    "role",
+                    "message_queue_length",
                     "current_relation",
                 )
             },
         ),
+        (_("Role"), {"fields": ("role",)}),
         (
             _("Public endpoint"),
             {
@@ -281,15 +300,108 @@ class NodeAdmin(EntityModelAdmin):
         "register_visitor",
         "run_task",
         "take_screenshots",
+        "download_evcs_firmware",
+        "start_charge_point_forwarding",
+        "stop_charge_point_forwarding",
         "import_rfids_from_selected",
         "export_rfids_to_selected",
+        "send_net_message",
     ]
     inlines = [NodeFeatureAssignmentInline]
 
+    class SendNetMessageForm(forms.Form):
+        subject = forms.CharField(
+            label=_("Subject"),
+            max_length=NetMessage._meta.get_field("subject").max_length,
+            required=False,
+        )
+        body = forms.CharField(
+            label=_("Body"),
+            max_length=NetMessage._meta.get_field("body").max_length,
+            required=False,
+            widget=forms.Textarea(attrs={"rows": 4}),
+        )
+
+        def clean(self):
+            cleaned = super().clean()
+            subject = (cleaned.get("subject") or "").strip()
+            body = (cleaned.get("body") or "").strip()
+            if not subject and not body:
+                raise forms.ValidationError(
+                    _("Enter a subject or body to send.")
+                )
+            cleaned["subject"] = subject
+            cleaned["body"] = body
+            return cleaned
+
+    class DownloadFirmwareForm(forms.Form):
+        def __init__(self, node: Node, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            base_queryset = Charger.objects.filter(
+                node_origin=node, connector_id__isnull=True
+            ).order_by("display_name", "charger_id")
+            self.fields["charger"].queryset = base_queryset
+
+        charger = forms.ModelChoiceField(
+            label=_("Charge point"),
+            queryset=Charger.objects.none(),
+            help_text=_("Select the EVCS to request firmware from."),
+        )
+        vendor_id = forms.CharField(
+            label=_("Vendor ID"),
+            max_length=255,
+            initial="org.openchargealliance.firmware",
+            help_text=_("Vendor identifier included in the DataTransfer request."),
+        )
+
     @admin.display(description=_("Relation"), ordering="current_relation")
     def relation(self, obj):
         return obj.get_current_relation_display()
 
+    @admin.display(description=_("IP Address"), ordering="address")
+    def primary_ip(self, obj):
+        if not obj:
+            return ""
+        return obj.get_best_ip() or ""
+
+    @admin.display(description=_("Visit"))
+    def visit_link(self, obj):
+        if not obj:
+            return ""
+        if obj.is_local:
+            try:
+                url = reverse("admin:index")
+            except NoReverseMatch:
+                return ""
+            return format_html(
+                '<a href="{}" target="_blank" rel="noopener noreferrer">{}</a>',
+                url,
+                _("Visit"),
+            )
+
+        host_values = obj.get_remote_host_candidates()
+
+        remote_url = ""
+        for host in host_values:
+            temp_node = SimpleNamespace(
+                public_endpoint=host,
+                address="",
+                hostname="",
+                port=obj.port,
+            )
+            remote_url = next(self._iter_remote_urls(temp_node, "/admin/"), "")
+            if remote_url:
+                break
+
+        if not remote_url:
+            return ""
+
+        return format_html(
+            '<a href="{}" target="_blank" rel="noopener noreferrer">{}</a>',
+            remote_url,
+            _("Visit"),
+        )
+
     def get_urls(self):
         urls = super().get_urls()
         custom = [
@@ -330,7 +442,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
 
     @admin.action(description="Register Visitor")
     def register_visitor(self, request, queryset=None):
@@ -354,6 +479,391 @@ class NodeAdmin(EntityModelAdmin):
             request, "admin/nodes/node/update_selected.html", context
         )
 
+    @admin.action(description=_("Send Net Message"))
+    def send_net_message(self, request, queryset):
+        is_submit = "apply" in request.POST
+        form = self.SendNetMessageForm(request.POST if is_submit else None)
+        selected_ids = request.POST.getlist(helpers.ACTION_CHECKBOX_NAME)
+        if not selected_ids:
+            selected_ids = [str(pk) for pk in queryset.values_list("pk", flat=True)]
+        nodes: list[Node] = []
+        cleaned_ids: list[int] = []
+        for value in selected_ids:
+            try:
+                cleaned_ids.append(int(value))
+            except (TypeError, ValueError):
+                continue
+        if cleaned_ids:
+            base_queryset = self.get_queryset(request).filter(pk__in=cleaned_ids)
+            nodes_by_pk = {str(node.pk): node for node in base_queryset}
+            nodes = [nodes_by_pk[value] for value in selected_ids if value in nodes_by_pk]
+        if not nodes:
+            nodes = list(queryset)
+            selected_ids = [str(node.pk) for node in nodes]
+        if not nodes:
+            self.message_user(request, _("No nodes selected."), messages.INFO)
+            return None
+        if is_submit and form.is_valid():
+            subject = form.cleaned_data["subject"]
+            body = form.cleaned_data["body"]
+            created = 0
+            for node in nodes:
+                message = NetMessage.objects.create(
+                    subject=subject,
+                    body=body,
+                    filter_node=node,
+                )
+                message.propagate()
+                created += 1
+            if created:
+                success_message = ngettext(
+                    "Sent %(count)d net message.",
+                    "Sent %(count)d net messages.",
+                    created,
+                ) % {"count": created}
+                self.message_user(request, success_message, messages.SUCCESS)
+            else:
+                self.message_user(
+                    request, _("No net messages were sent."), messages.INFO
+                )
+            return None
+        context = {
+            **self.admin_site.each_context(request),
+            "opts": self.model._meta,
+            "title": _("Send Net Message"),
+            "nodes": nodes,
+            "selected_ids": selected_ids,
+            "action_name": request.POST.get("action", "send_net_message"),
+            "select_across": request.POST.get("select_across", "0"),
+            "action_checkbox_name": helpers.ACTION_CHECKBOX_NAME,
+            "adminform": helpers.AdminForm(
+                form,
+                [(None, {"fields": ("subject", "body")})],
+                {},
+            ),
+            "form": form,
+            "media": self.media + form.media,
+        }
+        return TemplateResponse(
+            request, "admin/nodes/node/send_net_message.html", context
+        )
+
+    def _coerce_metadata_value(self, value):
+        if isinstance(value, (str, int, float, bool)) or value is None:
+            return value
+        if isinstance(value, (bytes, bytearray)):
+            return base64.b64encode(bytes(value)).decode("ascii")
+        if isinstance(value, Mapping):
+            return {k: self._coerce_metadata_value(v) for k, v in value.items()}
+        if isinstance(value, (list, tuple, set)):
+            return [self._coerce_metadata_value(v) for v in value]
+        return str(value)
+
+    def _decode_payload_bytes(self, value, encoding_hint: str = ""):
+        if isinstance(value, (bytes, bytearray)):
+            return bytes(value), encoding_hint or "binary"
+        if not isinstance(value, str):
+            return None, encoding_hint
+        text = value.strip()
+        if not text:
+            return b"", encoding_hint or "binary"
+        try:
+            decoded = base64.b64decode(text, validate=True)
+            return decoded, "base64"
+        except (binascii.Error, ValueError):
+            return None, encoding_hint
+
+    def _extract_firmware_payload(self, data):
+        content_type = "application/octet-stream"
+        encoding = ""
+        filename = ""
+        json_payload = None
+        binary_payload = None
+        metadata: dict[str, object] = {}
+
+        if isinstance(data, Mapping):
+            metadata = {
+                key: self._coerce_metadata_value(value)
+                for key, value in data.items()
+                if key not in {"payload", "data", "json"}
+            }
+            filename = str(data.get("filename") or data.get("name") or "").strip()
+            if data.get("contentType"):
+                content_type_candidate = str(data.get("contentType")).strip()
+                if content_type_candidate:
+                    content_type = content_type_candidate
+            encoding = str(data.get("encoding") or "").strip()
+            raw_payload = data.get("payload")
+            if raw_payload is None:
+                raw_payload = data.get("data")
+            if raw_payload is not None:
+                binary_payload, encoding = self._decode_payload_bytes(
+                    raw_payload, encoding
+                )
+            json_candidate = data.get("json")
+            if json_candidate is not None:
+                if isinstance(json_candidate, str):
+                    try:
+                        json_payload = json.loads(json_candidate)
+                    except json.JSONDecodeError:
+                        metadata["json_raw"] = json_candidate
+                else:
+                    json_payload = json_candidate
+            if json_payload is None and binary_payload is None:
+                remaining = {
+                    key: value
+                    for key, value in data.items()
+                    if key
+                    not in {
+                        "payload",
+                        "data",
+                        "encoding",
+                        "contentType",
+                        "filename",
+                        "json",
+                    }
+                }
+                if remaining:
+                    json_payload = remaining
+        elif isinstance(data, (bytes, bytearray)):
+            binary_payload = bytes(data)
+            encoding = encoding or "binary"
+        elif isinstance(data, str):
+            metadata = {"raw": data}
+            binary_payload, encoding = self._decode_payload_bytes(data, encoding)
+            if binary_payload is None:
+                try:
+                    json_payload = json.loads(data)
+                except json.JSONDecodeError:
+                    binary_payload = data.encode("utf-8")
+                    encoding = encoding or "utf-8"
+        elif data is not None:
+            metadata = {"raw": self._coerce_metadata_value(data)}
+            json_payload = metadata.get("raw")
+
+        return {
+            "binary": binary_payload,
+            "json": json_payload,
+            "encoding": encoding,
+            "content_type": content_type,
+            "filename": filename,
+            "metadata": metadata,
+        }
+
+    def _format_pending_failure(self, action: str, result: Mapping) -> str:
+        label_map = {
+            "DataTransfer": _("Data transfer"),
+            "UpdateFirmware": _("Update firmware"),
+        }
+        action_label = label_map.get(action, action)
+        error_code = str(result.get("error_code") or "").strip()
+        error_description = str(result.get("error_description") or "").strip()
+        details = result.get("error_details")
+        parts: list[str] = []
+        if error_code:
+            parts.append(_("code=%(code)s") % {"code": error_code})
+        if error_description:
+            parts.append(
+                _("description=%(description)s")
+                % {"description": error_description}
+            )
+        if details:
+            try:
+                details_text = json.dumps(
+                    details, sort_keys=True, ensure_ascii=False
+                )
+            except TypeError:
+                details_text = str(details)
+            if details_text:
+                parts.append(_("details=%(details)s") % {"details": details_text})
+        if parts:
+            return _("%(action)s failed: %(details)s") % {
+                "action": action_label,
+                "details": ", ".join(parts),
+            }
+        return _("%(action)s failed.") % {"action": action_label}
+
+    def _process_firmware_download(self, request, node: Node, cleaned_data) -> bool:
+        charger: Charger = cleaned_data["charger"]
+        vendor_id = cleaned_data.get("vendor_id", "")
+        connection = store.get_connection(charger.charger_id, charger.connector_id)
+        if connection is None:
+            self.message_user(
+                request,
+                _("%(charger)s is not currently connected to the platform.")
+                % {"charger": charger},
+                level=messages.ERROR,
+            )
+            return False
+
+        message_id = uuid.uuid4().hex
+        payload = {
+            "vendorId": vendor_id,
+            "messageId": "DownloadFirmware",
+        }
+        log_key = store.identity_key(charger.charger_id, charger.connector_id)
+        message_record = DataTransferMessage.objects.create(
+            charger=charger,
+            connector_id=charger.connector_id,
+            direction=DataTransferMessage.DIRECTION_CSMS_TO_CP,
+            ocpp_message_id=message_id,
+            vendor_id=vendor_id,
+            message_id="DownloadFirmware",
+            payload=payload,
+            status="Pending",
+        )
+
+        frame = json.dumps([2, message_id, "DataTransfer", payload])
+        async_to_sync(connection.send)(frame)
+        store.add_log(
+            log_key,
+            _("Requested firmware download via DataTransfer."),
+            log_type="charger",
+        )
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "DataTransfer",
+                "charger_id": charger.charger_id,
+                "connector_id": charger.connector_id,
+                "log_key": log_key,
+                "message_pk": message_record.pk,
+            },
+        )
+        store.schedule_call_timeout(
+            message_id, action="DataTransfer", log_key=log_key
+        )
+
+        result = store.wait_for_pending_call(message_id, timeout=15.0)
+        if result is None:
+            self.message_user(
+                request,
+                _("The charge point did not respond to the firmware request."),
+                level=messages.ERROR,
+            )
+            return False
+        if not result.get("success", True):
+            detail = self._format_pending_failure("DataTransfer", result)
+            self.message_user(request, detail, level=messages.ERROR)
+            return False
+
+        payload_data = result.get("payload") or {}
+        status_value = str(payload_data.get("status") or "").strip()
+        if status_value.lower() != "accepted":
+            self.message_user(
+                request,
+                _(
+                    "Firmware request for %(charger)s was %(status)s."
+                )
+                % {"charger": charger, "status": status_value or "Rejected"},
+                level=messages.ERROR,
+            )
+            return False
+
+        data_section = payload_data.get("data")
+        extracted = self._extract_firmware_payload(data_section)
+        binary_payload = extracted["binary"]
+        json_payload = extracted["json"]
+        if binary_payload is None and json_payload is None:
+            self.message_user(
+                request,
+                _("The charge point did not include a firmware payload."),
+                level=messages.ERROR,
+            )
+            return False
+
+        now = timezone.now()
+        filename = extracted["filename"] or ""
+        if not filename:
+            suffix = ".bin" if binary_payload is not None else ".json"
+            filename = f"{charger.charger_id}_{now:%Y%m%d%H%M%S}{suffix}"
+
+        metadata = {
+            "vendor_id": vendor_id,
+            "response": self._coerce_metadata_value(payload_data),
+        }
+        metadata.update(extracted["metadata"])
+
+        firmware = CPFirmware(
+            name=f"{charger.charger_id} firmware {now:%Y-%m-%d %H:%M:%S}",
+            source=CPFirmware.Source.DOWNLOAD,
+            source_node=node,
+            source_charger=charger,
+            filename=filename,
+            payload_binary=binary_payload,
+            payload_json=json_payload,
+            payload_encoding=extracted["encoding"],
+            content_type=extracted["content_type"],
+            metadata=metadata,
+            download_vendor_id=vendor_id,
+            download_message_id=message_id,
+            downloaded_at=now,
+            is_user_data=True,
+        )
+        firmware.save()
+
+        self.message_user(
+            request,
+            _("Stored firmware from %(charger)s as %(firmware)s.")
+            % {"charger": charger, "firmware": firmware},
+            level=messages.SUCCESS,
+        )
+        return True
+
+    @admin.action(description=_("Download EVCS firmware"))
+    def download_evcs_firmware(self, request, queryset):
+        nodes = list(queryset)
+        if len(nodes) != 1:
+            self.message_user(
+                request,
+                _("Select a single node to request firmware."),
+                level=messages.ERROR,
+            )
+            return None
+        node = nodes[0]
+
+        if "apply" in request.POST:
+            form = self.DownloadFirmwareForm(node, request.POST)
+            if form.is_valid():
+                if self._process_firmware_download(request, node, form.cleaned_data):
+                    return None
+        else:
+            form = self.DownloadFirmwareForm(node)
+
+        context = {
+            **self.admin_site.each_context(request),
+            "opts": self.model._meta,
+            "title": _("Download EVCS firmware"),
+            "node": node,
+            "nodes": [node],
+            "selected_ids": [str(node.pk)],
+            "action_name": request.POST.get(
+                "action", "download_evcs_firmware"
+            ),
+            "select_across": request.POST.get("select_across", "0"),
+            "action_checkbox_name": helpers.ACTION_CHECKBOX_NAME,
+            "adminform": helpers.AdminForm(
+                form,
+                [
+                    (
+                        None,
+                        {
+                            "fields": (
+                                "charger",
+                                "vendor_id",
+                            )
+                        },
+                    )
+                ],
+                {},
+            ),
+            "form": form,
+            "media": self.media + form.media,
+        }
+        return TemplateResponse(
+            request, "admin/nodes/node/download_firmware.html", context
+        )
+
     def update_selected_progress(self, request):
         if request.method != "POST":
             return JsonResponse({"detail": "POST required"}, status=405)
@@ -398,6 +908,7 @@ class NodeAdmin(EntityModelAdmin):
             }
 
         last_error = ""
+        host_candidates = node.get_remote_host_candidates()
         for url in self._iter_remote_urls(node, "/nodes/info/"):
             try:
                 response = requests.get(url, timeout=5)
@@ -424,13 +935,19 @@ class NodeAdmin(EntityModelAdmin):
                 "updated_fields": updated,
                 "message": message,
             }
-        return {"ok": False, "message": last_error or "Unable to reach remote node."}
+        return {
+            "ok": False,
+            "message": self._build_connectivity_hint(last_error, host_candidates),
+        }
 
     def _apply_remote_node_info(self, node, payload):
         changed = []
         field_map = {
             "hostname": payload.get("hostname"),
+            "network_hostname": payload.get("network_hostname"),
             "address": payload.get("address"),
+            "ipv4_address": payload.get("ipv4_address"),
+            "ipv6_address": payload.get("ipv6_address"),
             "public_key": payload.get("public_key"),
         }
         port_value = payload.get("port")
@@ -451,6 +968,17 @@ class NodeAdmin(EntityModelAdmin):
                 setattr(node, field, value)
                 changed.append(field)
 
+        role_value = payload.get("role") or payload.get("role_name")
+        if role_value is not None:
+            role_name = str(role_value).strip()
+            if role_name:
+                desired_role = NodeRole.objects.filter(name=role_name).first()
+            else:
+                desired_role = None
+            if desired_role and node.role_id != desired_role.id:
+                node.role = desired_role
+                changed.append("role")
+
         node.last_seen = timezone.now()
         if "last_seen" not in changed:
             changed.append("last_seen")
@@ -497,7 +1025,10 @@ class NodeAdmin(EntityModelAdmin):
 
         payload = {
             "hostname": local_node.hostname,
+            "network_hostname": local_node.network_hostname,
             "address": local_node.address,
+            "ipv4_address": local_node.ipv4_address,
+            "ipv6_address": local_node.ipv6_address,
             "port": local_node.port,
             "mac_address": local_node.mac_address,
             "public_key": local_node.public_key,
@@ -513,6 +1044,7 @@ class NodeAdmin(EntityModelAdmin):
         headers = {"Content-Type": "application/json"}
 
         last_error = ""
+        host_candidates = node.get_remote_host_candidates()
         for url in self._iter_remote_urls(node, "/nodes/register/"):
             try:
                 response = requests.post(
@@ -527,46 +1059,52 @@ class NodeAdmin(EntityModelAdmin):
             if response.ok:
                 return {"ok": True, "url": url, "message": "Remote updated."}
             last_error = f"{response.status_code} {response.text}"
-        return {"ok": False, "message": last_error or "Unable to reach remote node."}
+        return {
+            "ok": False,
+            "message": self._build_connectivity_hint(last_error, host_candidates),
+        }
+
+    def _build_connectivity_hint(self, last_error: str, hosts: list[str]) -> str:
+        base_message = last_error or _("Unable to reach remote node.")
+        if hosts:
+            host_text = ", ".join(hosts)
+            return _("%(message)s Tried hosts: %(hosts)s.") % {
+                "message": base_message,
+                "hosts": host_text,
+            }
+        return _("%(message)s No remote hosts were available for contact.") % {
+            "message": base_message
+        }
+
+    def _primary_remote_url(self, node, path: str) -> str:
+        return next(self._iter_remote_urls(node, path), "")
+
+    def _request_remote(self, node, path: str, request_callable):
+        errors: list[str] = []
+        for url in self._iter_remote_urls(node, path):
+            try:
+                response = request_callable(url)
+            except RequestException as exc:
+                errors.append(f"{url}: {exc}")
+                continue
+            return url, response, errors
+        return "", None, errors
 
     def _iter_remote_urls(self, node, path):
-        host_candidates = []
-        for attr in ("public_endpoint", "address", "hostname"):
-            value = getattr(node, attr, "") or ""
-            value = value.strip()
-            if value and value not in host_candidates:
-                host_candidates.append(value)
-
-        port = node.port or 8000
-        normalized_path = path if path.startswith("/") else f"/{path}"
-        seen = set()
-
-        for host in host_candidates:
-            formatted_host = host
-            if ":" in host and not host.startswith("["):
-                formatted_host = f"[{host}]"
-
-            candidates = []
-            if port == 80:
-                candidates = [
-                    f"http://{formatted_host}{normalized_path}",
-                    f"https://{formatted_host}{normalized_path}",
-                ]
-            elif port == 443:
-                candidates = [
-                    f"https://{formatted_host}{normalized_path}",
-                    f"http://{formatted_host}:{port}{normalized_path}",
-                ]
-            else:
-                candidates = [
-                    f"http://{formatted_host}:{port}{normalized_path}",
-                    f"https://{formatted_host}:{port}{normalized_path}",
-                ]
+        if hasattr(node, "iter_remote_urls"):
+            yield from node.iter_remote_urls(path)
+            return
 
-            for candidate in candidates:
-                if candidate not in seen:
-                    seen.add(candidate)
-                    yield candidate
+        temp = Node(
+            public_endpoint=getattr(node, "public_endpoint", ""),
+            address=getattr(node, "address", ""),
+            hostname=getattr(node, "hostname", ""),
+            port=getattr(node, "port", None),
+        )
+        temp.network_hostname = getattr(node, "network_hostname", "")
+        temp.ipv4_address = getattr(node, "ipv4_address", "")
+        temp.ipv6_address = getattr(node, "ipv6_address", "")
+        yield from temp.iter_remote_urls(path)
 
     def register_visitor_view(self, request):
         """Exchange registration data with the visiting node."""
@@ -585,8 +1123,8 @@ class NodeAdmin(EntityModelAdmin):
             "token": token,
             "info_url": reverse("node-info"),
             "register_url": reverse("register-node"),
-            "visitor_info_url": "http://localhost:8000/nodes/info/",
-            "visitor_register_url": "http://localhost:8000/nodes/register/",
+            "visitor_info_url": "http://localhost:8888/nodes/info/",
+            "visitor_register_url": "http://localhost:8888/nodes/register/",
         }
         return render(request, "admin/nodes/node/register_visitor.html", context)
 
@@ -640,11 +1178,28 @@ class NodeAdmin(EntityModelAdmin):
         for node in queryset:
             for source in sources:
                 try:
-                    url = source.format(node=node, address=node.address, port=node.port)
+                    contact_host = node.get_primary_contact()
+                    url = source.format(
+                        node=node, address=contact_host, port=node.port
+                    )
                 except Exception:
                     url = source
                 if not url.startswith("http"):
-                    url = f"http://{node.address}:{node.port}{url}"
+                    candidate = next(
+                        self._iter_remote_urls(node, url),
+                        "",
+                    )
+                    if not candidate:
+                        self.message_user(
+                            request,
+                            _(
+                                "No reachable host was available for %(node)s while generating %(path)s"
+                            )
+                            % {"node": node, "path": url},
+                            messages.WARNING,
+                        )
+                        continue
+                    url = candidate
                 try:
                     path = capture_screenshot(url)
                 except Exception as exc:  # pragma: no cover - selenium issues
@@ -742,6 +1297,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)
@@ -763,12 +1319,19 @@ class NodeAdmin(EntityModelAdmin):
 
     def _process_import_from_node(self, node, payload, headers):
         result = self._init_rfid_result(node)
-        url = f"http://{node.address}:{node.port}/nodes/rfid/export/"
-        try:
-            response = requests.post(url, data=payload, headers=headers, timeout=5)
-        except RequestException as exc:
+        _, response, attempt_errors = self._request_remote(
+            node,
+            "/nodes/rfid/export/",
+            lambda url: requests.post(url, data=payload, headers=headers, timeout=5),
+        )
+        if response is None:
             result["status"] = "error"
-            result["errors"].append(str(exc))
+            if attempt_errors:
+                result["errors"].extend(attempt_errors)
+            else:
+                result["errors"].append(
+                    _("No remote hosts were available for %(node)s.") % {"node": node}
+                )
             return result
 
         if response.status_code != 200:
@@ -808,12 +1371,19 @@ class NodeAdmin(EntityModelAdmin):
 
     def _post_export_to_node(self, node, payload, headers):
         result = self._init_rfid_result(node)
-        url = f"http://{node.address}:{node.port}/nodes/rfid/import/"
-        try:
-            response = requests.post(url, data=payload, headers=headers, timeout=5)
-        except RequestException as exc:
+        _, response, attempt_errors = self._request_remote(
+            node,
+            "/nodes/rfid/import/",
+            lambda url: requests.post(url, data=payload, headers=headers, timeout=5),
+        )
+        if response is None:
             result["status"] = "error"
-            result["errors"].append(str(exc))
+            if attempt_errors:
+                result["errors"].extend(attempt_errors)
+            else:
+                result["errors"].append(
+                    _("No remote hosts were available for %(node)s.") % {"node": node}
+                )
             return result
 
         if response.status_code != 200:
@@ -851,13 +1421,14 @@ 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_import(self, request, queryset):
         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, "import", results, setup_error=error
+            )
 
         if not nodes:
             return self._render_rfid_sync(
@@ -887,6 +1458,10 @@ class NodeAdmin(EntityModelAdmin):
 
         return self._render_rfid_sync(request, "import", results)
 
+    @admin.action(description=_("Import RFIDs from selected"))
+    def import_rfids_from_selected(self, request, queryset):
+        return self._run_rfid_import(request, queryset)
+
     @admin.action(description=_("Export RFIDs to selected"))
     def export_rfids_to_selected(self, request, queryset):
         nodes = list(queryset)
@@ -924,6 +1499,269 @@ class NodeAdmin(EntityModelAdmin):
 
         return self._render_rfid_sync(request, "export", results)
 
+    async def _probe_websocket(self, url: str) -> bool:
+        try:
+            async with websockets.connect(url, open_timeout=3, close_timeout=1):
+                return True
+        except Exception:
+            return False
+
+    def _attempt_forwarding_probe(self, node, charger_id: str) -> bool:
+        if not charger_id:
+            return False
+        safe_id = quote(str(charger_id))
+        candidates: list[str] = []
+        for base in node.iter_remote_urls("/"):
+            parsed = urlsplit(base)
+            if parsed.scheme not in {"http", "https"}:
+                continue
+            scheme = "wss" if parsed.scheme == "https" else "ws"
+            base_path = parsed.path.rstrip("/")
+            for prefix in ("", "/ws"):
+                path = f"{base_path}{prefix}/{safe_id}".replace("//", "/")
+                if not path.startswith("/"):
+                    path = f"/{path}"
+                candidates.append(urlunsplit((scheme, parsed.netloc, path, "", "")))
+
+        for url in candidates:
+            loop = asyncio.new_event_loop()
+            try:
+                result = loop.run_until_complete(self._probe_websocket(url))
+            except Exception:
+                result = False
+            finally:
+                loop.close()
+            if result:
+                return True
+        return False
+
+    def _send_forwarding_metadata(
+        self,
+        request,
+        node: Node,
+        chargers: list[Charger],
+        local_node: Node,
+        private_key,
+    ) -> bool:
+        if not chargers:
+            return True
+        payload = {
+            "requester": str(local_node.uuid),
+            "requester_mac": local_node.mac_address,
+            "requester_public_key": local_node.public_key,
+            "chargers": [serialize_charger_for_network(charger) for charger in chargers],
+            "transactions": {"chargers": [], "transactions": []},
+        }
+        payload_json = json.dumps(payload, separators=(",", ":"), sort_keys=True)
+        signature = self._sign_payload(private_key, payload_json)
+        headers = {"Content-Type": "application/json"}
+        if signature:
+            headers["X-Signature"] = signature
+
+        errors: list[str] = []
+        for url in node.iter_remote_urls("/nodes/network/chargers/forward/"):
+            if not url:
+                continue
+            try:
+                response = requests.post(
+                    url, data=payload_json, headers=headers, timeout=5
+                )
+            except RequestException as exc:
+                errors.append(
+                    _(
+                        "Failed to send forwarding metadata to %(node)s via %(url)s (%(error)s)."
+                    )
+                    % {"node": node, "url": url, "error": exc}
+                )
+                continue
+
+            try:
+                data = response.json()
+            except ValueError:
+                data = {}
+
+            if response.ok and isinstance(data, Mapping) and data.get("status") == "ok":
+                return True
+
+            detail = ""
+            if isinstance(data, Mapping):
+                detail = data.get("detail") or ""
+            errors.append(
+                _("Forwarding metadata to %(node)s via %(url)s failed: %(status)s %(detail)s")
+                % {
+                    "node": node,
+                    "url": url,
+                    "status": response.status_code,
+                    "detail": detail,
+                }
+            )
+
+        if not errors:
+            self.message_user(
+                request,
+                _("No reachable host found for %(node)s.") % {"node": node},
+                level=messages.WARNING,
+            )
+        else:
+            self.message_user(request, errors[-1].strip(), level=messages.WARNING)
+        return False
+
+    @admin.action(description=_("Start Charge Point Forwarding"))
+    def start_charge_point_forwarding(self, request, queryset):
+        if queryset.count() != 1:
+            self.message_user(
+                request,
+                _("Select a single remote node."),
+                level=messages.ERROR,
+            )
+            return
+
+        target = queryset.first()
+        local_node, private_key, error = self._load_local_node_credentials()
+        if error:
+            self.message_user(request, error, level=messages.ERROR)
+            return
+
+        if local_node.pk and target.pk == local_node.pk:
+            self.message_user(
+                request,
+                _("Cannot forward charge points to the local node."),
+                level=messages.ERROR,
+            )
+            return
+
+        eligible = Charger.objects.filter(export_transactions=True)
+        if local_node.pk:
+            eligible = eligible.filter(
+                Q(node_origin=local_node) | Q(node_origin__isnull=True)
+            )
+
+        chargers = list(eligible.select_related("forwarded_to"))
+        if not chargers:
+            self.message_user(
+                request,
+                _("No eligible charge points available for forwarding."),
+                level=messages.WARNING,
+            )
+            return
+
+        conflicts = [
+            charger
+            for charger in chargers
+            if charger.forwarded_to_id
+            and charger.forwarded_to_id not in {None, target.pk}
+        ]
+        if conflicts:
+            self.message_user(
+                request,
+                ngettext(
+                    "Skipped %(count)s charge point already forwarded to another node.",
+                    "Skipped %(count)s charge points already forwarded to another node.",
+                    len(conflicts),
+                )
+                % {"count": len(conflicts)},
+                level=messages.WARNING,
+            )
+
+        chargers_to_update = [
+            charger
+            for charger in chargers
+            if charger.forwarded_to_id in (None, target.pk)
+        ]
+        if not chargers_to_update:
+            self.message_user(
+                request,
+                _("No charge points were updated."),
+                level=messages.WARNING,
+            )
+            return
+
+        charger_pks = [c.pk for c in chargers_to_update]
+        Charger.objects.filter(pk__in=charger_pks).update(forwarded_to=target)
+
+        for charger in chargers_to_update:
+            charger.forwarded_to = target
+
+        sample = next((charger for charger in chargers_to_update if charger.charger_id), None)
+        if sample and not self._attempt_forwarding_probe(target, sample.charger_id):
+            self.message_user(
+                request,
+                _(
+                    "Unable to establish a websocket connection to %(node)s for charge point %(charger)s."
+                )
+                % {"node": target, "charger": sample.charger_id},
+                level=messages.WARNING,
+            )
+
+        success = self._send_forwarding_metadata(
+            request, target, chargers_to_update, local_node, private_key
+        )
+
+        if success:
+            now = timezone.now()
+            Charger.objects.filter(pk__in=charger_pks).update(
+                forwarding_watermark=now
+            )
+            self.message_user(
+                request,
+                ngettext(
+                    "Forwarding enabled for %(count)s charge point.",
+                    "Forwarding enabled for %(count)s charge points.",
+                    len(chargers_to_update),
+                )
+                % {"count": len(chargers_to_update)},
+                level=messages.SUCCESS,
+            )
+        else:
+            self.message_user(
+                request,
+                ngettext(
+                    "Marked %(count)s charge point for forwarding; awaiting remote acknowledgment.",
+                    "Marked %(count)s charge points for forwarding; awaiting remote acknowledgment.",
+                    len(chargers_to_update),
+                )
+                % {"count": len(chargers_to_update)},
+                level=messages.INFO,
+            )
+
+        try:
+            push_forwarded_charge_points.delay()
+        except Exception:
+            pass
+
+    @admin.action(description=_("Stop Charge Point Forwarding"))
+    def stop_charge_point_forwarding(self, request, queryset):
+        node_ids = [node.pk for node in queryset if node.pk]
+        if not node_ids:
+            self.message_user(
+                request,
+                _("No remote nodes selected."),
+                level=messages.WARNING,
+            )
+            return
+
+        cleared = Charger.objects.filter(forwarded_to_id__in=node_ids).update(
+            forwarded_to=None, forwarding_watermark=None
+        )
+
+        if cleared:
+            self.message_user(
+                request,
+                ngettext(
+                    "Stopped forwarding for %(count)s charge point.",
+                    "Stopped forwarding for %(count)s charge points.",
+                    cleared,
+                )
+                % {"count": cleared},
+                level=messages.SUCCESS,
+            )
+        else:
+            self.message_user(
+                request,
+                _("No forwarded charge points were updated."),
+                level=messages.WARNING,
+            )
+
     def changeform_view(self, request, object_id=None, form_url="", extra_context=None):
         extra_context = extra_context or {}
         if object_id:
@@ -1565,7 +2403,7 @@ class NetMessageAdmin(EntityModelAdmin):
     search_fields = ("subject", "body")
     list_filter = ("complete", "filter_node_role", "filter_current_relation")
     ordering = ("-created",)
-    readonly_fields = ("complete", "confirmed_peers")
+    readonly_fields = ("complete",)
     actions = ["send_messages"]
     fieldsets = (
         (None, {"fields": ("subject", "body")}),
@@ -1590,7 +2428,6 @@ class NetMessageAdmin(EntityModelAdmin):
                     "node_origin",
                     "target_limit",
                     "propagated_to",
-                    "confirmed_peers",
                     "complete",
                 )
             },