arthexis 0.1.24__py3-none-any.whl → 0.1.25__py3-none-any.whl

nodes/admin.py

@@ -16,22 +16,23 @@ 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 types import SimpleNamespace
-from urllib.parse import urljoin, urlparse, urlsplit, urlunsplit
+from urllib.parse import urlsplit, urlunsplit, quote
 import base64
-import ipaddress
 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 .classifiers import run_default_classifiers, suppress_default_classifiers
 from .rfid_sync import apply_rfid_payload, serialize_rfid
@@ -60,7 +61,9 @@ from .models import (
 )
 from . import dns as dns_utils
 from core.models import RFID
-from ocpp.models import Charger, Location
+from ocpp.models import Charger
+from ocpp.network import serialize_charger_for_network
+from ocpp.tasks import push_forwarded_charge_points
 from core.user_data import EntityModelAdmin
 
 
@@ -231,33 +234,37 @@ class DNSRecordAdmin(EntityModelAdmin):
 class NodeAdmin(EntityModelAdmin):
     list_display = (
         "hostname",
-        "mac_address",
-        "address",
+        "network_hostname",
+        "ipv4_address",
+        "ipv6_address",
         "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",
                     "message_queue_length",
-                    "role",
                     "current_relation",
                 )
             },
         ),
+        (_("Role"), {"fields": ("role",)}),
         (
             _("Public endpoint"),
             {
@@ -287,12 +294,39 @@ class NodeAdmin(EntityModelAdmin):
         "register_visitor",
         "run_task",
         "take_screenshots",
-        "discover_charge_points",
+        "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
+
     @admin.display(description=_("Relation"), ordering="current_relation")
     def relation(self, obj):
         return obj.get_current_relation_display()
@@ -312,12 +346,7 @@ class NodeAdmin(EntityModelAdmin):
                 _("Visit"),
             )
 
-        host_values: list[str] = []
-        for attr in ("hostname", "address", "public_endpoint"):
-            value = getattr(obj, attr, "") or ""
-            cleaned = value.strip()
-            if cleaned and cleaned not in host_values:
-                host_values.append(cleaned)
+        host_values = obj.get_remote_host_candidates()
 
         remote_url = ""
         for host in host_values:
@@ -417,6 +446,75 @@ 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 update_selected_progress(self, request):
         if request.method != "POST":
             return JsonResponse({"detail": "POST required"}, status=405)
@@ -461,6 +559,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)
@@ -487,13 +586,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")
@@ -571,7 +676,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,
@@ -587,6 +695,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(
@@ -601,102 +710,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 _iter_remote_urls(self, node, path):
-        host_candidates: list[str] = []
-        for attr in ("public_endpoint", "address", "hostname"):
-            value = getattr(node, attr, "") or ""
-            cleaned = value.strip()
-            if cleaned and cleaned not in host_candidates:
-                host_candidates.append(cleaned)
-
-        default_port = node.port or 8000
-        normalized_path = path if path.startswith("/") else f"/{path}"
-        seen: set[str] = set()
-
-        for host in host_candidates:
-            base_path = ""
-            formatted_host = host
-            port_override: int | None = None
-
-            if "://" in host:
-                parsed = urlparse(host)
-                netloc = parsed.netloc or parsed.path
-                base_path = (parsed.path or "").rstrip("/")
-                combined_path = (
-                    f"{base_path}{normalized_path}" if base_path else normalized_path
-                )
-                primary = urlunsplit((parsed.scheme, netloc, combined_path, "", ""))
-                if primary not in seen:
-                    seen.add(primary)
-                    yield primary
-                if parsed.scheme == "https":
-                    fallback = urlunsplit(("http", netloc, combined_path, "", ""))
-                    if fallback not in seen:
-                        seen.add(fallback)
-                        yield fallback
-                elif parsed.scheme == "http":
-                    alternate = urlunsplit(("https", netloc, combined_path, "", ""))
-                    if alternate not in seen:
-                        seen.add(alternate)
-                        yield alternate
+    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
 
-            if host.startswith("[") and "]" in host:
-                end = host.index("]")
-                core_host = host[1:end]
-                remainder = host[end + 1 :]
-                if remainder.startswith(":"):
-                    remainder = remainder[1:]
-                    port_part, sep, path_tail = remainder.partition("/")
-                    if port_part:
-                        try:
-                            port_override = int(port_part)
-                        except ValueError:
-                            port_override = None
-                    if sep:
-                        base_path = f"/{path_tail}".rstrip("/")
-                elif "/" in remainder:
-                    _, _, path_tail = remainder.partition("/")
-                    base_path = f"/{path_tail}".rstrip("/")
-                formatted_host = f"[{core_host}]"
-            else:
-                if "/" in host:
-                    host_only, _, path_tail = host.partition("/")
-                    formatted_host = host_only or host
-                    base_path = f"/{path_tail}".rstrip("/")
-                try:
-                    ip_obj = ipaddress.ip_address(formatted_host)
-                except ValueError:
-                    parts = formatted_host.rsplit(":", 1)
-                    if len(parts) == 2 and parts[1].isdigit():
-                        formatted_host = parts[0]
-                        port_override = int(parts[1])
-                    try:
-                        ip_obj = ipaddress.ip_address(formatted_host)
-                    except ValueError:
-                        ip_obj = None
-                else:
-                    if ip_obj.version == 6 and not formatted_host.startswith("["):
-                        formatted_host = f"[{formatted_host}]"
-
-            effective_port = port_override if port_override is not None else default_port
-            combined_path = f"{base_path}{normalized_path}" if base_path else normalized_path
-
-            for scheme, scheme_default_port in (("https", 443), ("http", 80)):
-                base = f"{scheme}://{formatted_host}"
-                if effective_port and (
-                    port_override is not None or effective_port != scheme_default_port
-                ):
-                    explicit = f"{base}:{effective_port}{combined_path}"
-                    if explicit not in seen:
-                        seen.add(explicit)
-                        yield explicit
-                candidate = f"{base}{combined_path}"
-                if candidate not in seen:
-                    seen.add(candidate)
-                    yield candidate
+    def _iter_remote_urls(self, node, path):
+        if hasattr(node, "iter_remote_urls"):
+            yield from node.iter_remote_urls(path)
+            return
+
+        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."""
@@ -770,11 +829,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
@@ -894,12 +970,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:
@@ -939,12 +1022,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:
@@ -1060,155 +1150,258 @@ class NodeAdmin(EntityModelAdmin):
 
         return self._render_rfid_sync(request, "export", results)
 
-    @admin.action(description=_("Discover Charge Points"))
-    def discover_charge_points(self, request, queryset):
+    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
+
+        url = next(node.iter_remote_urls("/nodes/network/chargers/forward/"), "")
+        if not url:
+            self.message_user(
+                request,
+                _("No reachable host found for %(node)s.") % {"node": node},
+                level=messages.WARNING,
+            )
+            return False
+        try:
+            response = requests.post(url, data=payload_json, headers=headers, timeout=5)
+        except RequestException as exc:
+            self.message_user(
+                request,
+                _("Failed to send forwarding metadata to %(node)s (%(error)s).")
+                % {"node": node, "error": exc},
+                level=messages.WARNING,
+            )
+            return False
+
+        try:
+            data = response.json()
+        except ValueError:
+            data = {}
+
+        if not response.ok or not isinstance(data, dict) or data.get("status") != "ok":
+            detail = ""
+            if isinstance(data, dict):
+                detail = data.get("detail") or ""
+            message = _("Forwarding metadata to %(node)s failed: %(status)s %(detail)s") % {
+                "node": node,
+                "status": response.status_code,
+                "detail": detail,
+            }
+            self.message_user(request, message.strip(), level=messages.WARNING)
+            return False
+
+        return True
+
+    @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
 
-        nodes = [node for node in queryset if not local_node.pk or node.pk != local_node.pk]
-        if not nodes:
-            self.message_user(request, _("No remote nodes selected."), level=messages.WARNING)
+        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
 
-        payload = json.dumps(
-            {"requester": str(local_node.uuid)},
-            separators=(",", ":"),
-            sort_keys=True,
-        )
-        signature = self._sign_payload(private_key, payload)
-        headers = {
-            "Content-Type": "application/json",
-            "X-Signature": signature,
-        }
-
-        created = 0
-        updated = 0
-        errors: list[str] = []
+        eligible = Charger.objects.filter(export_transactions=True)
+        if local_node.pk:
+            eligible = eligible.filter(
+                Q(node_origin=local_node) | Q(node_origin__isnull=True)
+            )
 
-        for node in nodes:
-            url = f"http://{node.address}:{node.port}/nodes/network/chargers/"
-            try:
-                response = requests.post(url, data=payload, headers=headers, timeout=5)
-            except RequestException as exc:
-                errors.append(f"{node}: {exc}")
-                continue
+        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
 
-            if response.status_code != 200:
-                errors.append(f"{node}: {response.status_code} {response.text}")
-                continue
+        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,
+            )
 
-            try:
-                data = response.json()
-            except ValueError:
-                errors.append(f"{node}: invalid JSON response")
-                continue
+        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
 
-            for entry in data.get("chargers", []):
-                applied = self._apply_remote_charger_payload(node, entry)
-                if applied == "created":
-                    created += 1
-                elif applied == "updated":
-                    updated += 1
+        charger_pks = [c.pk for c in chargers_to_update]
+        Charger.objects.filter(pk__in=charger_pks).update(forwarded_to=target)
 
-        if created or updated:
-            summary = _("Imported %(created)s new and %(updated)s existing charge point(s).") % {
-                "created": created,
-                "updated": updated,
-            }
-            self.message_user(request, summary, level=messages.SUCCESS)
-        if errors:
-            for error in errors:
-                self.message_user(request, error, level=messages.ERROR)
-
-    def _apply_remote_charger_payload(self, node, payload: Mapping) -> str | None:
-        serial = Charger.normalize_serial(payload.get("charger_id"))
-        if not serial or Charger.is_placeholder_serial(serial):
-            return None
+        for charger in chargers_to_update:
+            charger.forwarded_to = target
 
-        connector_value = payload.get("connector_id")
-        if connector_value in ("", None):
-            connector_value = None
-        elif isinstance(connector_value, str):
-            try:
-                connector_value = int(connector_value)
-            except ValueError:
-                connector_value = None
+        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,
+            )
 
-        charger, created = Charger.objects.get_or_create(
-            charger_id=serial,
-            connector_id=connector_value,
+        success = self._send_forwarding_metadata(
+            request, target, chargers_to_update, local_node, private_key
         )
 
-        location_obj = None
-        location_payload = payload.get("location")
-        if isinstance(location_payload, Mapping):
-            name = location_payload.get("name")
-            if name:
-                location_obj, _ = Location.objects.get_or_create(name=name)
-                simple_fields = [
-                    "latitude",
-                    "longitude",
-                    "zone",
-                    "contract_type",
-                ]
-                for field in simple_fields:
-                    value = location_payload.get(field)
-                    setattr(location_obj, field, value)
-                location_obj.save()
-
-        datetime_fields = [
-            "firmware_timestamp",
-            "last_heartbeat",
-            "availability_state_updated_at",
-            "availability_requested_at",
-            "availability_request_status_at",
-            "diagnostics_timestamp",
-            "last_status_timestamp",
-        ]
-
-        updates: dict[str, object] = {
-            "node_origin": node,
-            "allow_remote": bool(payload.get("allow_remote", False)),
-            "export_transactions": bool(payload.get("export_transactions", False)),
-            "last_online_at": timezone.now(),
-        }
-
-        simple_fields = [
-            "display_name",
-            "language",
-            "public_display",
-            "require_rfid",
-            "firmware_status",
-            "firmware_status_info",
-            "last_status",
-            "last_error_code",
-            "last_status_vendor_info",
-            "availability_state",
-            "availability_requested_state",
-            "availability_request_status",
-            "availability_request_details",
-            "temperature",
-            "temperature_unit",
-            "diagnostics_status",
-            "diagnostics_location",
-        ]
-        for field in simple_fields:
-            updates[field] = payload.get(field)
+        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,
+            )
 
-        if location_obj is not None:
-            updates["location"] = location_obj
+        try:
+            push_forwarded_charge_points.delay()
+        except Exception:
+            pass
 
-        for field in datetime_fields:
-            value = payload.get(field)
-            updates[field] = parse_datetime(value) if value else None
+    @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
 
-        for field in ("last_meter_values",):
-            updates[field] = payload.get(field) or {}
+        cleared = Charger.objects.filter(forwarded_to_id__in=node_ids).update(
+            forwarded_to=None, forwarding_watermark=None
+        )
 
-        Charger.objects.filter(pk=charger.pk).update(**updates)
-        return "created" if created else "updated"
+        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 {}