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

ocpp/tasks.py

@@ -3,16 +3,14 @@ import json
 import logging
 import uuid
 from datetime import date, datetime, time, timedelta
-from decimal import Decimal, InvalidOperation
 from pathlib import Path
 
 from asgiref.sync import async_to_sync
 from celery import shared_task
 from django.conf import settings
 from django.contrib.auth import get_user_model
-from django.utils import timezone
-from django.utils.dateparse import parse_datetime
 from django.db.models import Q
+from django.utils import timezone
 import requests
 from requests import RequestException
 from cryptography.hazmat.primitives import hashes
@@ -22,7 +20,12 @@ from core import mailer
 from nodes.models import Node
 
 from . import store
-from .models import Charger, Location, MeterValue, Transaction
+from .models import Charger, MeterValue, Transaction
+from .network import (
+    newest_transaction_timestamp,
+    serialize_charger_for_network,
+    serialize_transactions_for_forwarding,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -41,229 +44,6 @@ def _sign_payload(payload_json: str, private_key) -> str | None:
     return base64.b64encode(signature).decode()
 
 
-def _parse_remote_datetime(value):
-    if not value:
-        return None
-    dt = parse_datetime(value)
-    if dt is None:
-        return None
-    if timezone.is_naive(dt):
-        dt = timezone.make_aware(dt, timezone.get_current_timezone())
-    return dt
-
-
-def _to_decimal(value):
-    if value in (None, ""):
-        return None
-    try:
-        return Decimal(str(value))
-    except (InvalidOperation, TypeError, ValueError):
-        return None
-
-
-def _apply_remote_charger_payload(node, payload: dict) -> Charger | None:
-    serial = Charger.normalize_serial(payload.get("charger_id"))
-    if not serial or Charger.is_placeholder_serial(serial):
-        return None
-
-    connector = payload.get("connector_id")
-    if connector in (None, ""):
-        connector_value = None
-    elif isinstance(connector, int):
-        connector_value = connector
-    else:
-        try:
-            connector_value = int(str(connector))
-        except (TypeError, ValueError):
-            connector_value = None
-
-    charger = Charger.objects.filter(
-        charger_id=serial, connector_id=connector_value
-    ).first()
-    if not charger:
-        return None
-
-    location_payload = payload.get("location")
-    location_obj = None
-    if isinstance(location_payload, dict):
-        name = location_payload.get("name")
-        if name:
-            location_obj, _ = Location.objects.get_or_create(name=name)
-            for field in ("latitude", "longitude", "zone", "contract_type"):
-                setattr(location_obj, field, location_payload.get(field))
-            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 location_obj is not None:
-        updates["location"] = location_obj
-
-    for field in datetime_fields:
-        updates[field] = _parse_remote_datetime(payload.get(field))
-
-    updates["last_meter_values"] = payload.get("last_meter_values") or {}
-
-    Charger.objects.filter(pk=charger.pk).update(**updates)
-    charger.refresh_from_db()
-    return charger
-
-
-def _sync_transactions_payload(payload: dict) -> int:
-    if not isinstance(payload, dict):
-        return 0
-
-    chargers_map: dict[tuple[str, int | None], Charger] = {}
-    for entry in payload.get("chargers", []):
-        serial = Charger.normalize_serial(entry.get("charger_id"))
-        if not serial or Charger.is_placeholder_serial(serial):
-            continue
-        connector = entry.get("connector_id")
-        if connector in (None, ""):
-            connector_value = None
-        elif isinstance(connector, int):
-            connector_value = connector
-        else:
-            try:
-                connector_value = int(str(connector))
-            except (TypeError, ValueError):
-                connector_value = None
-        charger = Charger.objects.filter(
-            charger_id=serial, connector_id=connector_value
-        ).first()
-        if charger:
-            chargers_map[(serial, connector_value)] = charger
-
-    imported = 0
-    for tx in payload.get("transactions", []):
-        if not isinstance(tx, dict):
-            continue
-        serial = Charger.normalize_serial(tx.get("charger"))
-        if not serial:
-            continue
-        connector = tx.get("connector_id")
-        if connector in (None, ""):
-            connector_value = None
-        elif isinstance(connector, int):
-            connector_value = connector
-        else:
-            try:
-                connector_value = int(str(connector))
-            except (TypeError, ValueError):
-                connector_value = None
-
-        charger = chargers_map.get((serial, connector_value))
-        if charger is None:
-            charger = chargers_map.get((serial, None))
-        if charger is None:
-            continue
-
-        start_time = _parse_remote_datetime(tx.get("start_time"))
-        if start_time is None:
-            continue
-
-        defaults = {
-            "connector_id": connector_value,
-            "account_id": tx.get("account"),
-            "rfid": tx.get("rfid", ""),
-            "vid": tx.get("vid", ""),
-            "vin": tx.get("vin", ""),
-            "meter_start": tx.get("meter_start"),
-            "meter_stop": tx.get("meter_stop"),
-            "voltage_start": _to_decimal(tx.get("voltage_start")),
-            "voltage_stop": _to_decimal(tx.get("voltage_stop")),
-            "current_import_start": _to_decimal(tx.get("current_import_start")),
-            "current_import_stop": _to_decimal(tx.get("current_import_stop")),
-            "current_offered_start": _to_decimal(tx.get("current_offered_start")),
-            "current_offered_stop": _to_decimal(tx.get("current_offered_stop")),
-            "temperature_start": _to_decimal(tx.get("temperature_start")),
-            "temperature_stop": _to_decimal(tx.get("temperature_stop")),
-            "soc_start": _to_decimal(tx.get("soc_start")),
-            "soc_stop": _to_decimal(tx.get("soc_stop")),
-            "stop_time": _parse_remote_datetime(tx.get("stop_time")),
-            "received_start_time": _parse_remote_datetime(
-                tx.get("received_start_time")
-            ),
-            "received_stop_time": _parse_remote_datetime(
-                tx.get("received_stop_time")
-            ),
-        }
-
-        transaction, _ = Transaction.objects.update_or_create(
-            charger=charger,
-            start_time=start_time,
-            defaults=defaults,
-        )
-        transaction.meter_values.all().delete()
-        for mv in tx.get("meter_values", []):
-            if not isinstance(mv, dict):
-                continue
-            timestamp = _parse_remote_datetime(mv.get("timestamp"))
-            if timestamp is None:
-                continue
-            connector_mv = mv.get("connector_id")
-            if connector_mv in (None, ""):
-                connector_mv = None
-            elif isinstance(connector_mv, str):
-                try:
-                    connector_mv = int(connector_mv)
-                except (TypeError, ValueError):
-                    connector_mv = None
-            MeterValue.objects.create(
-                charger=charger,
-                transaction=transaction,
-                connector_id=connector_mv,
-                timestamp=timestamp,
-                context=mv.get("context", ""),
-                energy=_to_decimal(mv.get("energy")),
-                voltage=_to_decimal(mv.get("voltage")),
-                current_import=_to_decimal(mv.get("current_import")),
-                current_offered=_to_decimal(mv.get("current_offered")),
-                temperature=_to_decimal(mv.get("temperature")),
-                soc=_to_decimal(mv.get("soc")),
-            )
-        imported += 1
-
-    return imported
-
-
 @shared_task
 def check_charge_point_configuration(charger_pk: int) -> bool:
     """Request the latest configuration from a connected charge point."""
@@ -380,70 +160,118 @@ purge_meter_readings = purge_meter_values
 
 
 @shared_task
-def sync_remote_chargers() -> int:
-    """Synchronize remote charger metadata and transactions."""
+def push_forwarded_charge_points() -> int:
+    """Push local charge point sessions to configured upstream nodes."""
 
     local = Node.get_local()
     if not local:
-        logger.debug("Remote sync skipped: local node not registered")
+        logger.debug("Forwarding skipped: local node not registered")
         return 0
 
     private_key = local.get_private_key()
     if private_key is None:
-        logger.warning("Remote sync skipped: missing local node private key")
+        logger.warning("Forwarding skipped: missing local node private key")
         return 0
 
-    chargers = (
-        Charger.objects.filter(export_transactions=True)
-        .exclude(node_origin__isnull=True)
-        .select_related("node_origin")
+    chargers_qs = (
+        Charger.objects.filter(export_transactions=True, forwarded_to__isnull=False)
+        .select_related("forwarded_to", "node_origin")
+        .order_by("pk")
     )
+
+    node_filter = Q(node_origin__isnull=True)
     if local.pk:
-        chargers = chargers.exclude(node_origin=local)
+        node_filter |= Q(node_origin=local)
+
+    chargers = list(chargers_qs.filter(node_filter))
+    if not chargers:
+        return 0
 
     grouped: dict[Node, list[Charger]] = {}
     for charger in chargers:
-        origin = charger.node_origin
-        if not origin:
+        target = charger.forwarded_to
+        if not target:
             continue
-        grouped.setdefault(origin, []).append(charger)
+        if local.pk and target.pk == local.pk:
+            continue
+        grouped.setdefault(target, []).append(charger)
 
     if not grouped:
         return 0
 
-    synced = 0
+    forwarded_total = 0
+
     for node, node_chargers in grouped.items():
-        payload = {
-            "requester": str(local.uuid),
-            "include_transactions": True,
-            "chargers": [],
-        }
+        if not node_chargers:
+            continue
+
+        initializing = [ch for ch in node_chargers if ch.forwarding_watermark is None]
+        charger_by_pk = {ch.pk: ch for ch in node_chargers}
+        transactions_map: dict[int, list[Transaction]] = {}
+
         for charger in node_chargers:
-            payload["chargers"].append(
+            watermark = charger.forwarding_watermark
+            if watermark is None:
+                continue
+            tx_queryset = (
+                Transaction.objects.filter(charger=charger, start_time__gt=watermark)
+                .select_related("charger")
+                .prefetch_related("meter_values")
+                .order_by("start_time")
+            )
+            txs = list(tx_queryset)
+            if txs:
+                transactions_map[charger.pk] = txs
+
+        transaction_payload = {"chargers": [], "transactions": []}
+        for charger_pk, txs in transactions_map.items():
+            charger = charger_by_pk[charger_pk]
+            transaction_payload["chargers"].append(
                 {
                     "charger_id": charger.charger_id,
                     "connector_id": charger.connector_id,
-                    "since": charger.last_online_at.isoformat()
-                    if charger.last_online_at
-                    else None,
+                    "require_rfid": charger.require_rfid,
                 }
             )
+            transaction_payload["transactions"].extend(
+                serialize_transactions_for_forwarding(txs)
+            )
+
+        payload = {
+            "requester": str(local.uuid),
+            "requester_mac": local.mac_address,
+            "requester_public_key": local.public_key,
+            "chargers": [serialize_charger_for_network(ch) for ch in initializing],
+        }
+
+        has_transactions = bool(transaction_payload["transactions"])
+        if has_transactions or payload["chargers"]:
+            payload["transactions"] = transaction_payload
+        else:
+            continue
+
         payload_json = json.dumps(payload, separators=(",", ":"), sort_keys=True)
         signature = _sign_payload(payload_json, private_key)
         headers = {"Content-Type": "application/json"}
         if signature:
             headers["X-Signature"] = signature
 
-        url = f"http://{node.address}:{node.port}/nodes/network/chargers/"
+        url = next(node.iter_remote_urls("/nodes/network/chargers/forward/"), "")
+        if not url:
+            logger.warning(
+                "No reachable host found for %s when forwarding chargers", node
+            )
+            continue
+
         try:
             response = requests.post(url, data=payload_json, headers=headers, timeout=5)
         except RequestException as exc:
-            logger.warning("Failed to sync chargers from %s: %s", node, exc)
+            logger.warning("Failed to forward chargers to %s: %s", node, exc)
             continue
 
         if not response.ok:
             logger.warning(
-                "Sync request to %s returned %s", node, response.status_code
+                "Forwarding request to %s returned %s", node, response.status_code
             )
             continue
 
@@ -453,21 +281,34 @@ def sync_remote_chargers() -> int:
             logger.warning("Invalid JSON payload received from %s", node)
             continue
 
-        chargers_payload = data.get("chargers", [])
-        for entry in chargers_payload:
-            charger = _apply_remote_charger_payload(node, entry)
-            if charger:
-                synced += 1
-
-        transactions_payload = data.get("transactions")
-        if transactions_payload:
-            imported = _sync_transactions_payload(transactions_payload)
-            if imported:
-                logger.info(
-                    "Imported %s transaction(s) from node %s", imported, node
-                )
-
-    return synced
+        if data.get("status") != "ok":
+            detail = data.get("detail") if isinstance(data, dict) else None
+            logger.warning(
+                "Forwarding rejected by %s: %s",
+                node,
+                detail or response.text or "Remote node rejected the request.",
+            )
+            continue
+
+        updates: dict[int, datetime] = {}
+        now = timezone.now()
+        for charger in initializing:
+            updates[charger.pk] = now
+        for charger_pk, txs in transactions_map.items():
+            latest = newest_transaction_timestamp(txs)
+            if latest:
+                updates[charger_pk] = latest
+
+        for pk, timestamp in updates.items():
+            Charger.objects.filter(pk=pk).update(forwarding_watermark=timestamp)
+
+        forwarded_total += len(transaction_payload["transactions"])
+
+    return forwarded_total
+
+
+# Backwards compatibility alias for legacy schedules
+sync_remote_chargers = push_forwarded_charge_points
 
 
 def _resolve_report_window() -> tuple[datetime, datetime, date]:

ocpp/tests.py

@@ -67,6 +67,7 @@ from .models import (
     MeterReading,
     Location,
     DataTransferMessage,
+    CPReservation,
 )
 from .admin import ChargerConfigurationAdmin
 from .consumers import CSMSConsumer
@@ -304,6 +305,184 @@ class ChargerRefreshManagerNodeTests(TestCase):
         self.assertEqual(charger.manager_node, remote)
 
 
+class CPReservationTests(TransactionTestCase):
+    def setUp(self):
+        self.location = Location.objects.create(name="Reservation Site")
+        self.aggregate = Charger.objects.create(charger_id="RSV100", location=self.location)
+        self.connector_one = Charger.objects.create(
+            charger_id="RSV100", connector_id=1, location=self.location
+        )
+        self.connector_two = Charger.objects.create(
+            charger_id="RSV100", connector_id=2, location=self.location
+        )
+        self.addCleanup(store.clear_pending_calls, "RSV100")
+
+    def test_allocates_preferred_connector(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation(
+            location=self.location,
+            start_time=start,
+            duration_minutes=90,
+            id_tag="TAG001",
+        )
+        reservation.save()
+        self.assertEqual(reservation.connector, self.connector_two)
+
+    def test_allocation_falls_back_and_blocks_overlaps(self):
+        start = timezone.now() + timedelta(hours=1)
+        first = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=60,
+            id_tag="TAG002",
+        )
+        self.assertEqual(first.connector, self.connector_two)
+        second = CPReservation(
+            location=self.location,
+            start_time=start + timedelta(minutes=15),
+            duration_minutes=60,
+            id_tag="TAG003",
+        )
+        second.save()
+        self.assertEqual(second.connector, self.connector_one)
+        third = CPReservation(
+            location=self.location,
+            start_time=start + timedelta(minutes=30),
+            duration_minutes=45,
+            id_tag="TAG004",
+        )
+        with self.assertRaises(ValidationError):
+            third.save()
+
+    def test_send_reservation_request_dispatches_frame(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=30,
+            id_tag="TAG005",
+        )
+
+        class DummyConnection:
+            def __init__(self):
+                self.sent: list[str] = []
+
+            async def send(self, message):
+                self.sent.append(message)
+
+        ws = DummyConnection()
+        store.set_connection(
+            reservation.connector.charger_id,
+            reservation.connector.connector_id,
+            ws,
+        )
+        self.addCleanup(
+            store.pop_connection,
+            reservation.connector.charger_id,
+            reservation.connector.connector_id,
+        )
+
+        message_id = reservation.send_reservation_request()
+        self.assertTrue(ws.sent)
+        frame = json.loads(ws.sent[0])
+        self.assertEqual(frame[0], 2)
+        self.assertEqual(frame[2], "ReserveNow")
+        self.assertEqual(frame[3]["reservationId"], reservation.pk)
+        self.assertEqual(frame[3]["connectorId"], reservation.connector.connector_id)
+        self.assertEqual(frame[3]["idTag"], "TAG005")
+        metadata = store.pending_calls.get(message_id)
+        self.assertIsNotNone(metadata)
+        self.assertEqual(metadata.get("reservation_pk"), reservation.pk)
+
+    def test_call_result_marks_reservation_confirmed(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=45,
+            id_tag="TAG006",
+        )
+        log_key = store.identity_key(
+            reservation.connector.charger_id, reservation.connector.connector_id
+        )
+        message_id = "reserve-success"
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "ReserveNow",
+                "charger_id": reservation.connector.charger_id,
+                "connector_id": reservation.connector.connector_id,
+                "log_key": log_key,
+                "reservation_pk": reservation.pk,
+            },
+        )
+
+        consumer = CSMSConsumer()
+        consumer.scope = {"headers": [], "client": ("127.0.0.1", 1234)}
+        consumer.charger_id = reservation.connector.charger_id
+        consumer.store_key = log_key
+        consumer.connector_value = reservation.connector.connector_id
+        consumer.charger = reservation.connector
+        consumer.aggregate_charger = self.aggregate
+        consumer._consumption_task = None
+        consumer._consumption_message_uuid = None
+        consumer.send = AsyncMock()
+
+        async_to_sync(consumer._handle_call_result)(
+            message_id, {"status": "Accepted"}
+        )
+        reservation.refresh_from_db()
+        self.assertTrue(reservation.evcs_confirmed)
+        self.assertEqual(reservation.evcs_status, "Accepted")
+        self.assertIsNotNone(reservation.evcs_confirmed_at)
+
+    def test_call_error_updates_reservation_status(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=45,
+            id_tag="TAG007",
+        )
+        log_key = store.identity_key(
+            reservation.connector.charger_id, reservation.connector.connector_id
+        )
+        message_id = "reserve-error"
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "ReserveNow",
+                "charger_id": reservation.connector.charger_id,
+                "connector_id": reservation.connector.connector_id,
+                "log_key": log_key,
+                "reservation_pk": reservation.pk,
+            },
+        )
+
+        consumer = CSMSConsumer()
+        consumer.scope = {"headers": [], "client": ("127.0.0.1", 1234)}
+        consumer.charger_id = reservation.connector.charger_id
+        consumer.store_key = log_key
+        consumer.connector_value = reservation.connector.connector_id
+        consumer.charger = reservation.connector
+        consumer.aggregate_charger = self.aggregate
+        consumer._consumption_task = None
+        consumer._consumption_message_uuid = None
+        consumer.send = AsyncMock()
+
+        async_to_sync(consumer._handle_call_error)(
+            message_id,
+            "Rejected",
+            "Charger unavailable",
+            {"reason": "maintenance"},
+        )
+        reservation.refresh_from_db()
+        self.assertFalse(reservation.evcs_confirmed)
+        self.assertEqual(reservation.evcs_status, "")
+        self.assertIsNone(reservation.evcs_confirmed_at)
+        self.assertIn("Rejected", reservation.evcs_error or "")
+
+
 class ChargerUrlFallbackTests(TestCase):
     @override_settings(ALLOWED_HOSTS=["fallback.example", "10.0.0.0/8"])
     def test_reference_created_when_site_missing(self):

