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

nodes/views.py

@@ -37,12 +37,23 @@ from django.db.models import Q
 from core.models import RFID
 from ocpp import store
 from ocpp.models import Charger
+from ocpp.network import (
+    apply_remote_charger_payload,
+    serialize_charger_for_network,
+    sync_transactions_payload,
+)
 from ocpp.transactions_io import export_transactions
 from asgiref.sync import async_to_sync
 
 from .rfid_sync import apply_rfid_payload, serialize_rfid
 
-from .models import Node, NetMessage, PendingNetMessage, node_information_updated
+from .models import (
+    Node,
+    NetMessage,
+    PendingNetMessage,
+    NodeRole,
+    node_information_updated,
+)
 from .utils import capture_screenshot, save_screenshot
 
 
@@ -175,65 +186,6 @@ def _assign_groups_and_permissions(user, payload: Mapping) -> None:
         user.user_permissions.set(perm_objs)
 
 
-def _serialize_charger_for_network(charger: Charger) -> dict[str, object]:
-    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",
-    ]
-    datetime_fields = [
-        "firmware_timestamp",
-        "last_heartbeat",
-        "availability_state_updated_at",
-        "availability_requested_at",
-        "availability_request_status_at",
-        "diagnostics_timestamp",
-        "last_status_timestamp",
-        "last_online_at",
-    ]
-
-    data: dict[str, object] = {
-        "charger_id": charger.charger_id,
-        "connector_id": charger.connector_id,
-        "allow_remote": charger.allow_remote,
-        "export_transactions": charger.export_transactions,
-        "last_meter_values": charger.last_meter_values or {},
-    }
-
-    for field in simple_fields:
-        data[field] = getattr(charger, field)
-
-    for field in datetime_fields:
-        value = getattr(charger, field)
-        data[field] = value.isoformat() if value else None
-
-    if charger.location:
-        location = charger.location
-        data["location"] = {
-            "name": location.name,
-            "latitude": location.latitude,
-            "longitude": location.longitude,
-            "zone": location.zone,
-            "contract_type": location.contract_type,
-        }
-
-    return data
-
-
 def _normalize_requested_chargers(values) -> list[tuple[str, int | None, object]]:
     if not isinstance(values, list):
         return []
@@ -410,7 +362,7 @@ def _get_advertised_address(request, node) -> str:
     host_ip = _get_host_ip(request)
     if host_ip:
         return host_ip
-    return node.address
+    return node.get_primary_contact() or node.address or node.hostname
 
 
 @api_login_required
