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

ocpp/tests.py

@@ -61,13 +61,14 @@ from config.asgi import application
 from .models import (
     Transaction,
     Charger,
+    ChargerConfiguration,
     Simulator,
     MeterReading,
     Location,
     DataTransferMessage,
 )
 from .consumers import CSMSConsumer
-from .views import dispatch_action
+from .views import dispatch_action, _transaction_rfid_details
 from .status_display import STATUS_BADGE_MAP
 from core.models import EnergyAccount, EnergyCredit, Reference, RFID, SecurityGroup
 from . import store
@@ -714,6 +715,13 @@ class CSMSConsumerTests(TransactionTestCase):
         connected, _ = await communicator.connect()
         self.assertTrue(connected)
 
+        await database_sync_to_async(Charger.objects.get_or_create)(
+            charger_id="CFGRES", connector_id=1
+        )
+        await database_sync_to_async(Charger.objects.get_or_create)(
+            charger_id="CFGRES", connector_id=2
+        )
+
         message_id = "cfg-result"
         payload = {
             "configurationKey": [
@@ -744,6 +752,31 @@ class CSMSConsumerTests(TransactionTestCase):
         )
         self.assertNotIn(message_id, store.pending_calls)
 
+        configuration = await database_sync_to_async(
+            lambda: ChargerConfiguration.objects.order_by("-created_at").first()
+        )()
+        self.assertIsNotNone(configuration)
+        self.assertEqual(configuration.charger_identifier, "CFGRES")
+        self.assertEqual(
+            configuration.configuration_keys,
+            [
+                {
+                    "key": "AllowOfflineTxForUnknownId",
+                    "value": "false",
+                    "readonly": True,
+                }
+            ],
+        )
+        self.assertEqual(configuration.unknown_keys, [])
+        config_ids = await database_sync_to_async(
+            lambda: set(
+                Charger.objects.filter(charger_id="CFGRES").values_list(
+                    "configuration_id", flat=True
+                )
+            )
+        )()
+        self.assertEqual(config_ids, {configuration.pk})
+
         await communicator.disconnect()
         store.clear_log(log_key, log_type="charger")
         store.clear_log(pending_key, log_type="charger")
@@ -1109,7 +1142,7 @@ class CSMSConsumerTests(TransactionTestCase):
 
         await communicator.disconnect()
 
-    async def test_vin_recorded(self):
+    async def test_vid_populated_from_vin(self):
         await database_sync_to_async(Charger.objects.create)(charger_id="VINREC")
         communicator = WebsocketCommunicator(application, "/VINREC/")
         connected, _ = await communicator.connect()
@@ -1124,7 +1157,29 @@ class CSMSConsumerTests(TransactionTestCase):
         tx = await database_sync_to_async(Transaction.objects.get)(
             pk=tx_id, charger__charger_id="VINREC"
         )
-        self.assertEqual(tx.vin, "WP0ZZZ11111111111")
+        self.assertEqual(tx.vid, "WP0ZZZ11111111111")
+        self.assertEqual(tx.vehicle_identifier, "WP0ZZZ11111111111")
+        self.assertEqual(tx.vehicle_identifier_source, "vid")
+
+        await communicator.disconnect()
+
+    async def test_vid_recorded(self):
+        await database_sync_to_async(Charger.objects.create)(charger_id="VIDREC")
+        communicator = WebsocketCommunicator(application, "/VIDREC/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.send_json_to(
+            [2, "1", "StartTransaction", {"meterStart": 1, "vid": "VID123456"}]
+        )
+        response = await communicator.receive_json_from()
+        tx_id = response[2]["transactionId"]
+
+        tx = await database_sync_to_async(Transaction.objects.get)(
+            pk=tx_id, charger__charger_id="VIDREC"
+        )
+        self.assertEqual(tx.vid, "VID123456")
+        self.assertEqual(tx.rfid, "")
 
         await communicator.disconnect()
 
@@ -2126,12 +2181,12 @@ class SimulatorLandingTests(TestCase):
     @skip("Navigation links unavailable in test environment")
     def test_simulator_app_link_in_nav(self):
         resp = self.client.get(reverse("pages:index"))
-        self.assertContains(resp, "/ocpp/")
-        self.assertNotContains(resp, "/ocpp/simulator/")
+        self.assertContains(resp, "/ocpp/cpms/dashboard/")
+        self.assertNotContains(resp, "/ocpp/evcs/simulator/")
         self.client.force_login(self.user)
         resp = self.client.get(reverse("pages:index"))
-        self.assertContains(resp, "/ocpp/")
-        self.assertContains(resp, "/ocpp/simulator/")
+        self.assertContains(resp, "/ocpp/cpms/dashboard/")
+        self.assertContains(resp, "/ocpp/evcs/simulator/")
 
     def test_cp_simulator_redirects_to_login(self):
         response = self.client.get(reverse("cp-simulator"))
@@ -2280,6 +2335,36 @@ class ChargerAdminTests(TestCase):
         resp = self.client.get(url)
         self.assertContains(resp, "AdminLoc")
 
+    def test_admin_changelist_displays_quick_stats(self):
+        charger = Charger.objects.create(charger_id="STATMAIN", display_name="Main EVCS")
+        connector = Charger.objects.create(
+            charger_id="STATMAIN", connector_id=1, display_name="Connector 1"
+        )
+        start = timezone.now() - timedelta(minutes=30)
+        Transaction.objects.create(
+            charger=connector,
+            start_time=start,
+            stop_time=start + timedelta(minutes=10),
+            meter_start=1000,
+            meter_stop=6000,
+        )
+
+        url = reverse("admin:ocpp_charger_changelist")
+        resp = self.client.get(url)
+
+        self.assertContains(resp, "Total kW")
+        self.assertContains(resp, "Today kW")
+        self.assertContains(resp, "5.00")
+
+    def test_admin_changelist_does_not_indent_connectors(self):
+        Charger.objects.create(charger_id="INDENTMAIN")
+        Charger.objects.create(charger_id="INDENTMAIN", connector_id=1)
+
+        url = reverse("admin:ocpp_charger_changelist")
+        resp = self.client.get(url)
+
+        self.assertNotContains(resp, 'class="charger-connector-entry"')
+
     def test_last_fields_are_read_only(self):
         now = timezone.now()
         charger = Charger.objects.create(
@@ -3212,8 +3297,7 @@ class SimulatorAdminTests(TransactionTestCase):
         self.assertIsNotNone(aggregate.last_heartbeat)
         if previous_heartbeat:
             self.assertNotEqual(aggregate.last_heartbeat, previous_heartbeat)
-        if connector.last_heartbeat:
-            self.assertNotEqual(aggregate.last_heartbeat, connector.last_heartbeat)
+        self.assertEqual(connector.last_heartbeat, aggregate.last_heartbeat)
 
         await communicator.disconnect()
 
@@ -4009,6 +4093,43 @@ class TransactionKwTests(TestCase):
         self.assertEqual(tx.kw, 0.0)
 
 
+class TransactionIdentifierTests(TestCase):
+    def test_vehicle_identifier_prefers_vid(self):
+        charger = Charger.objects.create(charger_id="VIDPREF")
+        tx = Transaction.objects.create(
+            charger=charger,
+            start_time=timezone.now(),
+            vid="VID-123",
+            vin="VIN-456",
+        )
+        self.assertEqual(tx.vehicle_identifier, "VID-123")
+        self.assertEqual(tx.vehicle_identifier_source, "vid")
+
+    def test_vehicle_identifier_falls_back_to_vin(self):
+        charger = Charger.objects.create(charger_id="VINONLY")
+        tx = Transaction.objects.create(
+            charger=charger,
+            start_time=timezone.now(),
+            vin="WP0ZZZ00000000001",
+        )
+        self.assertEqual(tx.vehicle_identifier, "WP0ZZZ00000000001")
+        self.assertEqual(tx.vehicle_identifier_source, "vin")
+
+    def test_transaction_rfid_details_handles_vin(self):
+        charger = Charger.objects.create(charger_id="VINDET")
+        tx = Transaction.objects.create(
+            charger=charger,
+            start_time=timezone.now(),
+            vin="WAUZZZ00000000002",
+        )
+        details = _transaction_rfid_details(tx, cache={})
+        self.assertIsNotNone(details)
+        assert details is not None  # for type checkers
+        self.assertEqual(details["value"], "WAUZZZ00000000002")
+        self.assertEqual(details["display_label"], "VIN")
+        self.assertEqual(details["type"], "vin")
+
+
 class DispatchActionViewTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -4704,6 +4825,59 @@ class LiveUpdateViewTests(TestCase):
         )
         self.assertEqual(aggregate_entry["state"], available_label)
 
+    def test_dashboard_groups_connectors_under_parent(self):
+        aggregate = Charger.objects.create(charger_id="GROUPED")
+        first = Charger.objects.create(
+            charger_id=aggregate.charger_id, connector_id=1
+        )
+        second = Charger.objects.create(
+            charger_id=aggregate.charger_id, connector_id=2
+        )
+
+        resp = self.client.get(reverse("ocpp-dashboard"))
+        self.assertEqual(resp.status_code, 200)
+        groups = resp.context["charger_groups"]
+        target = next(
+            group
+            for group in groups
+            if group.get("parent")
+            and group["parent"]["charger"].pk == aggregate.pk
+        )
+        child_ids = [item["charger"].pk for item in target["children"]]
+        self.assertEqual(child_ids, [first.pk, second.pk])
+
+    def test_dashboard_includes_energy_totals(self):
+        aggregate = Charger.objects.create(charger_id="KWSTATS")
+        now = timezone.now()
+        Transaction.objects.create(
+            charger=aggregate,
+            start_time=now - timedelta(hours=1),
+            stop_time=now,
+            meter_start=0,
+            meter_stop=3000,
+        )
+        past_start = now - timedelta(days=2)
+        Transaction.objects.create(
+            charger=aggregate,
+            start_time=past_start,
+            stop_time=past_start + timedelta(hours=1),
+            meter_start=0,
+            meter_stop=1000,
+        )
+
+        resp = self.client.get(reverse("ocpp-dashboard"))
+        self.assertEqual(resp.status_code, 200)
+        groups = resp.context["charger_groups"]
+        target = next(
+            group
+            for group in groups
+            if group.get("parent")
+            and group["parent"]["charger"].pk == aggregate.pk
+        )
+        stats = target["parent"]["stats"]
+        self.assertAlmostEqual(stats["total_kw"], 4.0, places=2)
+        self.assertAlmostEqual(stats["today_kw"], 3.0, places=2)
+
     def test_cp_simulator_includes_interval(self):
         resp = self.client.get(reverse("cp-simulator"))
         self.assertEqual(resp.context["request"].live_update_interval, 5)

ocpp/transactions_io.py

@@ -46,6 +46,7 @@ def export_transactions(
                 "charger": tx.charger.charger_id if tx.charger else None,
                 "account": tx.account_id,
                 "rfid": tx.rfid,
+                "vid": tx.vehicle_identifier,
                 "vin": tx.vin,
                 "meter_start": tx.meter_start,
                 "meter_stop": tx.meter_stop,
@@ -144,11 +145,18 @@ def import_transactions(data: dict) -> int:
             except ValidationError:
                 continue
             charger_map[serial] = charger
+        vid_value = tx.get("vid")
+        vin_value = tx.get("vin")
+        vid_text = str(vid_value).strip() if vid_value is not None else ""
+        vin_text = str(vin_value).strip() if vin_value is not None else ""
+        if not vid_text and vin_text:
+            vid_text = vin_text
         transaction = Transaction.objects.create(
             charger=charger,
             account_id=tx.get("account"),
             rfid=tx.get("rfid", ""),
-            vin=tx.get("vin", ""),
+            vid=vid_text,
+            vin=vin_text,
             meter_start=tx.get("meter_start"),
             meter_stop=tx.get("meter_stop"),
             voltage_start=tx.get("voltage_start"),

ocpp/urls.py

@@ -3,8 +3,8 @@ from django.urls import include, path
 from . import views
 
 urlpatterns = [
-    path("", views.dashboard, name="ocpp-dashboard"),
-    path("simulator/", views.cp_simulator, name="cp-simulator"),
+    path("cpms/dashboard/", views.dashboard, name="ocpp-dashboard"),
+    path("evcs/simulator/", views.cp_simulator, name="cp-simulator"),
     path("chargers/", views.charger_list, name="charger-list"),
     path("chargers/<str:cid>/", views.charger_detail, name="charger-detail"),
     path(
@@ -46,5 +46,5 @@ urlpatterns = [
         views.charger_status,
         name="charger-status-connector",
     ),
-    path("rfid/", include("ocpp.rfid.urls")),
+    path("rfid/validator/", include("ocpp.rfid.urls")),
 ]

ocpp/views.py

@@ -1,6 +1,7 @@
 import json
 import uuid
 from datetime import datetime, timedelta, timezone as dt_timezone
+from datetime import datetime, time, timedelta
 from types import SimpleNamespace
 
 from django.http import Http404, HttpResponse, JsonResponse
@@ -224,24 +225,75 @@ def _transaction_rfid_details(
     if not tx_obj:
         return None
     rfid_value = getattr(tx_obj, "rfid", None)
-    if not rfid_value:
-        return None
-    normalized = str(rfid_value).strip()
-    if not normalized:
+    normalized = str(rfid_value or "").strip().upper()
+    cache_key = normalized
+    if normalized:
+        if cache is not None and cache_key in cache:
+            return cache[cache_key]
+        tag = (
+            RFID.matching_queryset(normalized)
+            .only("pk", "label_id", "custom_label")
+            .first()
+        )
+        rfid_url = None
+        label_value = None
+        canonical_value = normalized
+        if tag:
+            try:
+                rfid_url = reverse("admin:core_rfid_change", args=[tag.pk])
+            except NoReverseMatch:  # pragma: no cover - admin may be disabled
+                rfid_url = None
+            custom_label = (tag.custom_label or "").strip()
+            if custom_label:
+                label_value = custom_label
+            elif tag.label_id is not None:
+                label_value = str(tag.label_id)
+            canonical_value = tag.rfid or canonical_value
+        display_value = label_value or canonical_value
+        details = {
+            "value": display_value,
+            "url": rfid_url,
+            "uid": canonical_value,
+            "type": "rfid",
+            "display_label": gettext("RFID"),
+        }
+        if label_value:
+            details["label"] = label_value
+        if cache is not None:
+            cache[cache_key] = details
+        return details
+
+    identifier_value = getattr(tx_obj, "vehicle_identifier", None)
+    normalized_identifier = str(identifier_value or "").strip()
+    if not normalized_identifier:
+        vid_value = getattr(tx_obj, "vid", None)
+        vin_value = getattr(tx_obj, "vin", None)
+        normalized_identifier = str(vid_value or vin_value or "").strip()
+    if not normalized_identifier:
         return None
-    normalized = normalized.upper()
-    if cache is not None and normalized in cache:
-        return cache[normalized]
-    tag = RFID.objects.filter(rfid=normalized).only("pk").first()
-    rfid_url = None
-    if tag:
-        try:
-            rfid_url = reverse("admin:core_rfid_change", args=[tag.pk])
-        except NoReverseMatch:  # pragma: no cover - admin may be disabled
-            rfid_url = None
-    details = {"value": normalized, "url": rfid_url}
+    source = getattr(tx_obj, "vehicle_identifier_source", "") or "vid"
+    if source not in {"vid", "vin"}:
+        vid_raw = getattr(tx_obj, "vid", None)
+        vin_raw = getattr(tx_obj, "vin", None)
+        if str(vid_raw or "").strip():
+            source = "vid"
+        elif str(vin_raw or "").strip():
+            source = "vin"
+        else:
+            source = "vid"
+    cache_key = f"{source}:{normalized_identifier}"
+    if cache is not None and cache_key in cache:
+        return cache[cache_key]
+    label = gettext("VID") if source == "vid" else gettext("VIN")
+    details = {
+        "value": normalized_identifier,
+        "url": None,
+        "uid": None,
+        "type": source,
+        "display_label": label,
+    }
     if cache is not None:
-        cache[normalized] = details
+        cache[cache_key] = details
     return details
 
 
@@ -509,8 +561,12 @@ def charger_list(request):
                 "meterStart": tx_obj.meter_start,
                 "startTime": tx_obj.start_time.isoformat(),
             }
-            if tx_obj.vin:
-                tx_data["vin"] = tx_obj.vin
+            identifier = str(getattr(tx_obj, "vehicle_identifier", "") or "").strip()
+            if identifier:
+                tx_data["vid"] = identifier
+            legacy_vin = str(getattr(tx_obj, "vin", "") or "").strip()
+            if legacy_vin:
+                tx_data["vin"] = legacy_vin
             if tx_obj.meter_stop is not None:
                 tx_data["meterStop"] = tx_obj.meter_stop
             if tx_obj.stop_time is not None:
@@ -525,8 +581,12 @@ def charger_list(request):
                 "meterStart": session_tx.meter_start,
                 "startTime": session_tx.start_time.isoformat(),
             }
-            if session_tx.vin:
-                active_payload["vin"] = session_tx.vin
+            identifier = str(getattr(session_tx, "vehicle_identifier", "") or "").strip()
+            if identifier:
+                active_payload["vid"] = identifier
+            legacy_vin = str(getattr(session_tx, "vin", "") or "").strip()
+            if legacy_vin:
+                active_payload["vin"] = legacy_vin
             if session_tx.meter_stop is not None:
                 active_payload["meterStop"] = session_tx.meter_stop
             if session_tx.stop_time is not None:
@@ -606,8 +666,12 @@ def charger_detail(request, cid, connector=None):
             "meterStart": tx_obj.meter_start,
             "startTime": tx_obj.start_time.isoformat(),
         }
-        if tx_obj.vin:
-            tx_data["vin"] = tx_obj.vin
+        identifier = str(getattr(tx_obj, "vehicle_identifier", "") or "").strip()
+        if identifier:
+            tx_data["vid"] = identifier
+        legacy_vin = str(getattr(tx_obj, "vin", "") or "").strip()
+        if legacy_vin:
+            tx_data["vin"] = legacy_vin
         if tx_obj.meter_stop is not None:
             tx_data["meterStop"] = tx_obj.meter_stop
         if tx_obj.stop_time is not None:
@@ -623,8 +687,12 @@ def charger_detail(request, cid, connector=None):
             "meterStart": session_tx.meter_start,
             "startTime": session_tx.start_time.isoformat(),
         }
-        if session_tx.vin:
-            payload["vin"] = session_tx.vin
+        identifier = str(getattr(session_tx, "vehicle_identifier", "") or "").strip()
+        if identifier:
+            payload["vid"] = identifier
+        legacy_vin = str(getattr(session_tx, "vin", "") or "").strip()
+        if legacy_vin:
+            payload["vin"] = legacy_vin
         if session_tx.meter_stop is not None:
             payload["meterStop"] = session_tx.meter_stop
         if session_tx.stop_time is not None:
@@ -679,14 +747,54 @@ def dashboard(request):
     node = Node.get_local()
     role = node.role if node else None
     role_name = role.name if role else ""
-    allow_anonymous_roles = {"Constellation", "Satellite"}
+    allow_anonymous_roles = {"Watchtower", "Constellation", "Satellite"}
     if not request.user.is_authenticated and role_name not in allow_anonymous_roles:
         return redirect_to_login(
             request.get_full_path(), login_url=reverse("pages:login")
         )
-    is_constellation = role_name == "Constellation"
-    chargers = []
-    for charger in _visible_chargers(request.user):
+    is_watchtower = role_name in {"Watchtower", "Constellation"}
+    visible_chargers = (
+        _visible_chargers(request.user)
+        .select_related("location")
+        .order_by("charger_id", "connector_id")
+    )
+    stats_cache: dict[int, dict[str, float]] = {}
+
+    def _charger_display_name(charger: Charger) -> str:
+        if charger.display_name:
+            return charger.display_name
+        if charger.location:
+            return charger.location.name
+        return charger.charger_id
+
+    today = timezone.localdate()
+    tz = timezone.get_current_timezone()
+    day_start = datetime.combine(today, time.min)
+    if timezone.is_naive(day_start):
+        day_start = timezone.make_aware(day_start, tz)
+    day_end = day_start + timedelta(days=1)
+
+    def _charger_stats(charger: Charger) -> dict[str, float]:
+        cache_key = charger.pk or id(charger)
+        if cache_key not in stats_cache:
+            stats_cache[cache_key] = {
+                "total_kw": charger.total_kw,
+                "today_kw": charger.total_kw_for_range(day_start, day_end),
+            }
+        return stats_cache[cache_key]
+
+    def _status_url(charger: Charger) -> str:
+        return _reverse_connector_url(
+            "charger-status",
+            charger.charger_id,
+            charger.connector_slug,
+        )
+
+    chargers: list[dict[str, object]] = []
+    charger_groups: list[dict[str, object]] = []
+    group_lookup: dict[str, dict[str, object]] = {}
+
+    for charger in visible_chargers:
         tx_obj = store.get_transaction(charger.charger_id, charger.connector_id)
         if not tx_obj:
             tx_obj = (
@@ -694,14 +802,55 @@ def dashboard(request):
                 .order_by("-start_time")
                 .first()
             )
+        has_session = _has_active_session(tx_obj)
         state, color = _charger_state(charger, tx_obj)
-        chargers.append({"charger": charger, "state": state, "color": color})
+        if (
+            charger.connector_id is not None
+            and not has_session
+            and (charger.last_status or "").strip().casefold() == "charging"
+        ):
+            state, color = STATUS_BADGE_MAP["charging"]
+        entry = {
+            "charger": charger,
+            "state": state,
+            "color": color,
+            "display_name": _charger_display_name(charger),
+            "stats": _charger_stats(charger),
+            "status_url": _status_url(charger),
+        }
+        chargers.append(entry)
+        if charger.connector_id is None:
+            group = {"parent": entry, "children": []}
+            charger_groups.append(group)
+            group_lookup[charger.charger_id] = group
+        else:
+            group = group_lookup.get(charger.charger_id)
+            if group is None:
+                group = {"parent": None, "children": []}
+                charger_groups.append(group)
+                group_lookup[charger.charger_id] = group
+            group["children"].append(entry)
+
+    for group in charger_groups:
+        parent_entry = group.get("parent")
+        if not parent_entry or not group["children"]:
+            continue
+        connector_statuses = [
+            (child["charger"].last_status or "").strip().casefold()
+            for child in group["children"]
+            if child["charger"].connector_id is not None
+        ]
+        if connector_statuses and all(status == "charging" for status in connector_statuses):
+            label, badge_color = STATUS_BADGE_MAP["charging"]
+            parent_entry["state"] = label
+            parent_entry["color"] = badge_color
     scheme = "wss" if request.is_secure() else "ws"
     host = request.get_host()
     ws_url = f"{scheme}://{host}/ocpp/<CHARGE_POINT_ID>/"
     context = {
         "chargers": chargers,
-        "show_demo_notice": is_constellation,
+        "charger_groups": charger_groups,
+        "show_demo_notice": is_watchtower,
         "demo_ws_url": ws_url,
         "ws_rate_limit": store.MAX_CONNECTIONS_PER_IP,
     }
@@ -1049,7 +1198,10 @@ def charger_status(request, cid, connector=None):
                         "connector_id": connector_id,
                     }
                 )
-    overview = _connector_overview(charger, request.user)
+    rfid_cache: dict[str, dict[str, str | None]] = {}
+    overview = _connector_overview(
+        charger, request.user, rfid_cache=rfid_cache
+    )
     connector_links = [
         {
             "slug": item["slug"],
@@ -1090,12 +1242,15 @@ def charger_status(request, cid, connector=None):
     action_url = _reverse_connector_url("charger-action", cid, connector_slug)
     chart_should_animate = bool(has_active_session and not past_session)
 
+    tx_rfid_details = _transaction_rfid_details(tx_obj, cache=rfid_cache)
+
     return render(
         request,
         "ocpp/charger_status.html",
         {
             "charger": charger,
             "tx": tx_obj,
+            "tx_rfid_details": tx_rfid_details,
             "state": state,
             "color": color,
             "transactions": transactions,