ocpp/views.py

@@ -47,6 +47,7 @@ CALL_ACTION_LABELS = {
     "DataTransfer": _("Data transfer"),
     "Reset": _("Reset"),
     "TriggerMessage": _("Trigger message"),
+    "ReserveNow": _("Reserve connector"),
 }
 
 CALL_EXPECTED_STATUSES: dict[str, set[str]] = {
@@ -56,6 +57,7 @@ CALL_EXPECTED_STATUSES: dict[str, set[str]] = {
     "DataTransfer": {"Accepted"},
     "Reset": {"Accepted"},
     "TriggerMessage": {"Accepted"},
+    "ReserveNow": {"Accepted"},
 }
 
 

pages/middleware.py

@@ -10,7 +10,7 @@ from django.conf import settings
 from django.urls import Resolver404, resolve
 
 from .models import Landing, LandingLead, ViewHistory
-from .utils import landing_leads_supported
+from .utils import cache_original_referer, get_original_referer, landing_leads_supported
 
 
 logger = logging.getLogger(__name__)
@@ -30,6 +30,7 @@ class ViewHistoryMiddleware:
         )
 
     def __call__(self, request):
+        cache_original_referer(request)
         should_track = self._should_track(request)
         if not should_track:
             return self.get_response(request)
@@ -132,7 +133,7 @@ class ViewHistoryMiddleware:
         if not landing_leads_supported():
             return
 
-        referer = request.META.get("HTTP_REFERER", "") or ""
+        referer = get_original_referer(request)
         user_agent = request.META.get("HTTP_USER_AGENT", "") or ""
         ip_address = self._extract_client_ip(request) or None
         user = getattr(request, "user", None)