arthexis 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

ocpp/consumers.py

@@ -1,12 +1,14 @@
-import asyncio
-import json
 import base64
 import ipaddress
 import re
 from datetime import datetime
+import asyncio
+import inspect
+import json
 from django.utils import timezone
 from core.models import EnergyAccount, Reference, RFID as CoreRFID
 from nodes.models import NetMessage
+from django.core.exceptions import ValidationError
 
 from channels.generic.websocket import AsyncWebsocketConsumer
 from channels.db import database_sync_to_async
@@ -16,7 +18,15 @@ 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
+from .models import Transaction, Charger, MeterValue, DataTransferMessage
+from .reference_utils import host_is_local_loopback
+from .evcs_discovery import (
+    DEFAULT_CONSOLE_PORT,
+    HTTPS_PORTS,
+    build_console_url,
+    prioritise_ports,
+    scan_open_ports,
+)
 
 FORWARDED_PAIR_RE = re.compile(r"for=(?:\"?)(?P<value>[^;,\"\s]+)(?:\"?)", re.IGNORECASE)
 
@@ -129,7 +139,20 @@ class CSMSConsumer(AsyncWebsocketConsumer):
 
     @requires_network
     async def connect(self):
-        self.charger_id = self.scope["url_route"]["kwargs"].get("cid", "")
+        raw_serial = self.scope["url_route"]["kwargs"].get("cid", "")
+        try:
+            self.charger_id = Charger.validate_serial(raw_serial)
+        except ValidationError as exc:
+            serial = Charger.normalize_serial(raw_serial)
+            store_key = store.pending_key(serial)
+            message = exc.messages[0] if exc.messages else "Invalid Serial Number"
+            store.add_log(
+                store_key,
+                f"Rejected connection: {message}",
+                log_type="charger",
+            )
+            await self.close(code=4003)
+            return
         self.connector_value: int | None = None
         self.store_key = store.pending_key(self.charger_id)
         self.aggregate_charger: Charger | None = None
@@ -287,19 +310,26 @@ class CSMSConsumer(AsyncWebsocketConsumer):
         serial = (self.charger_id or "").strip()
         if not ip or not serial:
             return
+        if host_is_local_loopback(ip):
+            return
         host = ip
-        if ":" in host and not host.startswith("["):
-            host = f"[{host}]"
-        url = f"http://{host}:8900"
+        ports = scan_open_ports(host)
+        if ports:
+            ordered_ports = prioritise_ports(ports)
+        else:
+            ordered_ports = prioritise_ports([DEFAULT_CONSOLE_PORT])
+        port = ordered_ports[0] if ordered_ports else DEFAULT_CONSOLE_PORT
+        secure = port in HTTPS_PORTS
+        url = build_console_url(host, port, secure)
         alt_text = f"{serial} Console"
-        reference, _ = Reference.objects.get_or_create(
-            alt_text=alt_text,
-            defaults={
-                "value": url,
-                "show_in_header": True,
-                "method": "link",
-            },
-        )
+        reference = Reference.objects.filter(alt_text=alt_text).order_by("id").first()
+        if reference is None:
+            reference = Reference.objects.create(
+                alt_text=alt_text,
+                value=url,
+                show_in_header=True,
+                method="link",
+            )
         updated_fields: list[str] = []
         if reference.value != url:
             reference.value = url
@@ -550,6 +580,435 @@ class CSMSConsumer(AsyncWebsocketConsumer):
         task.add_done_callback(lambda _: setattr(self, "_consumption_task", None))
         self._consumption_task = task
 
