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

ocpp/consumers.py

@@ -3,8 +3,10 @@ import ipaddress
 import re
 from datetime import datetime
 import asyncio
+from collections import deque
 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 +21,16 @@ 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,
+    CPFirmwareDeployment,
+    RFIDSessionAttempt,
+)
 from .reference_utils import host_is_local_loopback
 from .evcs_discovery import (
     DEFAULT_CONSOLE_PORT,
@@ -32,6 +43,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 +148,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."""
 
@@ -194,8 +220,20 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                         trimmed = value.strip()
                         if trimmed:
                             return trimmed
-                          
-        return self.scope["url_route"]["kwargs"].get("cid", "")
+
+        serial = self.scope["url_route"]["kwargs"].get("cid", "")
+        if serial:
+            return serial
+
+        path = (self.scope.get("path") or "").strip("/")
+        if not path:
+            return ""
+
+        segments = [segment for segment in path.split("/") if segment]
+        if not segments:
+            return ""
+
+        return segments[-1]
 
     @requires_network
     async def connect(self):
@@ -253,7 +291,9 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             log_type="charger",
         )
         store.connections[self.store_key] = self
-        store.logs["charger"].setdefault(self.store_key, [])
+        store.logs["charger"].setdefault(
+            self.store_key, deque(maxlen=store.MAX_IN_MEMORY_LOG_ENTRIES)
+        )
         self.charger, created = await database_sync_to_async(
             Charger.objects.get_or_create
         )(
@@ -279,11 +319,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."""
@@ -300,15 +347,58 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             if not tag.allowed:
                 tag.allowed = True
                 updates.append("allowed")
+            if not tag.released:
+                tag.released = True
+                updates.append("released")
             if tag.last_seen_on != now:
                 tag.last_seen_on = now
                 updates.append("last_seen_on")
             if updates:
-                tag.save(update_fields=updates)
+                tag.save(update_fields=sorted(set(updates)))
             return tag
 
         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 _record_rfid_attempt(
+        self,
+        *,
+        rfid: str,
+        status: RFIDSessionAttempt.Status,
+        account: EnergyAccount | None,
+        transaction: Transaction | None = None,
+    ) -> None:
+        """Persist RFID session attempt metadata for reporting."""
+
+        normalized = (rfid or "").strip().upper()
+        if not normalized:
+            return
+
+        charger = self.charger
+
+        def _create_attempt() -> None:
+            RFIDSessionAttempt.objects.create(
+                charger=charger,
+                rfid=normalized,
+                status=status,
+                account=account,
+                transaction=transaction,
+            )
+
+        await database_sync_to_async(_create_attempt)()
+
     async def _assign_connector(self, connector: int | str | None) -> None:
         """Ensure ``self.charger`` matches the provided connector id."""
         if connector in (None, "", "-"):
@@ -345,7 +435,9 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                     await existing_consumer.close()
                 store.reassign_identity(previous_key, new_key)
                 store.connections[new_key] = self
-                store.logs["charger"].setdefault(new_key, [])
+                store.logs["charger"].setdefault(
+                    new_key, deque(maxlen=store.MAX_IN_MEMORY_LOG_ENTRIES)
+                )
             aggregate_name = await sync_to_async(
                 lambda: self.charger.name or self.charger.charger_id
             )()
@@ -414,7 +506,9 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                 await existing_consumer.close()
             store.reassign_identity(previous_key, new_key)
             store.connections[new_key] = self
-            store.logs["charger"].setdefault(new_key, [])
+            store.logs["charger"].setdefault(
+                new_key, deque(maxlen=store.MAX_IN_MEMORY_LOG_ENTRIES)
+            )
         connector_name = await sync_to_async(
             lambda: self.charger.name or self.charger.charger_id
         )()
@@ -613,6 +707,23 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             target.firmware_status_info = status_info
             target.firmware_timestamp = timestamp
 
+        def _update_deployments(ids: list[int]) -> None:
+            deployments = list(
+                CPFirmwareDeployment.objects.filter(
+                    charger_id__in=ids, completed_at__isnull=True
+                )
+            )
+            payload = {"status": status, "statusInfo": status_info}
+            for deployment in deployments:
+                deployment.mark_status(
+                    status,
+                    status_info,
+                    timestamp,
+                    response=payload,
+                )
+
+        await database_sync_to_async(_update_deployments)([target.pk for target in targets])
+
     async def _cancel_consumption_message(self) -> None:
         """Stop any scheduled consumption message updates."""
 
@@ -709,6 +820,136 @@ 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,
+            unknown_keys=unknown_values,
+            evcs_snapshot_at=timezone.now(),
+            raw_payload=raw_payload,
+        )
+        configuration.replace_configuration_keys(normalized_entries)
+        Charger.objects.filter(charger_id=self.charger_id).update(
+            configuration=configuration
+        )
+        return configuration
+
+    def _apply_change_configuration_snapshot(
+        self,
+        key: str,
+        value: str | None,
+        connector_hint: int | str | None,
+    ) -> ChargerConfiguration:
+        connector_value: int | None = None
+        if connector_hint not in (None, ""):
+            try:
+                connector_value = int(connector_hint)
+            except (TypeError, ValueError):
+                connector_value = None
+
+        queryset = ChargerConfiguration.objects.filter(
+            charger_identifier=self.charger_id
+        )
+        if connector_value is None:
+            queryset = queryset.filter(connector_id__isnull=True)
+        else:
+            queryset = queryset.filter(connector_id=connector_value)
+
+        configuration = queryset.order_by("-created_at").first()
+        if configuration is None:
+            configuration = ChargerConfiguration.objects.create(
+                charger_identifier=self.charger_id,
+                connector_id=connector_value,
+                unknown_keys=[],
+                evcs_snapshot_at=timezone.now(),
+                raw_payload={},
+            )
+
+        entries = configuration.configuration_keys
+        updated = False
+        for entry in entries:
+            if entry.get("key") == key:
+                updated = True
+                if value is None:
+                    entry.pop("value", None)
+                else:
+                    entry["value"] = value
+        if not updated:
+            new_entry: dict[str, object] = {"key": key, "readonly": False}
+            if value is not None:
+                new_entry["value"] = value
+            entries.append(new_entry)
+
+        configuration.replace_configuration_keys(entries)
+
+        raw_payload = configuration.raw_payload or {}
+        if not isinstance(raw_payload, dict):
+            raw_payload = {}
+        else:
+            raw_payload = dict(raw_payload)
+
+        payload_entries: list[dict[str, object]] = []
+        seen = False
+        for item in raw_payload.get("configurationKey", []):
+            if not isinstance(item, dict):
+                continue
+            entry_copy = dict(item)
+            if str(entry_copy.get("key") or "") == key:
+                if value is None:
+                    entry_copy.pop("value", None)
+                else:
+                    entry_copy["value"] = value
+                seen = True
+            payload_entries.append(entry_copy)
+        if not seen:
+            payload_entry: dict[str, object] = {"key": key}
+            if value is not None:
+                payload_entry["value"] = value
+            payload_entries.append(payload_entry)
+
+        raw_payload["configurationKey"] = payload_entries
+        configuration.raw_payload = raw_payload
+        configuration.evcs_snapshot_at = timezone.now()
+        configuration.save(update_fields=["raw_payload", "evcs_snapshot_at", "updated_at"])
+        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:
@@ -718,6 +959,46 @@ class CSMSConsumer(AsyncWebsocketConsumer):
         action = metadata.get("action")
         log_key = metadata.get("log_key") or self.store_key
         payload_data = payload if isinstance(payload, dict) else {}
