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

ocpp/consumers.py

@@ -5,6 +5,7 @@ from datetime import datetime
 import asyncio
 import inspect
 import json
+import logging
 from urllib.parse import parse_qs
 from django.utils import timezone
 from core.models import EnergyAccount, Reference, RFID as CoreRFID
@@ -19,7 +20,14 @@ from config.offline import requires_network
 from . import store
 from decimal import Decimal
 from django.utils.dateparse import parse_datetime
-from .models import Transaction, Charger, MeterValue, DataTransferMessage
+from .models import (
+    Transaction,
+    Charger,
+    ChargerConfiguration,
+    MeterValue,
+    DataTransferMessage,
+    CPReservation,
+)
 from .reference_utils import host_is_local_loopback
 from .evcs_discovery import (
     DEFAULT_CONSOLE_PORT,
@@ -32,6 +40,9 @@ from .evcs_discovery import (
 FORWARDED_PAIR_RE = re.compile(r"for=(?:\"?)(?P<value>[^;,\"\s]+)(?:\"?)", re.IGNORECASE)
 
 
+logger = logging.getLogger(__name__)
+
+
 # Query parameter keys that may contain the charge point serial. Keys are
 # matched case-insensitively and trimmed before use.
 SERIAL_QUERY_PARAM_NAMES = (
@@ -134,6 +145,18 @@ def _parse_ocpp_timestamp(value) -> datetime | None:
     return timestamp
 
 
+def _extract_vehicle_identifier(payload: dict) -> tuple[str, str]:
+    """Return normalized VID and VIN values from an OCPP message payload."""
+
+    raw_vid = payload.get("vid")
+    vid_value = str(raw_vid).strip() if raw_vid is not None else ""
+    raw_vin = payload.get("vin")
+    vin_value = str(raw_vin).strip() if raw_vin is not None else ""
+    if not vid_value and vin_value:
+        vid_value = vin_value
+    return vid_value, vin_value
+
+
 class SinkConsumer(AsyncWebsocketConsumer):
     """Accept any message without validation."""
 
@@ -279,11 +302,18 @@ class CSMSConsumer(AsyncWebsocketConsumer):
         """Return the energy account for the provided RFID if valid."""
         if not id_tag:
             return None
-        return await database_sync_to_async(
-            EnergyAccount.objects.filter(
-                rfids__rfid=id_tag.upper(), rfids__allowed=True
-            ).first
-        )()
+
+        def _resolve() -> EnergyAccount | None:
+            matches = CoreRFID.matching_queryset(id_tag).filter(allowed=True)
+            if not matches.exists():
+                return None
+            return (
+                EnergyAccount.objects.filter(rfids__in=matches)
+                .distinct()
+                .first()
+            )
+
+        return await database_sync_to_async(_resolve)()
 
     async def _ensure_rfid_seen(self, id_tag: str) -> CoreRFID | None:
         """Ensure an RFID record exists and update its last seen timestamp."""
@@ -309,6 +339,19 @@ class CSMSConsumer(AsyncWebsocketConsumer):
 
         return await database_sync_to_async(_ensure)()
 
+    def _log_unlinked_rfid(self, rfid: str) -> None:
+        """Record a warning when an RFID is authorized without an account."""
+
+        message = (
+            f"Authorized RFID {rfid} on charger {self.charger_id} without linked energy account"
+        )
+        logger.warning(message)
+        store.add_log(
+            store.pending_key(self.charger_id),
+            message,
+            log_type="charger",
+        )
+
     async def _assign_connector(self, connector: int | str | None) -> None:
         """Ensure ``self.charger`` matches the provided connector id."""
         if connector in (None, "", "-"):
@@ -709,6 +752,54 @@ class CSMSConsumer(AsyncWebsocketConsumer):
         task.add_done_callback(lambda _: setattr(self, "_consumption_task", None))
         self._consumption_task = task
 
+    def _persist_configuration_result(
+        self, payload: dict, connector_hint: int | str | None
+    ) -> ChargerConfiguration | None:
+        if not isinstance(payload, dict):
+            return None
+
+        connector_value: int | None = None
+        if connector_hint not in (None, ""):
+            try:
+                connector_value = int(connector_hint)
+            except (TypeError, ValueError):
+                connector_value = None
+
+        normalized_entries: list[dict[str, object]] = []
+        for entry in payload.get("configurationKey") or []:
+            if not isinstance(entry, dict):
+                continue
+            key = str(entry.get("key") or "")
+            normalized: dict[str, object] = {"key": key}
+            if "value" in entry:
+                normalized["value"] = entry.get("value")
+            normalized["readonly"] = bool(entry.get("readonly"))
+            normalized_entries.append(normalized)
+
+        unknown_values: list[str] = []
+        for value in payload.get("unknownKey") or []:
+            if value is None:
+                continue
+            unknown_values.append(str(value))
+
+        try:
+            raw_payload = json.loads(json.dumps(payload, ensure_ascii=False))
+        except (TypeError, ValueError):
+            raw_payload = payload
+
+        configuration = ChargerConfiguration.objects.create(
+            charger_identifier=self.charger_id,
+            connector_id=connector_value,
+            configuration_keys=normalized_entries,
+            unknown_keys=unknown_values,
+            evcs_snapshot_at=timezone.now(),
+            raw_payload=raw_payload,
+        )
+        Charger.objects.filter(charger_id=self.charger_id).update(
+            configuration=configuration
+        )
+        return configuration
+
     async def _handle_call_result(self, message_id: str, payload: dict | None) -> None:
         metadata = store.pop_pending_call(message_id)
         if not metadata:
@@ -770,6 +861,17 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                 f"GetConfiguration result: {payload_text}",
                 log_type="charger",
             )
+            configuration = await database_sync_to_async(
+                self._persist_configuration_result
+            )(payload_data, metadata.get("connector_id"))
+            if configuration:
+                if self.charger and self.charger.charger_id == self.charger_id:
+                    self.charger.configuration = configuration
+                if (
+                    self.aggregate_charger
+                    and self.aggregate_charger.charger_id == self.charger_id
+                ):
+                    self.aggregate_charger.configuration = configuration
             store.record_pending_call_result(
                 message_id,
                 metadata=metadata,
@@ -802,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"
@@ -983,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:
@@ -1321,8 +1520,13 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                 reply_payload = {"currentTime": datetime.utcnow().isoformat() + "Z"}
                 now = timezone.now()
                 self.charger.last_heartbeat = now
+                if (
+                    self.aggregate_charger
+                    and self.aggregate_charger is not self.charger
+                ):
+                    self.aggregate_charger.last_heartbeat = now
                 await database_sync_to_async(
-                    Charger.objects.filter(pk=self.charger.pk).update
+                    Charger.objects.filter(charger_id=self.charger_id).update
                 )(last_heartbeat=now)
             elif action == "StatusNotification":
                 await self._assign_connector(payload.get("connectorId"))
@@ -1395,13 +1599,25 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             elif action == "Authorize":
                 id_tag = payload.get("idTag")
                 account = await self._get_account(id_tag)
+                status = "Invalid"
                 if self.charger.require_rfid:
-                    status = (
-                        "Accepted"
-                        if account
-                        and await database_sync_to_async(account.can_authorize)()
-                        else "Invalid"
-                    )
+                    tag = None
+                    tag_created = False
+                    if id_tag:
+                        tag, tag_created = await database_sync_to_async(
+                            CoreRFID.register_scan
+                        )(id_tag)
+                    if account:
+                        if await database_sync_to_async(account.can_authorize)():
+                            status = "Accepted"
+                    elif (
+                        id_tag
+                        and tag
+                        and not tag_created
+                        and tag.allowed
+                    ):
+                        status = "Accepted"
+                        self._log_unlinked_rfid(tag.rfid)
                 else:
                     await self._ensure_rfid_seen(id_tag)
                     status = "Accepted"
@@ -1475,30 +1691,47 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                 reply_payload = {}
             elif action == "StartTransaction":
                 id_tag = payload.get("idTag")
-                account = await self._get_account(id_tag)
+                tag = None
+                tag_created = False
                 if id_tag:
-                    if self.charger.require_rfid:
-                        await database_sync_to_async(CoreRFID.register_scan)(
-                            id_tag.upper()
-                        )
-                    else:
-                        await self._ensure_rfid_seen(id_tag)
+                    tag, tag_created = await database_sync_to_async(
+                        CoreRFID.register_scan
+                    )(id_tag)
+                account = await self._get_account(id_tag)
+                if id_tag and not self.charger.require_rfid:
+                    seen_tag = await self._ensure_rfid_seen(id_tag)
+                    if seen_tag:
+                        tag = seen_tag
                 await self._assign_connector(payload.get("connectorId"))
+                authorized = True
+                authorized_via_tag = False
                 if self.charger.require_rfid:
-                    authorized = (
-                        account is not None
-                        and await database_sync_to_async(account.can_authorize)()
-                    )
-                else:
-                    authorized = True
+                    if account is not None:
+                        authorized = await database_sync_to_async(
+                            account.can_authorize
+                        )()
+                    elif (
+                        id_tag
+                        and tag
+                        and not tag_created
+                        and getattr(tag, "allowed", False)
+                    ):
+                        authorized = True
+                        authorized_via_tag = True
+                    else:
+                        authorized = False
                 if authorized:
+                    if authorized_via_tag and tag:
+                        self._log_unlinked_rfid(tag.rfid)
                     start_timestamp = _parse_ocpp_timestamp(payload.get("timestamp"))
                     received_start = timezone.now()
+                    vid_value, vin_value = _extract_vehicle_identifier(payload)
                     tx_obj = await database_sync_to_async(Transaction.objects.create)(
                         charger=self.charger,
                         account=account,
                         rfid=(id_tag or ""),
-                        vin=(payload.get("vin") or ""),
+                        vid=vid_value,
+                        vin=vin_value,
                         connector_id=payload.get("connectorId"),
                         meter_start=payload.get("meterStart"),
                         start_time=start_timestamp or received_start,
@@ -1524,6 +1757,7 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                     )()
                 if not tx_obj and tx_id is not None:
                     received_start = timezone.now()
+                    vid_value, vin_value = _extract_vehicle_identifier(payload)
                     tx_obj = await database_sync_to_async(Transaction.objects.create)(
                         pk=tx_id,
                         charger=self.charger,
@@ -1531,12 +1765,18 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                         received_start_time=received_start,
                         meter_start=payload.get("meterStart")
                         or payload.get("meterStop"),
-                        vin=(payload.get("vin") or ""),
+                        vid=vid_value,
+                        vin=vin_value,
                     )
                 if tx_obj:
                     stop_timestamp = _parse_ocpp_timestamp(payload.get("timestamp"))
                     received_stop = timezone.now()
                     tx_obj.meter_stop = payload.get("meterStop")
+                    vid_value, vin_value = _extract_vehicle_identifier(payload)
+                    if vid_value:
+                        tx_obj.vid = vid_value
+                    if vin_value:
+                        tx_obj.vin = vin_value
                     tx_obj.stop_time = stop_timestamp or received_stop
                     tx_obj.received_stop_time = received_stop
                     await database_sync_to_async(tx_obj.save)()