+    async def _handle_call_result(self, message_id: str, payload: dict | None) -> None:
+        metadata = store.pop_pending_call(message_id)
+        if not metadata:
+            return
+        if metadata.get("charger_id") and metadata.get("charger_id") != self.charger_id:
+            return
+        action = metadata.get("action")
+        log_key = metadata.get("log_key") or self.store_key
+        if action == "DataTransfer":
+            message_pk = metadata.get("message_pk")
+            if not message_pk:
+                return
+
+            def _apply():
+                message = DataTransferMessage.objects.filter(pk=message_pk).first()
+                if not message:
+                    return
+                status_value = str((payload or {}).get("status") or "").strip()
+                message.status = status_value
+                message.response_data = (payload or {}).get("data")
+                message.error_code = ""
+                message.error_description = ""
+                message.error_details = None
+                message.responded_at = timezone.now()
+                message.save(
+                    update_fields=[
+                        "status",
+                        "response_data",
+                        "error_code",
+                        "error_description",
+                        "error_details",
+                        "responded_at",
+                        "updated_at",
+                    ]
+                )
+
+            await database_sync_to_async(_apply)()
+            return
+        if action == "GetConfiguration":
+            payload_data = payload if isinstance(payload, dict) else {}
+            try:
+                payload_text = json.dumps(
+                    payload_data, sort_keys=True, ensure_ascii=False
+                )
+            except TypeError:
+                payload_text = str(payload_data)
+            store.add_log(
+                log_key,
+                f"GetConfiguration result: {payload_text}",
+                log_type="charger",
+            )
+            return
+        if action == "TriggerMessage":
+            payload_data = payload if isinstance(payload, dict) else {}
+            status_value = str(payload_data.get("status") or "").strip()
+            target = metadata.get("trigger_target") or metadata.get("follow_up_action")
+            connector_value = metadata.get("trigger_connector")
+            message = "TriggerMessage result"
+            if target:
+                message = f"TriggerMessage {target} result"
+            if status_value:
+                message += f": status={status_value}"
+            if connector_value:
+                message += f", connector={connector_value}"
+            store.add_log(log_key, message, log_type="charger")
+            if status_value == "Accepted" and target:
+                store.register_triggered_followup(
+                    self.charger_id,
+                    str(target),
+                    connector=connector_value,
+                    log_key=log_key,
+                    target=str(target),
+                )
+            return
+        if action == "RemoteStartTransaction":
+            payload_data = payload if isinstance(payload, dict) else {}
+            status_value = str(payload_data.get("status") or "").strip()
+            message = "RemoteStartTransaction result"
+            if status_value:
+                message += f": status={status_value}"
+            store.add_log(log_key, message, log_type="charger")
+            return
+        if action == "RemoteStopTransaction":
+            payload_data = payload if isinstance(payload, dict) else {}
+            status_value = str(payload_data.get("status") or "").strip()
+            message = "RemoteStopTransaction result"
+            if status_value:
+                message += f": status={status_value}"
+            store.add_log(log_key, message, log_type="charger")
+            return
+        if action == "Reset":
+            payload_data = payload if isinstance(payload, dict) else {}
+            status_value = str(payload_data.get("status") or "").strip()
+            message = "Reset result"
+            if status_value:
+                message += f": status={status_value}"
+            store.add_log(log_key, message, log_type="charger")
+            return
+        if action != "ChangeAvailability":
+            return
+        status = str((payload or {}).get("status") or "").strip()
+        requested_type = metadata.get("availability_type")
+        connector_value = metadata.get("connector_id")
+        requested_at = metadata.get("requested_at")
+        await self._update_change_availability_state(
+            connector_value,
+            requested_type,
+            status,
+            requested_at,
+            details="",
+        )
+
+    async def _handle_call_error(
+        self,
+        message_id: str,
+        error_code: str | None,
+        description: str | None,
+        details: dict | None,
+    ) -> None:
+        metadata = store.pop_pending_call(message_id)
+        if not metadata:
+            return
+        if metadata.get("charger_id") and metadata.get("charger_id") != self.charger_id:
+            return
+        action = metadata.get("action")
+        log_key = metadata.get("log_key") or self.store_key
+        if action == "DataTransfer":
+            message_pk = metadata.get("message_pk")
+            if not message_pk:
+                return
+
+            def _apply():
+                message = DataTransferMessage.objects.filter(pk=message_pk).first()
+                if not message:
+                    return
+                status_value = (error_code or "Error").strip() or "Error"
+                message.status = status_value
+                message.response_data = None
+                message.error_code = (error_code or "").strip()
+                message.error_description = (description or "").strip()
+                message.error_details = details
+                message.responded_at = timezone.now()
+                message.save(
+                    update_fields=[
+                        "status",
+                        "response_data",
+                        "error_code",
+                        "error_description",
+                        "error_details",
+                        "responded_at",
+                        "updated_at",
+                    ]
+                )
+
+            await database_sync_to_async(_apply)()
+            return
+        if action == "GetConfiguration":
+            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}")
+            if parts:
+                message = "GetConfiguration error: " + ", ".join(parts)
+            else:
+                message = "GetConfiguration error"
+            store.add_log(log_key, message, log_type="charger")
+            return
+        if action == "TriggerMessage":
+            target = metadata.get("trigger_target") or metadata.get("follow_up_action")
+            connector_value = metadata.get("trigger_connector")
+            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:
+                    parts.append(
+                        "details="
+                        + json.dumps(details, sort_keys=True, ensure_ascii=False)
+                    )
+                except TypeError:
+                    parts.append(f"details={details}")
+            label = f"TriggerMessage {target}" if target else "TriggerMessage"
+            message = label + " error"
+            if parts:
+                message += ": " + ", ".join(parts)
+            if connector_value:
+                message += f", connector={connector_value}"
+            store.add_log(log_key, message, log_type="charger")
+            return
+        if action == "RemoteStartTransaction":
+            message = "RemoteStartTransaction error"
+            if error_code:
+                message += f": code={str(error_code).strip()}"
+            if description:
+                suffix = str(description).strip()
+                if suffix:
+                    message += f", description={suffix}"
+            store.add_log(log_key, message, log_type="charger")
+            return
+        if action == "RemoteStopTransaction":
+            message = "RemoteStopTransaction error"
+            if error_code:
+                message += f": code={str(error_code).strip()}"
+            if description:
+                suffix = str(description).strip()
+                if suffix:
+                    message += f", description={suffix}"
+            store.add_log(log_key, message, log_type="charger")
+            return
+        if action == "Reset":
+            message = "Reset error"
+            if error_code:
+                message += f": code={str(error_code).strip()}"
+            if description:
+                suffix = str(description).strip()
+                if suffix:
+                    message += f", description={suffix}"
+            store.add_log(log_key, message, log_type="charger")
+            return
+        if action != "ChangeAvailability":
+            return
+        detail_text = (description or "").strip()
+        if not detail_text and details:
+            try:
+                detail_text = json.dumps(details, sort_keys=True)
+            except Exception:
+                detail_text = str(details)
+        if not detail_text:
+            detail_text = (error_code or "").strip() or "Error"
+        requested_type = metadata.get("availability_type")
+        connector_value = metadata.get("connector_id")
+        requested_at = metadata.get("requested_at")
+        await self._update_change_availability_state(
+            connector_value,
+            requested_type,
+            "Rejected",
+            requested_at,
+            details=detail_text,
+        )
+
+    async def _handle_data_transfer(
+        self, message_id: str, payload: dict | None
+    ) -> dict[str, object]:
+        payload = payload if isinstance(payload, dict) else {}
+        vendor_id = str(payload.get("vendorId") or "").strip()
+        vendor_message_id = payload.get("messageId")
+        if vendor_message_id is None:
+            vendor_message_id_text = ""
+        elif isinstance(vendor_message_id, str):
+            vendor_message_id_text = vendor_message_id.strip()
+        else:
+            vendor_message_id_text = str(vendor_message_id)
+        connector_value = self.connector_value
+
+        def _get_or_create_charger():
+            if self.charger and getattr(self.charger, "pk", None):
+                return self.charger
+            if connector_value is None:
+                charger, _ = Charger.objects.get_or_create(
+                    charger_id=self.charger_id,
+                    connector_id=None,
+                    defaults={"last_path": self.scope.get("path", "")},
+                )
+                return charger
+            charger, _ = Charger.objects.get_or_create(
+                charger_id=self.charger_id,
+                connector_id=connector_value,
+                defaults={"last_path": self.scope.get("path", "")},
+            )
+            return charger
+
+        charger_obj = await database_sync_to_async(_get_or_create_charger)()
+        message = await database_sync_to_async(DataTransferMessage.objects.create)(
+            charger=charger_obj,
+            connector_id=connector_value,
+            direction=DataTransferMessage.DIRECTION_CP_TO_CSMS,
+            ocpp_message_id=message_id,
+            vendor_id=vendor_id,
+            message_id=vendor_message_id_text,
+            payload=payload or {},
+            status="Pending",
+        )
+
+        status = "Rejected" if not vendor_id else "UnknownVendorId"
+        response_data = None
+        error_code = ""
+        error_description = ""
+        error_details = None
+
+        handler = self._resolve_data_transfer_handler(vendor_id) if vendor_id else None
+        if handler:
+            try:
+                result = handler(message, payload)
+                if inspect.isawaitable(result):
+                    result = await result
+            except Exception as exc:  # pragma: no cover - defensive guard
+                status = "Rejected"
+                error_code = "InternalError"
+                error_description = str(exc)
+            else:
+                if isinstance(result, tuple):
+                    status = str(result[0]) if result else status
+                    if len(result) > 1:
+                        response_data = result[1]
+                elif isinstance(result, dict):
+                    status = str(result.get("status", status))
+                    if "data" in result:
+                        response_data = result["data"]
+                elif isinstance(result, str):
+                    status = result
+        final_status = status or "Rejected"
+
+        def _finalise():
+            DataTransferMessage.objects.filter(pk=message.pk).update(
+                status=final_status,
+                response_data=response_data,
+                error_code=error_code,
+                error_description=error_description,
+                error_details=error_details,
+                responded_at=timezone.now(),
+            )
+
+        await database_sync_to_async(_finalise)()
+
+        reply_payload: dict[str, object] = {"status": final_status}
+        if response_data is not None:
+            reply_payload["data"] = response_data
+        return reply_payload
+
+    def _resolve_data_transfer_handler(self, vendor_id: str):
+        if not vendor_id:
+            return None
+        candidate = f"handle_data_transfer_{vendor_id.lower()}"
+        return getattr(self, candidate, None)
+
+    async def _update_change_availability_state(
+        self,
+        connector_value: int | None,
+        requested_type: str | None,
+        status: str,
+        requested_at,
+        *,
+        details: str = "",
+    ) -> None:
+        status_value = status or ""
+        now = timezone.now()
+
+        def _apply():
+            filters: dict[str, object] = {"charger_id": self.charger_id}
+            if connector_value is None:
+                filters["connector_id__isnull"] = True
+            else:
+                filters["connector_id"] = connector_value
+            targets = list(Charger.objects.filter(**filters))
+            if not targets:
+                return
+            for target in targets:
+                updates: dict[str, object] = {
+                    "availability_request_status": status_value,
+                    "availability_request_status_at": now,
+                    "availability_request_details": details,
+                }
+                if requested_type:
+                    updates["availability_requested_state"] = requested_type
+                if requested_at:
+                    updates["availability_requested_at"] = requested_at
+                elif requested_type:
+                    updates["availability_requested_at"] = now
+                if status_value == "Accepted" and requested_type:
+                    updates["availability_state"] = requested_type
+                    updates["availability_state_updated_at"] = now
+                Charger.objects.filter(pk=target.pk).update(**updates)
+                for field, value in updates.items():
+                    setattr(target, field, value)
+                if self.charger and self.charger.pk == target.pk:
+                    for field, value in updates.items():
+                        setattr(self.charger, field, value)
+                if self.aggregate_charger and self.aggregate_charger.pk == target.pk:
+                    for field, value in updates.items():
+                        setattr(self.aggregate_charger, field, value)
+
+        await database_sync_to_async(_apply)()
+
+    async def _update_availability_state(
+        self,
+        state: str,
+        timestamp: datetime,
+        connector_value: int | None,
+    ) -> None:
+        def _apply():
+            filters: dict[str, object] = {"charger_id": self.charger_id}
+            if connector_value is None:
+                filters["connector_id__isnull"] = True
+            else:
+                filters["connector_id"] = connector_value
+            updates = {
+                "availability_state": state,
+                "availability_state_updated_at": timestamp,
+            }
+            targets = list(Charger.objects.filter(**filters))
+            if not targets:
+                return
+            Charger.objects.filter(pk__in=[target.pk for target in targets]).update(
+                **updates
+            )
+            for target in targets:
+                for field, value in updates.items():
+                    setattr(target, field, value)
+                if self.charger and self.charger.pk == target.pk:
+                    for field, value in updates.items():
+                        setattr(self.charger, field, value)
+                if self.aggregate_charger and self.aggregate_charger.pk == target.pk:
+                    for field, value in updates.items():
+                        setattr(self.aggregate_charger, field, value)
+
+        await database_sync_to_async(_apply)()
+
     async def disconnect(self, close_code):
         store.release_ip_connection(getattr(self, "client_ip", None), self)
         tx_obj = None