+        if action == "ChangeConfiguration":
+            key_value = str(metadata.get("key") or "").strip()
+            status_value = str(payload_data.get("status") or "").strip()
+            stored_value = metadata.get("value")
+            parts: list[str] = []
+            if status_value:
+                parts.append(f"status={status_value}")
+            if key_value:
+                parts.append(f"key={key_value}")
+            if stored_value is not None:
+                parts.append(f"value={stored_value}")
+            message = "ChangeConfiguration result"
+            if parts:
+                message += ": " + ", ".join(parts)
+            store.add_log(log_key, message, log_type="charger")
+            if status_value.casefold() in {"accepted", "rebootrequired"} and key_value:
+                connector_hint = metadata.get("connector_id")
+
+                def _apply() -> ChargerConfiguration:
+                    return self._apply_change_configuration_snapshot(
+                        key_value,
+                        stored_value if isinstance(stored_value, str) else None,
+                        connector_hint,
+                    )
+
+                configuration = await database_sync_to_async(_apply)()
+                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,
+                payload=payload_data,
+            )
+            return
         if action == "DataTransfer":
             message_pk = metadata.get("message_pk")
             if not message_pk:
@@ -751,6 +1032,97 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                     ]
                 )
 
+            await database_sync_to_async(_apply)()
+            store.record_pending_call_result(
+                message_id,
+                metadata=metadata,
+                payload=payload_data,
+            )
+            return
+        if action == "SendLocalList":
+            status_value = str(payload_data.get("status") or "").strip()
+            version_candidate = (
+                payload_data.get("currentLocalListVersion")
+                or payload_data.get("listVersion")
+                or metadata.get("list_version")
+            )
+            message = "SendLocalList result"
+            if status_value:
+                message += f": status={status_value}"
+            if version_candidate is not None:
+                message += f", version={version_candidate}"
+            store.add_log(log_key, message, log_type="charger")
+            version_int = None
+            if version_candidate is not None:
+                try:
+                    version_int = int(version_candidate)
+                except (TypeError, ValueError):
+                    version_int = None
+            await self._update_local_authorization_state(version_int)
+            store.record_pending_call_result(
+                message_id,
+                metadata=metadata,
+                payload=payload_data,
+            )
+            return
+        if action == "GetLocalListVersion":
+            version_candidate = payload_data.get("listVersion")
+            processed = 0
+            auth_list = payload_data.get("localAuthorizationList")
+            if isinstance(auth_list, list):
+                processed = await self._apply_local_authorization_entries(auth_list)
+            message = "GetLocalListVersion result"
+            if version_candidate is not None:
+                message += f": version={version_candidate}"
+            if processed:
+                message += f", entries={processed}"
+            store.add_log(log_key, message, log_type="charger")
+            version_int = None
+            if version_candidate is not None:
+                try:
+                    version_int = int(version_candidate)
+                except (TypeError, ValueError):
+                    version_int = None
+            await self._update_local_authorization_state(version_int)
+            store.record_pending_call_result(
+                message_id,
+                metadata=metadata,
+                payload=payload_data,
+            )
+            return
+        if action == "ClearCache":
+            status_value = str(payload_data.get("status") or "").strip()
+            message = "ClearCache result"
+            if status_value:
+                message += f": status={status_value}"
+            store.add_log(log_key, message, log_type="charger")
+            version_int = 0 if status_value == "Accepted" else None
+            await self._update_local_authorization_state(version_int)
+            store.record_pending_call_result(
+                message_id,
+                metadata=metadata,
+                payload=payload_data,
+            )
+            return
+        if action == "UpdateFirmware":
+            deployment_pk = metadata.get("deployment_pk")
+
+            def _apply():
+                if not deployment_pk:
+                    return
+                deployment = CPFirmwareDeployment.objects.filter(
+                    pk=deployment_pk
+                ).first()
+                if not deployment:
+                    return
+                status_value = str(payload_data.get("status") or "").strip() or "Accepted"
+                deployment.mark_status(
+                    status_value,
+                    "",
+                    timezone.now(),
+                    response=payload_data,
+                )
+
             await database_sync_to_async(_apply)()
             store.record_pending_call_result(
                 message_id,
@@ -770,6 +1142,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 +1185,79 @@ 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 == "CancelReservation":
+            status_value = str(payload_data.get("status") or "").strip()
+            message = "CancelReservation 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 = ""
+                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,
+                payload=payload_data,
+            )
+            return
         if action == "RemoteStartTransaction":
             status_value = str(payload_data.get("status") or "").strip()
             message = "RemoteStartTransaction result"