@@ -420,7 +372,10 @@ def node_list(request):
     nodes = [
         {
             "hostname": node.hostname,
+            "network_hostname": node.network_hostname,
             "address": node.address,
+            "ipv4_address": node.ipv4_address,
+            "ipv6_address": node.ipv6_address,
             "port": node.port,
             "last_seen": node.last_seen,
             "features": list(node.features.values_list("slug", flat=True)),
@@ -448,21 +403,22 @@ def node_info(request):
             advertised_port = host_port
     if host_domain:
         hostname = host_domain
-        if advertised_address and advertised_address != node.address:
-            address = advertised_address
-        else:
-            address = host_domain
+        address = advertised_address or host_domain
     else:
         hostname = node.hostname
-        address = advertised_address
+        address = advertised_address or node.address or node.network_hostname or ""
     data = {
         "hostname": hostname,
+        "network_hostname": node.network_hostname,
         "address": address,
+        "ipv4_address": node.ipv4_address,
+        "ipv6_address": node.ipv6_address,
         "port": advertised_port,
         "mac_address": node.mac_address,
         "public_key": node.public_key,
         "features": list(node.features.values_list("slug", flat=True)),
         "role": node.role.name if node.role_id else "",
+        "contact_hosts": node.get_remote_host_candidates(),
     }
 
     if token:
@@ -506,7 +462,14 @@ def _add_cors_headers(request, response):
 def _node_display_name(node: Node) -> str:
     """Return a human-friendly name for ``node`` suitable for messaging."""
 
-    for attr in ("hostname", "public_endpoint", "address"):
+    for attr in (
+        "hostname",
+        "network_hostname",
+        "public_endpoint",
+        "address",
+        "ipv6_address",
+        "ipv4_address",
+    ):
         value = getattr(node, attr, "") or ""
         value = value.strip()
         if value:
@@ -558,10 +521,13 @@ def register_node(request):
     else:
         features = data.get("features")
 
-    hostname = data.get("hostname")
-    address = data.get("address")
+    hostname = (data.get("hostname") or "").strip()
+    address = (data.get("address") or "").strip()
+    network_hostname = (data.get("network_hostname") or "").strip()
+    ipv4_address = (data.get("ipv4_address") or "").strip()
+    ipv6_address = (data.get("ipv6_address") or "").strip()
     port = data.get("port", 8000)
-    mac_address = data.get("mac_address")
+    mac_address = (data.get("mac_address") or "").strip()
     public_key = data.get("public_key")
     token = data.get("token")
     signature = data.get("signature")
@@ -577,12 +543,27 @@ def register_node(request):
         Node.normalize_relation(raw_relation) if relation_present else None
     )
 
-    if not hostname or not address or not mac_address:
+    if not hostname or not mac_address:
+        response = JsonResponse(
+            {"detail": "hostname and mac_address required"}, status=400
+        )
+        return _add_cors_headers(request, response)
+
+    if not any([address, network_hostname, ipv4_address, ipv6_address]):
         response = JsonResponse(
-            {"detail": "hostname, address and mac_address required"}, status=400
+            {
+                "detail": "at least one of address, network_hostname, "
+                "ipv4_address or ipv6_address must be provided",
+            },
+            status=400,
         )
         return _add_cors_headers(request, response)
 
+    try:
+        port = int(port)
+    except (TypeError, ValueError):
+        port = 8000
+
     verified = False
     if public_key and token and signature:
         try:
@@ -603,9 +584,15 @@ def register_node(request):
         return _add_cors_headers(request, response)
 
     mac_address = mac_address.lower()
+    address_value = address or None
+    ipv4_value = ipv4_address or None
+    ipv6_value = ipv6_address or None
     defaults = {
         "hostname": hostname,
-        "address": address,
+        "network_hostname": network_hostname,
+        "address": address_value,
+        "ipv4_address": ipv4_value,
+        "ipv6_address": ipv6_value,
         "port": port,
     }
     role_name = str(data.get("role") or data.get("role_name") or "").strip()
@@ -630,10 +617,18 @@ def register_node(request):
     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
-        update_fields = ["hostname", "address", "port"]
+        update_fields = []
+        for field, value in (
+            ("hostname", hostname),
+            ("network_hostname", network_hostname),
+            ("address", address_value),
+            ("ipv4_address", ipv4_value),
+            ("ipv6_address", ipv6_value),
+            ("port", port),
+        ):
+            if getattr(node, field) != value:
+                setattr(node, field, value)
+                update_fields.append(field)
         if verified:
             node.public_key = public_key
             update_fields.append("public_key")
@@ -651,7 +646,8 @@ def register_node(request):
         if desired_role and node.role_id != desired_role.id:
             node.role = desired_role
             update_fields.append("role")
-        node.save(update_fields=update_fields)
+        if update_fields:
+            node.save(update_fields=update_fields)
         current_version = (node.installed_version or "").strip()
         current_revision = (node.installed_revision or "").strip()
         node_information_updated.send(
@@ -866,7 +862,7 @@ def network_chargers(request):
                 filters |= Q(charger_id=serial, connector_id=connector_value)
         qs = qs.filter(filters)
 
-    chargers = [_serialize_charger_for_network(charger) for charger in qs]
+    chargers = [serialize_charger_for_network(charger) for charger in qs]
 
     include_transactions = bool(body.get("include_transactions"))
     response_data: dict[str, object] = {"chargers": chargers}
@@ -883,6 +879,55 @@ def network_chargers(request):
     return JsonResponse(response_data)
 
 
+@csrf_exempt
+def forward_chargers(request):
+    """Receive forwarded charger metadata and transactions from trusted peers."""
+
+    if request.method != "POST":
+        return JsonResponse({"detail": "POST required"}, status=405)
+
+    try:
+        body = json.loads(request.body.decode() or "{}")
+    except json.JSONDecodeError:
+        return JsonResponse({"detail": "invalid json"}, status=400)
+
+    requester = body.get("requester")
+    if not requester:
+        return JsonResponse({"detail": "requester required"}, status=400)
+
+    requester_mac = _clean_requester_hint(body.get("requester_mac"))
+    requester_public_key = _clean_requester_hint(
+        body.get("requester_public_key"), strip=False
+    )
+
+    node, error_response = _load_signed_node(
+        request,
+        requester,
+        mac_address=requester_mac,
+        public_key=requester_public_key,
+    )
+    if error_response is not None:
+        return error_response
+
+    processed = 0
+    chargers_payload = body.get("chargers", [])
+    if not isinstance(chargers_payload, list):
+        chargers_payload = []
+    for entry in chargers_payload:
+        if not isinstance(entry, Mapping):
+            continue
+        charger = apply_remote_charger_payload(node, entry)
+        if charger:
+            processed += 1
+
+    imported = 0
+    transactions_payload = body.get("transactions")
+    if isinstance(transactions_payload, Mapping):
+        imported = sync_transactions_payload(transactions_payload)
+
+    return JsonResponse({"status": "ok", "chargers": processed, "transactions": imported})
+
+
 def _require_local_origin(charger: Charger) -> bool:
     local = Node.get_local()
     if not local:
@@ -1561,7 +1606,10 @@ def public_node_endpoint(request, endpoint):
     if request.method == "GET":
         data = {
             "hostname": node.hostname,
-            "address": node.address,
+            "network_hostname": node.network_hostname,
+            "address": node.address or node.get_primary_contact(),
+            "ipv4_address": node.ipv4_address,
+            "ipv6_address": node.ipv6_address,
             "port": node.port,
             "badge_color": node.badge_color,
             "last_seen": node.last_seen,

ocpp/admin.py

@@ -9,6 +9,7 @@ from typing import Any
 
 from django.shortcuts import redirect
 from django.utils import formats, timezone, translation
+from django.utils.translation import gettext_lazy as _
 from django.utils.dateparse import parse_datetime
 from django.utils.html import format_html
 from django.urls import path
@@ -21,6 +22,8 @@ import requests
 from requests import RequestException
 from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.asymmetric import padding
+from django.db import transaction
+from django.core.exceptions import ValidationError
 
 from .models import (
     Charger,
@@ -30,6 +33,7 @@ from .models import (
     Transaction,
     Location,
     DataTransferMessage,
+    CPReservation,
 )
 from .simulator import ChargePointSimulator
 from . import store
@@ -74,6 +78,43 @@ class TransactionImportForm(forms.Form):
     file = forms.FileField()
 
 
+class CPReservationForm(forms.ModelForm):
+    class Meta:
+        model = CPReservation
+        fields = [
+            "location",
+            "account",
+            "rfid",
+            "id_tag",
+            "start_time",
+            "duration_minutes",
+        ]
+
+    def clean(self):
+        cleaned = super().clean()
+        instance = self.instance
+        for field in self.Meta.fields:
+            if field in cleaned:
+                setattr(instance, field, cleaned[field])
+        try:
+            instance.allocate_connector(force=bool(instance.pk))
+        except ValidationError as exc:
+            if exc.message_dict:
+                for field, errors in exc.message_dict.items():
+                    for error in errors:
+                        self.add_error(field, error)
+                raise forms.ValidationError(
+                    _("Unable to allocate a connector for the selected time window.")
+                )
+            raise forms.ValidationError(exc.messages or [str(exc)])
+        if not instance.id_tag_value:
+            message = _("Select an RFID or provide an idTag for the reservation.")
+            self.add_error("id_tag", message)
+            self.add_error("rfid", message)
+            raise forms.ValidationError(message)
+        return cleaned
+
+
 class LogViewAdminMixin:
     """Mixin providing an admin view to display charger or simulator logs."""
 
@@ -218,6 +259,7 @@ class LocationAdmin(EntityModelAdmin):
     form = LocationAdminForm
     list_display = ("name", "zone", "contract_type", "latitude", "longitude")
     change_form_template = "admin/ocpp/location/change_form.html"
+    search_fields = ("name",)
 
 
 @admin.register(DataTransferMessage)
@@ -258,6 +300,130 @@ class DataTransferMessageAdmin(admin.ModelAdmin):
     )
 
 
+@admin.register(CPReservation)
+class CPReservationAdmin(EntityModelAdmin):
+    form = CPReservationForm
+    list_display = (
+        "location",
+        "connector_side_display",
+        "start_time",
+        "end_time_display",
+        "account",
+        "id_tag_display",
+        "evcs_status",
+        "evcs_confirmed",
+    )
+    list_filter = ("location", "evcs_confirmed")
+    search_fields = (
+        "location__name",
+        "connector__charger_id",
+        "connector__display_name",
+        "account__name",
+        "id_tag",
+        "rfid__rfid",
+    )
+    date_hierarchy = "start_time"
+    ordering = ("-start_time",)
+    autocomplete_fields = ("location", "account", "rfid")
+    readonly_fields = (
+        "connector_identity",
+        "connector_side_display",
+        "evcs_status",
+        "evcs_error",
+        "evcs_confirmed",
+        "evcs_confirmed_at",
+        "ocpp_message_id",
+        "created_on",
+        "updated_on",
+    )
+    fieldsets = (
+        (
+            None,
+            {
+                "fields": (
+                    "location",
+                    "account",
+                    "rfid",
+                    "id_tag",
+                    "start_time",
+                    "duration_minutes",
+                )
+            },
+        ),
+        (
+            _("Assigned connector"),
+            {"fields": ("connector_identity", "connector_side_display")},
+        ),
+        (
+            _("EVCS response"),
+            {
+                "fields": (
+                    "evcs_confirmed",
+                    "evcs_status",
+                    "evcs_confirmed_at",
+                    "evcs_error",
+                    "ocpp_message_id",
+                )
+            },
+        ),
+        (
+            _("Metadata"),
+            {"fields": ("created_on", "updated_on")},
+        ),
+    )
+
+    def save_model(self, request, obj, form, change):
+        trigger_fields = {
+            "start_time",
+            "duration_minutes",
+            "location",
+            "id_tag",
+            "rfid",
+            "account",
+        }
+        changed_data = set(getattr(form, "changed_data", []))
+        should_send = not change or bool(trigger_fields.intersection(changed_data))
+        with transaction.atomic():
+            super().save_model(request, obj, form, change)
+            if should_send:
+                try:
+                    obj.send_reservation_request()
+                except ValidationError as exc:
+                    raise ValidationError(exc.message_dict or exc.messages or str(exc))
+                else:
+                    self.message_user(
+                        request,
+                        _("Reservation request sent to %(connector)s.")
+                        % {"connector": self.connector_identity(obj)},
+                        messages.SUCCESS,
+                    )
+
+    @admin.display(description=_("Connector"), ordering="connector__connector_id")
+    def connector_side_display(self, obj):
+        return obj.connector_label or "-"
+
+    @admin.display(description=_("Connector identity"))
+    def connector_identity(self, obj):
+        if obj.connector_id:
+            return obj.connector.identity_slug()
+        return "-"
+
+    @admin.display(description=_("End time"))
+    def end_time_display(self, obj):
+        try:
+            value = timezone.localtime(obj.end_time)
+        except Exception:
+            value = obj.end_time
+        if not value:
+            return "-"
+        return formats.date_format(value, "DATETIME_FORMAT")
+
+    @admin.display(description=_("Id tag"))
+    def id_tag_display(self, obj):
+        value = obj.id_tag_value
+        return value or "-"
+
+
 @admin.register(Charger)
 class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
     _REMOTE_DATETIME_FIELDS = {
@@ -327,6 +493,8 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
                 "fields": (
                     "node_origin",
                     "manager_node",
+                    "forwarded_to",
+                    "forwarding_watermark",
                     "allow_remote",
                     "export_transactions",
                     "last_online_at",
@@ -361,6 +529,8 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
         "availability_request_status_at",
         "availability_request_details",
         "configuration",
+        "forwarded_to",
+        "forwarding_watermark",
         "last_online_at",
     )
     list_display = (
@@ -429,7 +599,15 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
             )
             return False, {}
         origin = charger.node_origin
-        if not origin.address or not origin.port:
+        if not origin.port:
+            self.message_user(
+                request,
+                f"{charger}: remote node port is not configured.",
+                level=messages.ERROR,
+            )
+            return False, {}
+
+        if not origin.get_remote_host_candidates():
             self.message_user(
                 request,
                 f"{charger}: remote node connection details are incomplete.",
@@ -465,7 +643,17 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
             )
             return False, {}
 
-        url = f"http://{origin.address}:{origin.port}/nodes/network/chargers/action/"
+        url = next(
+            origin.iter_remote_urls("/nodes/network/chargers/action/"),
+            "",
+        )
+        if not url:
+            self.message_user(
+                request,
+                f"{charger}: no reachable hosts were reported for the remote node.",
+                level=messages.ERROR,
+            )
+            return False, {}
         try:
             response = requests.post(url, data=payload_json, headers=headers, timeout=5)
         except RequestException as exc:

ocpp/consumers.py

@@ -26,6 +26,7 @@ from .models import (
     ChargerConfiguration,
     MeterValue,
     DataTransferMessage,
+    CPReservation,
 )
 from .reference_utils import host_is_local_loopback
 from .evcs_discovery import (
@@ -903,6 +904,43 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                 payload=payload_data,
             )
             return
+        if action == "ReserveNow":
+            status_value = str(payload_data.get("status") or "").strip()
+            message = "ReserveNow result"
+            if status_value:
+                message += f": status={status_value}"
+            store.add_log(log_key, message, log_type="charger")
+
+            reservation_pk = metadata.get("reservation_pk")
+
+            def _apply():
+                if not reservation_pk:
+                    return
+                reservation = CPReservation.objects.filter(pk=reservation_pk).first()
+                if not reservation:
+                    return
+                reservation.evcs_status = status_value
+                reservation.evcs_error = ""
+                confirmed = status_value.casefold() == "accepted"
+                reservation.evcs_confirmed = confirmed
+                reservation.evcs_confirmed_at = timezone.now() if confirmed else None
+                reservation.save(
+                    update_fields=[
+                        "evcs_status",
+                        "evcs_error",
+                        "evcs_confirmed",
+                        "evcs_confirmed_at",
+                        "updated_on",
+                    ]
+                )
+
+            await database_sync_to_async(_apply)()
+            store.record_pending_call_result(
+                message_id,
+                metadata=metadata,
+                payload=payload_data,
+            )
+            return
         if action == "RemoteStartTransaction":
             status_value = str(payload_data.get("status") or "").strip()
             message = "RemoteStartTransaction result"
@@ -1084,6 +1122,66 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                 error_details=details,
             )
             return
+        if action == "ReserveNow":
+            parts: list[str] = []
+            code_text = (error_code or "").strip() if error_code else ""
+            if code_text:
+                parts.append(f"code={code_text}")
+            description_text = (description or "").strip() if description else ""
+            if description_text:
+                parts.append(f"description={description_text}")
+            details_text = ""
+            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(f"details={details_text}")
+            message = "ReserveNow error"
+            if parts:
+                message += ": " + ", ".join(parts)
+            store.add_log(log_key, message, log_type="charger")
+
+            reservation_pk = metadata.get("reservation_pk")
+
+            def _apply():
+                if not reservation_pk:
+                    return
+                reservation = CPReservation.objects.filter(pk=reservation_pk).first()
+                if not reservation:
+                    return
+                summary_parts = []
+                if code_text:
+                    summary_parts.append(code_text)
+                if description_text:
+                    summary_parts.append(description_text)
+                if details_text:
+                    summary_parts.append(details_text)
+                reservation.evcs_status = ""
+                reservation.evcs_error = "; ".join(summary_parts)
+                reservation.evcs_confirmed = False
+                reservation.evcs_confirmed_at = None
+                reservation.save(
+                    update_fields=[
+                        "evcs_status",
+                        "evcs_error",
+                        "evcs_confirmed",
+                        "evcs_confirmed_at",
+                        "updated_on",
+                    ]
+                )
+
+            await database_sync_to_async(_apply)()
+            store.record_pending_call_result(
+                message_id,
+                metadata=metadata,
+                success=False,
+                error_code=error_code,
+                error_description=description,
+                error_details=details,
+            )
+            return
         if action == "RemoteStartTransaction":
             message = "RemoteStartTransaction error"
             if error_code: