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

ocpp/consumers.py

@@ -3,6 +3,7 @@ import ipaddress
 import re
 from datetime import datetime
 import asyncio
+from collections import deque
 import inspect
 import json
 import logging
@@ -27,6 +28,8 @@ from .models import (
     MeterValue,
     DataTransferMessage,
     CPReservation,
+    CPFirmwareDeployment,
+    RFIDSessionAttempt,
 )
 from .reference_utils import host_is_local_loopback
 from .evcs_discovery import (
@@ -217,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):
@@ -276,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
         )(
@@ -330,11 +347,14 @@ 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)()
@@ -352,6 +372,33 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             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, "", "-"):
@@ -388,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
             )()
@@ -457,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
         )()
@@ -656,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."""
 
@@ -790,11 +858,93 @@ class CSMSConsumer(AsyncWebsocketConsumer):
         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,
         )
+        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
         )
@@ -809,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:
@@ -842,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,
@@ -934,6 +1215,42 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                     ]
                 )
 
+            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,
@@ -1015,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:
@@ -1061,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()
@@ -1122,6 +1498,53 @@ 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 ""
@@ -1145,6 +1568,66 @@ class CSMSConsumer(AsyncWebsocketConsumer):
 
             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
@@ -1416,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,
@@ -1742,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)