arthexis 0.1.19__py3-none-any.whl → 0.1.21__py3-none-any.whl

ocpp/admin.py

@@ -2,11 +2,12 @@ from django.contrib import admin, messages
 from django import forms
 
 import asyncio
-from datetime import timedelta
+from datetime import datetime, time, timedelta
 import json
 
 from django.shortcuts import redirect
 from django.utils import formats, timezone, translation
+from django.utils.html import format_html
 from django.urls import path
 from django.http import HttpResponse, HttpResponseRedirect
 from django.template.response import TemplateResponse
@@ -16,6 +17,7 @@ from asgiref.sync import async_to_sync
 
 from .models import (
     Charger,
+    ChargerConfiguration,
     Simulator,
     MeterValue,
     Transaction,
@@ -108,6 +110,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
@@ -207,7 +285,7 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
         ),
         (
             "Configuration",
-            {"fields": ("public_display", "require_rfid")},
+            {"fields": ("public_display", "require_rfid", "configuration")},
         ),
         (
             "References",
@@ -236,11 +314,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",
+        "charger_name_display",
         "require_rfid_display",
         "public_display",
         "last_heartbeat",
@@ -349,6 +428,21 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
                 return True
         return False
 
+    @admin.display(description="Display Name", ordering="display_name")
+    def display_name_with_fallback(self, obj):
+        return self._charger_display_name(obj)
+
+    @admin.display(description="Charger", ordering="display_name")
+    def charger_name_display(self, obj):
+        return self._charger_display_name(obj)
+
+    def _charger_display_name(self, obj):
+        if obj.display_name:
+            return obj.display_name
+        if obj.location:
+            return obj.location.name
+        return obj.charger_id
+
     def location_name(self, obj):
         return obj.location.name if obj.location else ""
 
@@ -710,6 +804,44 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
 
     session_kw.short_description = "Session kW"
 
+    def changelist_view(self, request, extra_context=None):
+        response = super().changelist_view(request, extra_context=extra_context)
+        if hasattr(response, "context_data"):
+            cl = response.context_data.get("cl")
+            if cl is not None:
+                response.context_data.update(
+                    self._charger_quick_stats_context(cl.queryset)
+                )
+        return response
+
+    def _charger_quick_stats_context(self, queryset):
+        chargers = list(queryset)
+        stats = {"total_kw": 0.0, "today_kw": 0.0}
+        if not chargers:
+            return {"charger_quick_stats": stats}
+
+        parent_ids = {c.charger_id for c in chargers if c.connector_id is None}
+        start, end = self._today_range()
+
+        for charger in chargers:
+            include_totals = True
+            if charger.connector_id is not None and charger.charger_id in parent_ids:
+                include_totals = False
+            if include_totals:
+                stats["total_kw"] += charger.total_kw
+                stats["today_kw"] += charger.total_kw_for_range(start, end)
+
+        stats = {key: round(value, 2) for key, value in stats.items()}
+        return {"charger_quick_stats": stats}
+
+    def _today_range(self):
+        today = timezone.localdate()
+        start = datetime.combine(today, time.min)
+        if timezone.is_naive(start):
+            start = timezone.make_aware(start, timezone.get_current_timezone())
+        end = start + timedelta(days=1)
+        return start, end
+
 
 @admin.register(Simulator)
 class SimulatorAdmin(SaveBeforeChangeAction, LogViewAdminMixin, EntityModelAdmin):
@@ -933,8 +1065,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",
@@ -946,6 +1080,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

@@ -204,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,
@@ -534,6 +544,20 @@ class Charger(Entity):
             return qs
         return qs.filter(pk=self.pk)
 
+    def total_kw_for_range(
+        self,
+        start=None,
+        end=None,
+    ) -> float:
+        """Return total energy delivered within ``start``/``end`` window."""
+
+        from . import store
+
+        total = 0.0
+        for charger in self._target_chargers():
+            total += charger._total_kw_range_single(store, start, end)
+        return total
+
     def _total_kw_single(self, store_module) -> float:
         """Return total kW for this specific charger identity."""
 
@@ -554,6 +578,40 @@ class Charger(Entity):
                 total += kw
         return total
 
+    def _total_kw_range_single(self, store_module, start=None, end=None) -> float:
+        """Return total kW for a date range for this charger."""
+
+        tx_active = None
+        if self.connector_id is not None:
+            tx_active = store_module.get_transaction(self.charger_id, self.connector_id)
+
+        qs = self.transactions.all()
+        if start is not None:
+            qs = qs.filter(start_time__gte=start)
+        if end is not None:
+            qs = qs.filter(start_time__lt=end)
+        if tx_active and tx_active.pk is not None:
+            qs = qs.exclude(pk=tx_active.pk)
+
+        total = 0.0
+        for tx in qs:
+            kw = tx.kw
+            if kw:
+                total += kw
+
+        if tx_active:
+            start_time = getattr(tx_active, "start_time", None)
+            include = True
+            if start is not None and start_time and start_time < start:
+                include = False
+            if end is not None and start_time and start_time >= end:
+                include = False
+            if include:
+                kw = tx_active.kw
+                if kw:
+                    total += kw
+        return total
+
     def purge(self):
         from . import store
 
@@ -585,6 +643,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."""
 
@@ -599,7 +702,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)
@@ -645,6 +759,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/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):