arthexis 0.1.18__py3-none-any.whl → 0.1.20__py3-none-any.whl

ocpp/admin.py

@@ -6,7 +6,7 @@ from datetime import timedelta
 import json
 
 from django.shortcuts import redirect
-from django.utils import timezone
+from django.utils import formats, timezone, translation
 from django.urls import path
 from django.http import HttpResponse, HttpResponseRedirect
 from django.template.response import TemplateResponse
@@ -16,6 +16,7 @@ from asgiref.sync import async_to_sync
 
 from .models import (
     Charger,
+    ChargerConfiguration,
     Simulator,
     MeterValue,
     Transaction,
@@ -108,6 +109,82 @@ class LogViewAdminMixin:
         return TemplateResponse(request, self.log_template_name, context)
 
 
+@admin.register(ChargerConfiguration)
+class ChargerConfigurationAdmin(admin.ModelAdmin):
+    list_display = ("charger_identifier", "connector_display", "created_at")
+    list_filter = ("connector_id",)
+    search_fields = ("charger_identifier",)
+    readonly_fields = (
+        "charger_identifier",
+        "connector_id",
+        "created_at",
+        "updated_at",
+        "linked_chargers",
+        "configuration_keys_display",
+        "unknown_keys_display",
+        "raw_payload_display",
+    )
+    fieldsets = (
+        (
+            None,
+            {
+                "fields": (
+                    "charger_identifier",
+                    "connector_id",
+                    "linked_chargers",
+                    "created_at",
+                    "updated_at",
+                )
+            },
+        ),
+        (
+            "Payload",
+            {
+                "fields": (
+                    "configuration_keys_display",
+                    "unknown_keys_display",
+                    "raw_payload_display",
+                )
+            },
+        ),
+    )
+
+    @admin.display(description="Connector")
+    def connector_display(self, obj):
+        if obj.connector_id is None:
+            return "All"
+        return obj.connector_id
+
+    @admin.display(description="Linked charge points")
+    def linked_chargers(self, obj):
+        if obj.pk is None:
+            return ""
+        linked = [charger.identity_slug() for charger in obj.chargers.all()]
+        if not linked:
+            return "-"
+        return ", ".join(sorted(linked))
+
+    def _render_json(self, data):
+        from django.utils.html import format_html
+
+        if not data:
+            return "-"
+        formatted = json.dumps(data, indent=2, ensure_ascii=False)
+        return format_html("<pre>{}</pre>", formatted)
+
+    @admin.display(description="configurationKey")
+    def configuration_keys_display(self, obj):
+        return self._render_json(obj.configuration_keys)
+
+    @admin.display(description="unknownKey")
+    def unknown_keys_display(self, obj):
+        return self._render_json(obj.unknown_keys)
+
+    @admin.display(description="Raw payload")
+    def raw_payload_display(self, obj):
+        return self._render_json(obj.raw_payload)
+
+
 @admin.register(Location)
 class LocationAdmin(EntityModelAdmin):
     form = LocationAdminForm
@@ -163,6 +240,7 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
                     "charger_id",
                     "display_name",
                     "connector_id",
+                    "language",
                     "location",
                     "last_path",
                     "last_heartbeat",
@@ -206,7 +284,7 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
         ),
         (
             "Configuration",
-            {"fields": ("public_display", "require_rfid")},
+            {"fields": ("public_display", "require_rfid", "configuration")},
         ),
         (
             "References",
@@ -235,11 +313,12 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
         "availability_request_status",
         "availability_request_status_at",
         "availability_request_details",
+        "configuration",
     )
     list_display = (
-        "charger_id",
+        "display_name_with_fallback",
         "connector_number",
-        "location_name",
+        "serial_number_display",
         "require_rfid_display",
         "public_display",
         "last_heartbeat",
@@ -348,6 +427,18 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
                 return True
         return False
 
+    @admin.display(description="Display Name", ordering="display_name")
+    def display_name_with_fallback(self, obj):
+        if obj.display_name:
+            return obj.display_name
+        if obj.location:
+            return obj.location.name
+        return obj.charger_id
+
+    @admin.display(description="Serial Number", ordering="charger_id")
+    def serial_number_display(self, obj):
+        return obj.charger_id
+
     def location_name(self, obj):
         return obj.location.name if obj.location else ""
 
@@ -719,7 +810,7 @@ class SimulatorAdmin(SaveBeforeChangeAction, LogViewAdminMixin, EntityModelAdmin
         "ws_port",
         "ws_url",
         "interval",
-        "kw_max",
+        "kw_max_display",
         "running",
         "log_link",
     )
@@ -759,6 +850,26 @@ class SimulatorAdmin(SaveBeforeChangeAction, LogViewAdminMixin, EntityModelAdmin
 
     log_type = "simulator"
 
+    @admin.display(description="kW Max", ordering="kw_max")
+    def kw_max_display(self, obj):
+        """Display ``kw_max`` with a dot decimal separator for Spanish locales."""
+
+        language = translation.get_language() or ""
+        if language.startswith("es"):
+            return formats.number_format(
+                obj.kw_max,
+                decimal_pos=2,
+                use_l10n=False,
+                force_grouping=False,
+            )
+
+        return formats.number_format(
+            obj.kw_max,
+            decimal_pos=2,
+            use_l10n=True,
+            force_grouping=False,
+        )
+
     def save_model(self, request, obj, form, change):
         previous_door_open = False
         if change and obj.pk:
@@ -912,8 +1023,10 @@ class TransactionAdmin(EntityModelAdmin):
     change_list_template = "admin/ocpp/transaction/change_list.html"
     list_display = (
         "charger",
+        "connector_number",
         "account",
         "rfid",
+        "vid",
         "meter_start",
         "meter_stop",
         "start_time",
@@ -925,6 +1038,12 @@ class TransactionAdmin(EntityModelAdmin):
     date_hierarchy = "start_time"
     inlines = [MeterValueInline]
 
+    def connector_number(self, obj):
+        return obj.connector_id or ""
+
+    connector_number.short_description = "#"
+    connector_number.admin_order_field = "connector_id"
+
     def get_urls(self):
         urls = super().get_urls()
         custom = [

ocpp/consumers.py

@@ -20,7 +20,13 @@ 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,
+)
 from .reference_utils import host_is_local_loopback
 from .evcs_discovery import (
     DEFAULT_CONSOLE_PORT,
@@ -138,6 +144,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."""
 
@@ -283,11 +301,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."""
@@ -726,6 +751,53 @@ class CSMSConsumer(AsyncWebsocketConsumer):
         task.add_done_callback(lambda _: setattr(self, "_consumption_task", None))
         self._consumption_task = task
 
+    def _persist_configuration_result(
+        self, payload: dict, connector_hint: int | str | None
+    ) -> ChargerConfiguration | None:
+        if not isinstance(payload, dict):
+            return None
+
+        connector_value: int | None = None
+        if connector_hint not in (None, ""):
+            try:
+                connector_value = int(connector_hint)
+            except (TypeError, ValueError):
+                connector_value = None
+
+        normalized_entries: list[dict[str, object]] = []
+        for entry in payload.get("configurationKey") or []:
+            if not isinstance(entry, dict):
+                continue
+            key = str(entry.get("key") or "")
+            normalized: dict[str, object] = {"key": key}
+            if "value" in entry:
+                normalized["value"] = entry.get("value")
+            normalized["readonly"] = bool(entry.get("readonly"))
+            normalized_entries.append(normalized)
+
+        unknown_values: list[str] = []
+        for value in payload.get("unknownKey") or []:
+            if value is None:
+                continue
+            unknown_values.append(str(value))
+
+        try:
+            raw_payload = json.loads(json.dumps(payload, ensure_ascii=False))
+        except (TypeError, ValueError):
+            raw_payload = payload
+
+        configuration = ChargerConfiguration.objects.create(
+            charger_identifier=self.charger_id,
+            connector_id=connector_value,
+            configuration_keys=normalized_entries,
+            unknown_keys=unknown_values,
+            raw_payload=raw_payload,
+        )
+        Charger.objects.filter(charger_id=self.charger_id).update(
+            configuration=configuration
+        )
+        return configuration
+
     async def _handle_call_result(self, message_id: str, payload: dict | None) -> None:
         metadata = store.pop_pending_call(message_id)
         if not metadata:
@@ -787,6 +859,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,
@@ -1338,8 +1421,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"))
@@ -1538,11 +1626,13 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                         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,
@@ -1568,6 +1658,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,
@@ -1575,12 +1666,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)()

ocpp/models.py

@@ -82,6 +82,13 @@ class Charger(Entity):
         default=True,
         help_text="Display this charger on the public status dashboard.",
     )
+    language = models.CharField(
+        _("Language"),
+        max_length=12,
+        choices=settings.LANGUAGES,
+        default="es",
+        help_text=_("Preferred language for the public landing page."),
+    )
     require_rfid = models.BooleanField(
         _("Require RFID Authorization"),
         default=False,
@@ -197,6 +204,16 @@ class Charger(Entity):
         related_name="chargers",
     )
     last_path = models.CharField(max_length=255, blank=True)
+    configuration = models.ForeignKey(
+        "ChargerConfiguration",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        related_name="chargers",
+        help_text=_(
+            "Latest GetConfiguration response received from this charge point."
+        ),
+    )
     manager_node = models.ForeignKey(
         "nodes.Node",
         on_delete=models.SET_NULL,
@@ -578,6 +595,51 @@ class Charger(Entity):
         super().delete(*args, **kwargs)
 
 
+class ChargerConfiguration(models.Model):
+    """Persisted configuration package returned by a charge point."""
+
+    charger_identifier = models.CharField(_("Serial Number"), max_length=100)
+    connector_id = models.PositiveIntegerField(
+        _("Connector ID"),
+        null=True,
+        blank=True,
+        help_text=_("Connector that returned this configuration (if specified)."),
+    )
+    configuration_keys = models.JSONField(
+        default=list,
+        blank=True,
+        help_text=_("Entries from the configurationKey list."),
+    )
+    unknown_keys = models.JSONField(
+        default=list,
+        blank=True,
+        help_text=_("Keys returned in the unknownKey list."),
+    )
+    raw_payload = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text=_("Raw payload returned by the GetConfiguration call."),
+    )
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        ordering = ["-created_at"]
+        verbose_name = _("CP Configuration")
+        verbose_name_plural = _("CP Configurations")
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        connector = (
+            _("connector %(number)s") % {"number": self.connector_id}
+            if self.connector_id is not None
+            else _("all connectors")
+        )
+        return _("%(serial)s configuration (%(connector)s)") % {
+            "serial": self.charger_identifier,
+            "connector": connector,
+        }
+
+
 class Transaction(Entity):
     """Charging session data stored for each charger."""
 
@@ -592,7 +654,18 @@ class Transaction(Entity):
         blank=True,
         verbose_name=_("RFID"),
     )
-    vin = models.CharField(max_length=17, blank=True)
+    vid = models.CharField(
+        max_length=64,
+        blank=True,
+        default="",
+        verbose_name=_("VID"),
+        help_text=_("Vehicle identifier reported by the charger."),
+    )
+    vin = models.CharField(
+        max_length=17,
+        blank=True,
+        help_text=_("Deprecated. Use VID instead."),
+    )
     connector_id = models.PositiveIntegerField(null=True, blank=True)
     meter_start = models.IntegerField(null=True, blank=True)
     meter_stop = models.IntegerField(null=True, blank=True)
@@ -638,6 +711,22 @@ class Transaction(Entity):
         verbose_name = _("Transaction")
         verbose_name_plural = _("CP Transactions")
 
+    @property
+    def vehicle_identifier(self) -> str:
+        """Return the preferred vehicle identifier for this transaction."""
+
+        return (self.vid or self.vin or "").strip()
+
+    @property
+    def vehicle_identifier_source(self) -> str:
+        """Return which field supplies :pyattr:`vehicle_identifier`."""
+
+        if (self.vid or "").strip():
+            return "vid"
+        if (self.vin or "").strip():
+            return "vin"
+        return ""
+
     @property
     def kw(self) -> float:
         """Return consumed energy in kW for this session."""

ocpp/store.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-from datetime import datetime
+from datetime import datetime, timezone
 import json
 from pathlib import Path
 import re
@@ -427,7 +427,7 @@ def _file_path(cid: str, log_type: str = "charger") -> Path:
 def add_log(cid: str, entry: str, log_type: str = "charger") -> None:
     """Append a timestamped log entry for the given id and log type."""
 
-    timestamp = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
+    timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
     entry = f"{timestamp} {entry}"
 
     store = logs[log_type]
@@ -454,7 +454,7 @@ def start_session_log(cid: str, tx_id: int) -> None:
 
     history[cid] = {
         "transaction": tx_id,
-        "start": datetime.utcnow(),
+        "start": datetime.now(timezone.utc),
         "messages": [],
     }
 
@@ -467,7 +467,9 @@ def add_session_message(cid: str, message: str) -> None:
         return
     sess["messages"].append(
         {
-            "timestamp": datetime.utcnow().isoformat() + "Z",
+            "timestamp": datetime.now(timezone.utc)
+            .isoformat()
+            .replace("+00:00", "Z"),
             "message": message,
         }
     )

ocpp/tasks.py

@@ -149,6 +149,10 @@ def send_daily_session_report() -> int:
         lines.append(f"   Account: {account}")
         if transaction.rfid:
             lines.append(f"   RFID: {transaction.rfid}")
+        identifier = transaction.vehicle_identifier
+        if identifier:
+            label = "VID" if transaction.vehicle_identifier_source == "vid" else "VIN"
+            lines.append(f"   {label}: {identifier}")
         if connector:
             lines.append(f"   {connector}")
         lines.append(

ocpp/test_export_import.py

@@ -111,6 +111,7 @@ class TransactionAdminExportImportTests(TestCase):
                     "charger": "C9",
                     "account": None,
                     "rfid": "",
+                    "vid": "",
                     "vin": "",
                     "meter_start": 0,
                     "meter_stop": 0,

ocpp/test_rfid.py

@@ -771,7 +771,9 @@ class RFIDLandingTests(TestCase):
         app = Application.objects.create(name="Ocpp")
         module = Module.objects.create(node_role=role, application=app, path="/ocpp/")
         module.create_landings()
-        self.assertTrue(module.landings.filter(path="/ocpp/rfid/").exists())
+        self.assertTrue(
+            module.landings.filter(path="/ocpp/rfid/validator/").exists()
+        )
 
 
 class ScannerTemplateTests(TestCase):