@@ -564,6 +1023,7 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             store.connections.pop(pending_key, None)
         store.end_session_log(self.store_key)
         store.stop_session_lock()
+        store.clear_pending_calls(self.charger_id)
         store.add_log(self.store_key, f"Closed (code={close_code})", log_type="charger")
 
     async def receive(self, text_data=None, bytes_data=None):
@@ -578,10 +1038,34 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             msg = json.loads(raw)
         except json.JSONDecodeError:
             return
-        if isinstance(msg, list) and msg and msg[0] == 2:
+        if not isinstance(msg, list) or not msg:
+            return
+        message_type = msg[0]
+        if message_type == 2:
             msg_id, action = msg[1], msg[2]
             payload = msg[3] if len(msg) > 3 else {}
             reply_payload = {}
+            connector_hint = None
+            if isinstance(payload, dict):
+                connector_hint = payload.get("connectorId")
+            follow_up = store.consume_triggered_followup(
+                self.charger_id, action, connector_hint
+            )
+            if follow_up:
+                follow_up_log_key = follow_up.get("log_key") or self.store_key
+                target_label = follow_up.get("target") or action
+                connector_slug_value = follow_up.get("connector")
+                suffix = ""
+                if (
+                    connector_slug_value
+                    and connector_slug_value != store.AGGREGATE_SLUG
+                ):
+                    suffix = f" (connector {connector_slug_value})"
+                store.add_log(
+                    follow_up_log_key,
+                    f"TriggerMessage follow-up received: {target_label}{suffix}",
+                    log_type="charger",
+                )
             await self._assign_connector(payload.get("connectorId"))
             if action == "BootNotification":
                 reply_payload = {
@@ -589,6 +1073,8 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                     "interval": 300,
                     "status": "Accepted",
                 }