@@ -876,6 +1332,36 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             return
         action = metadata.get("action")
         log_key = metadata.get("log_key") or self.store_key
+        if action == "ChangeConfiguration":
+            key_value = str(metadata.get("key") or "").strip()
+            parts: list[str] = []
+            if key_value:
+                parts.append(f"key={key_value}")
+            if error_code:
+                parts.append(f"code={str(error_code).strip()}")
+            if description:
+                parts.append(f"description={str(description).strip()}")
+            if details:
+                try:
+                    parts.append(
+                        "details="
+                        + json.dumps(details, sort_keys=True, ensure_ascii=False)
+                    )
+                except TypeError:
+                    parts.append(f"details={details}")
+            message = "ChangeConfiguration error"
+            if parts:
+                message += ": " + ", ".join(parts)
+            store.add_log(log_key, message, log_type="charger")
+            store.record_pending_call_result(
+                message_id,
+                metadata=metadata,
+                success=False,
+                error_code=error_code,
+                error_description=description,
+                error_details=details,
+            )
+            return
         if action == "DataTransfer":
             message_pk = metadata.get("message_pk")
             if not message_pk:
@@ -922,6 +1408,35 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                 error_details=details,
             )
             return
+        if action == "ClearCache":
+            parts: list[str] = []
+            code_text = (error_code or "").strip()
+            if code_text:
+                parts.append(f"code={code_text}")
+            description_text = (description or "").strip()
+            if description_text:
+                parts.append(f"description={description_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 = "ClearCache error"
+            if parts:
+                message += ": " + ", ".join(parts)
+            store.add_log(log_key, message, log_type="charger")
+            await self._update_local_authorization_state(None)
+            store.record_pending_call_result(
+                message_id,
+                metadata=metadata,
+                success=False,
+                error_code=error_code,
+                error_description=description,
+                error_details=details,
+            )
+            return
         if action == "GetConfiguration":
             parts: list[str] = []
             code_text = (error_code or "").strip()
@@ -983,6 +1498,173 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                 error_details=details,
             )
             return