+            elif action == "DataTransfer":
+                reply_payload = await self._handle_data_transfer(msg_id, payload)
             elif action == "Heartbeat":
                 reply_payload = {"currentTime": datetime.utcnow().isoformat() + "Z"}
                 now = timezone.now()
@@ -652,6 +1138,11 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                     f"StatusNotification processed: {json.dumps(payload, sort_keys=True)}",
                     log_type="charger",
                 )
+                availability_state = Charger.availability_state_from_status(status)
+                if availability_state:
+                    await self._update_availability_state(
+                        availability_state, status_timestamp, self.connector_value
+                    )
                 reply_payload = {}
             elif action == "Authorize":
                 account = await self._get_account(payload.get("idTag"))
@@ -839,3 +1330,13 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             store.add_log(
                 self.store_key, f"< {json.dumps(response)}", log_type="charger"
             )
+        elif message_type == 3:
+            msg_id = msg[1] if len(msg) > 1 else ""
+            payload = msg[2] if len(msg) > 2 else {}
+            await self._handle_call_result(msg_id, payload)
+        elif message_type == 4:
+            msg_id = msg[1] if len(msg) > 1 else ""
+            error_code = msg[2] if len(msg) > 2 else ""
+            description = msg[3] if len(msg) > 3 else ""
+            details = msg[4] if len(msg) > 4 else {}
+            await self._handle_call_error(msg_id, error_code, description, details)