+        if action == "UpdateFirmware":
+            deployment_pk = metadata.get("deployment_pk")
+
+            def _apply():
+                if not deployment_pk:
+                    return
+                deployment = CPFirmwareDeployment.objects.filter(
+                    pk=deployment_pk
+                ).first()
+                if not deployment:
+                    return
+                parts: list[str] = []
+                if error_code:
+                    parts.append(f"code={str(error_code).strip()}")
+                if description:
+                    parts.append(f"description={str(description).strip()}")
+                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 = "UpdateFirmware error"
+                if parts:
+                    message += ": " + ", ".join(parts)
+                deployment.mark_status(
+                    "Error",
+                    message,
+                    timezone.now(),
+                    response=details or {},
+                )
+                deployment.completed_at = timezone.now()
+                deployment.save(update_fields=["completed_at", "updated_at"])
+
+            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 == "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 == "CancelReservation":
+            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 = "CancelReservation 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:
@@ -1217,6 +1899,77 @@ class CSMSConsumer(AsyncWebsocketConsumer):
 
         await database_sync_to_async(_apply)()
 
+    async def _update_local_authorization_state(self, version: int | None) -> None:
+        """Persist the reported local authorization list version."""
+
+        timestamp = timezone.now()
+
+        def _apply() -> None:
+            updates: dict[str, object] = {"local_auth_list_updated_at": timestamp}
+            if version is not None:
+                updates["local_auth_list_version"] = int(version)
+
+            targets: list[Charger] = []
+            if self.charger and getattr(self.charger, "pk", None):
+                targets.append(self.charger)
+            aggregate = self.aggregate_charger
+            if (
+                aggregate
+                and getattr(aggregate, "pk", None)
+                and not any(target.pk == aggregate.pk for target in targets if target.pk)
+            ):
+                targets.append(aggregate)
+
+            if not targets:
+                return
+
+            for target in targets:
+                Charger.objects.filter(pk=target.pk).update(**updates)
+                for field, value in updates.items():
+                    setattr(target, field, value)
+
+        await database_sync_to_async(_apply)()
+
+    async def _apply_local_authorization_entries(
+        self, entries: list[dict[str, object]]
+    ) -> int:
+        """Create or update RFID records from a local authorization list."""
+
+        def _apply() -> int:
+            processed = 0
+            now = timezone.now()
+            for entry in entries:
+                if not isinstance(entry, dict):
+                    continue
+                id_tag = entry.get("idTag")
+                id_tag_text = str(id_tag or "").strip().upper()
+                if not id_tag_text:
+                    continue
+                info = entry.get("idTagInfo")
+                status_value = ""
+                if isinstance(info, dict):
+                    status_value = str(info.get("status") or "").strip()
+                status_key = status_value.lower()
+                allowed_flag = status_key in {"", "accepted", "concurrenttx"}
+                defaults = {"allowed": allowed_flag, "released": allowed_flag}
+                tag, _ = CoreRFID.update_or_create_from_code(id_tag_text, defaults)
+                updates: set[str] = set()
+                if tag.allowed != allowed_flag:
+                    tag.allowed = allowed_flag
+                    updates.add("allowed")
+                if tag.released != allowed_flag:
+                    tag.released = allowed_flag
+                    updates.add("released")
+                if tag.last_seen_on != now:
+                    tag.last_seen_on = now
+                    updates.add("last_seen_on")
+                if updates:
+                    tag.save(update_fields=sorted(updates))
+                processed += 1
+            return processed
+
+        return await database_sync_to_async(_apply)()
+
     async def _update_availability_state(
         self,
         state: str,
@@ -1321,8 +2074,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 +2153,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 +2245,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,
@@ -1509,12 +2296,23 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                     store.start_session_lock()
                     store.add_session_message(self.store_key, text_data)
                     await self._start_consumption_updates(tx_obj)
+                    await self._record_rfid_attempt(
+                        rfid=id_tag or "",
+                        status=RFIDSessionAttempt.Status.ACCEPTED,
+                        account=account,
+                        transaction=tx_obj,
+                    )
                     reply_payload = {
                         "transactionId": tx_obj.pk,
                         "idTagInfo": {"status": "Accepted"},
                     }
                 else:
                     reply_payload = {"idTagInfo": {"status": "Invalid"}}
+                    await self._record_rfid_attempt(
+                        rfid=id_tag or "",
+                        status=RFIDSessionAttempt.Status.REJECTED,
+                        account=account,
+                    )
             elif action == "StopTransaction":
                 tx_id = payload.get("transactionId")
                 tx_obj = store.transactions.pop(self.store_key, None)
@@ -1524,6 +2322,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 +2330,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)()