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

ocpp/tests.py

@@ -55,19 +55,23 @@ from django.contrib.sites.models import Site
 from django.core.exceptions import ValidationError
 from pages.models import Application, Module
 from nodes.models import Node, NodeRole
+from django.contrib.admin.sites import AdminSite
 
 from config.asgi import application
 
 from .models import (
     Transaction,
     Charger,
+    ChargerConfiguration,
     Simulator,
     MeterReading,
     Location,
     DataTransferMessage,
+    CPReservation,
 )
+from .admin import ChargerConfigurationAdmin
 from .consumers import CSMSConsumer
-from .views import dispatch_action
+from .views import dispatch_action, _transaction_rfid_details, _usage_timeline
 from .status_display import STATUS_BADGE_MAP
 from core.models import EnergyAccount, EnergyCredit, Reference, RFID, SecurityGroup
 from . import store
@@ -80,7 +84,12 @@ from .simulator import SimulatorConfig, ChargePointSimulator
 from .evcs import simulate, SimulatorState, _simulators
 import re
 from datetime import datetime, timedelta, timezone as dt_timezone
-from .tasks import purge_meter_readings, send_daily_session_report
+from .tasks import (
+    purge_meter_readings,
+    send_daily_session_report,
+    check_charge_point_configuration,
+    schedule_daily_charge_point_configuration_checks,
+)
 from django.db import close_old_connections
 from django.db.utils import OperationalError
 from urllib.parse import unquote, urlparse
@@ -169,6 +178,36 @@ class DispatchActionTests(TestCase):
         self.assertEqual(metadata.get("trigger_target"), "BootNotification")
         self.assertEqual(metadata.get("log_key"), log_key)
 
+    def test_reset_rejected_when_transaction_active(self):
+        charger = Charger.objects.create(charger_id="RESETBLOCK")
+        dummy = DummyWebSocket()
+        connection_key = store.set_connection(charger.charger_id, charger.connector_id, dummy)
+        self.addCleanup(lambda: store.connections.pop(connection_key, None))
+        tx_obj = Transaction.objects.create(
+            charger=charger,
+            connector_id=charger.connector_id,
+            start_time=timezone.now(),
+        )
+        tx_key = store.set_transaction(charger.charger_id, charger.connector_id, tx_obj)
+        self.addCleanup(lambda: store.transactions.pop(tx_key, None))
+
+        request = self.factory.post(
+            "/chargers/RESETBLOCK/action/",
+            data=json.dumps({"action": "reset"}),
+            content_type="application/json",
+        )
+        request.user = SimpleNamespace(
+            is_authenticated=True,
+            is_superuser=True,
+            is_staff=True,
+        )
+
+        response = dispatch_action(request, charger.charger_id)
+        self.assertEqual(response.status_code, 409)
+        payload = json.loads(response.content.decode("utf-8"))
+        self.assertIn("stop the session first", payload.get("detail", "").lower())
+        self.assertFalse(dummy.sent)
+
 class ChargerFixtureTests(TestCase):
     fixtures = [
         p.name
@@ -210,6 +249,240 @@ class ChargerFixtureTests(TestCase):
         self.assertEqual(cp2.name, "Simulator #2")
 
 
+class ChargerRefreshManagerNodeTests(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        local = Node.objects.create(
+            hostname="local-node",
+            address="127.0.0.1",
+            port=8000,
+            mac_address="aa:bb:cc:dd:ee:ff",
+            current_relation=Node.Relation.SELF,
+        )
+        Node.objects.filter(pk=local.pk).update(mac_address="AA:BB:CC:DD:EE:FF")
+        cls.local_node = Node.objects.get(pk=local.pk)
+
+    def test_refresh_manager_node_assigns_local_to_unsaved_charger(self):
+        charger = Charger(charger_id="UNSAVED")
+
+        with patch("nodes.models.Node.get_current_mac", return_value="aa:bb:cc:dd:ee:ff"):
+            result = charger.refresh_manager_node()
+
+        self.assertEqual(result, self.local_node)
+        self.assertEqual(charger.manager_node, self.local_node)
+
+    def test_refresh_manager_node_updates_persisted_charger(self):
+        remote = Node.objects.create(
+            hostname="remote-node",
+            address="10.0.0.1",
+            port=9000,
+            mac_address="11:22:33:44:55:66",
+        )
+        charger = Charger.objects.create(
+            charger_id="PERSISTED",
+            manager_node=remote,
+        )
+
+        charger.refresh_manager_node(node=self.local_node)
+
+        self.assertEqual(charger.manager_node, self.local_node)
+        charger.refresh_from_db()
+        self.assertEqual(charger.manager_node, self.local_node)
+
+    def test_refresh_manager_node_handles_missing_local_node(self):
+        remote = Node.objects.create(
+            hostname="existing-manager",
+            address="10.0.0.2",
+            port=9001,
+            mac_address="22:33:44:55:66:77",
+        )
+        charger = Charger(charger_id="NOLOCAL", manager_node=remote)
+
+        with patch.object(Node, "get_local", return_value=None):
+            result = charger.refresh_manager_node()
+
+        self.assertIsNone(result)
+        self.assertEqual(charger.manager_node, remote)
+
+
+class CPReservationTests(TransactionTestCase):
+    def setUp(self):
+        self.location = Location.objects.create(name="Reservation Site")
+        self.aggregate = Charger.objects.create(charger_id="RSV100", location=self.location)
+        self.connector_one = Charger.objects.create(
+            charger_id="RSV100", connector_id=1, location=self.location
+        )
+        self.connector_two = Charger.objects.create(
+            charger_id="RSV100", connector_id=2, location=self.location
+        )
+        self.addCleanup(store.clear_pending_calls, "RSV100")
+
+    def test_allocates_preferred_connector(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation(
+            location=self.location,
+            start_time=start,
+            duration_minutes=90,
+            id_tag="TAG001",
+        )
+        reservation.save()
+        self.assertEqual(reservation.connector, self.connector_two)
+
+    def test_allocation_falls_back_and_blocks_overlaps(self):
+        start = timezone.now() + timedelta(hours=1)
+        first = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=60,
+            id_tag="TAG002",
+        )
+        self.assertEqual(first.connector, self.connector_two)
+        second = CPReservation(
+            location=self.location,
+            start_time=start + timedelta(minutes=15),
+            duration_minutes=60,
+            id_tag="TAG003",
+        )
+        second.save()
+        self.assertEqual(second.connector, self.connector_one)
+        third = CPReservation(
+            location=self.location,
+            start_time=start + timedelta(minutes=30),
+            duration_minutes=45,
+            id_tag="TAG004",
+        )
+        with self.assertRaises(ValidationError):
+            third.save()
+
+    def test_send_reservation_request_dispatches_frame(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=30,
+            id_tag="TAG005",
+        )
+
+        class DummyConnection:
+            def __init__(self):
+                self.sent: list[str] = []
+
+            async def send(self, message):
+                self.sent.append(message)
+
+        ws = DummyConnection()
+        store.set_connection(
+            reservation.connector.charger_id,
+            reservation.connector.connector_id,
+            ws,
+        )
+        self.addCleanup(
+            store.pop_connection,
+            reservation.connector.charger_id,
+            reservation.connector.connector_id,
+        )
+
+        message_id = reservation.send_reservation_request()
+        self.assertTrue(ws.sent)
+        frame = json.loads(ws.sent[0])
+        self.assertEqual(frame[0], 2)
+        self.assertEqual(frame[2], "ReserveNow")
+        self.assertEqual(frame[3]["reservationId"], reservation.pk)
+        self.assertEqual(frame[3]["connectorId"], reservation.connector.connector_id)
+        self.assertEqual(frame[3]["idTag"], "TAG005")
+        metadata = store.pending_calls.get(message_id)
+        self.assertIsNotNone(metadata)
+        self.assertEqual(metadata.get("reservation_pk"), reservation.pk)
+
+    def test_call_result_marks_reservation_confirmed(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=45,
+            id_tag="TAG006",
+        )
+        log_key = store.identity_key(
+            reservation.connector.charger_id, reservation.connector.connector_id
+        )
+        message_id = "reserve-success"
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "ReserveNow",
+                "charger_id": reservation.connector.charger_id,
+                "connector_id": reservation.connector.connector_id,
+                "log_key": log_key,
+                "reservation_pk": reservation.pk,
+            },
+        )
+
+        consumer = CSMSConsumer()
+        consumer.scope = {"headers": [], "client": ("127.0.0.1", 1234)}
+        consumer.charger_id = reservation.connector.charger_id
+        consumer.store_key = log_key
+        consumer.connector_value = reservation.connector.connector_id
+        consumer.charger = reservation.connector
+        consumer.aggregate_charger = self.aggregate
+        consumer._consumption_task = None
+        consumer._consumption_message_uuid = None
+        consumer.send = AsyncMock()
+
+        async_to_sync(consumer._handle_call_result)(
+            message_id, {"status": "Accepted"}
+        )
+        reservation.refresh_from_db()
+        self.assertTrue(reservation.evcs_confirmed)
+        self.assertEqual(reservation.evcs_status, "Accepted")
+        self.assertIsNotNone(reservation.evcs_confirmed_at)
+
+    def test_call_error_updates_reservation_status(self):
+        start = timezone.now() + timedelta(hours=1)
+        reservation = CPReservation.objects.create(
+            location=self.location,
+            start_time=start,
+            duration_minutes=45,
+            id_tag="TAG007",
+        )
+        log_key = store.identity_key(
+            reservation.connector.charger_id, reservation.connector.connector_id
+        )
+        message_id = "reserve-error"
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "ReserveNow",
+                "charger_id": reservation.connector.charger_id,
+                "connector_id": reservation.connector.connector_id,
+                "log_key": log_key,
+                "reservation_pk": reservation.pk,
+            },
+        )
+
+        consumer = CSMSConsumer()
+        consumer.scope = {"headers": [], "client": ("127.0.0.1", 1234)}
+        consumer.charger_id = reservation.connector.charger_id
+        consumer.store_key = log_key
+        consumer.connector_value = reservation.connector.connector_id
+        consumer.charger = reservation.connector
+        consumer.aggregate_charger = self.aggregate
+        consumer._consumption_task = None
+        consumer._consumption_message_uuid = None
+        consumer.send = AsyncMock()
+
+        async_to_sync(consumer._handle_call_error)(
+            message_id,
+            "Rejected",
+            "Charger unavailable",
+            {"reason": "maintenance"},
+        )
+        reservation.refresh_from_db()
+        self.assertFalse(reservation.evcs_confirmed)
+        self.assertEqual(reservation.evcs_status, "")
+        self.assertIsNone(reservation.evcs_confirmed_at)
+        self.assertIn("Rejected", reservation.evcs_error or "")
+
+
 class ChargerUrlFallbackTests(TestCase):
     @override_settings(ALLOWED_HOSTS=["fallback.example", "10.0.0.0/8"])
     def test_reference_created_when_site_missing(self):
@@ -714,6 +987,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 +1024,32 @@ 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.assertIsNotNone(configuration.evcs_snapshot_at)
+        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 +1415,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 +1430,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()
 
@@ -1852,6 +2180,16 @@ class ChargerLandingTests(TestCase):
         status_url = reverse("charger-status-connector", args=["PAGE1", "all"])
         self.assertContains(response, status_url)
 
+    def test_charger_page_respects_language_configuration(self):
+        charger = Charger.objects.create(charger_id="PAGE-DE", language="de")
+
+        response = self.client.get(reverse("charger-page", args=["PAGE-DE"]))
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.context["LANGUAGE_CODE"], "de")
+        self.assertContains(response, 'lang="de"')
+        self.assertContains(response, 'data-preferred-language="de"')
+
     def test_status_page_renders(self):
         charger = Charger.objects.create(charger_id="PAGE2")
         resp = self.client.get(reverse("charger-status", args=["PAGE2"]))
@@ -1931,6 +2269,27 @@ class ChargerLandingTests(TestCase):
         finally:
             store.transactions.pop(key, None)
 
+    def test_public_page_shows_available_when_status_stale(self):
+        charger = Charger.objects.create(
+            charger_id="STALEPUB",
+            last_status="Charging",
+        )
+        response = self.client.get(reverse("charger-page", args=["STALEPUB"]))
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(
+            response,
+            'style="background-color: #0d6efd; color: #fff;">Available</span>',
+        )
+
+    def test_admin_status_shows_available_when_status_stale(self):
+        charger = Charger.objects.create(
+            charger_id="STALEADM",
+            last_status="Charging",
+        )
+        response = self.client.get(reverse("charger-status", args=["STALEADM"]))
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, 'id="charger-state">Available</strong>')
+
     def test_public_status_shows_rfid_link_for_known_tag(self):
         aggregate = Charger.objects.create(charger_id="PUBRFID")
         connector = Charger.objects.create(
@@ -2057,7 +2416,10 @@ class ChargerLandingTests(TestCase):
         log_id = store.identity_key("LOG1", None)
         store.add_log(log_id, "hello", log_type="charger")
         entry = store.get_logs(log_id, log_type="charger")[0]
-        self.assertRegex(entry, r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} hello$")
+        self.assertRegex(
+            entry,
+            r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} hello$",
+        )
         resp = self.client.get(reverse("charger-log", args=["LOG1"]) + "?type=charger")
         self.assertEqual(resp.status_code, 200)
         self.assertContains(resp, "hello")
@@ -2092,12 +2454,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"))
@@ -2129,6 +2491,32 @@ class ChargerAdminTests(TestCase):
         resp = self.client.get(url)
         self.assertNotContains(resp, charger.reference.image.url)
 
+    def test_toggle_rfid_authentication_action_toggles_value(self):
+        charger_requires = Charger.objects.create(
+            charger_id="RFIDON", require_rfid=True
+        )
+        charger_optional = Charger.objects.create(
+            charger_id="RFIDOFF", require_rfid=False
+        )
+        url = reverse("admin:ocpp_charger_changelist")
+        response = self.client.post(
+            url,
+            {
+                "action": "toggle_rfid_authentication",
+                "_selected_action": [
+                    charger_requires.pk,
+                    charger_optional.pk,
+                ],
+            },
+            follow=True,
+        )
+        self.assertEqual(response.status_code, 200)
+        charger_requires.refresh_from_db()
+        charger_optional.refresh_from_db()
+        self.assertFalse(charger_requires.require_rfid)
+        self.assertTrue(charger_optional.require_rfid)
+        self.assertContains(response, "Updated RFID authentication")
+
     def test_admin_lists_log_link(self):
         charger = Charger.objects.create(charger_id="LOG1")
         url = reverse("admin:ocpp_charger_changelist")
@@ -2155,6 +2543,85 @@ class ChargerAdminTests(TestCase):
         finally:
             store.transactions.pop(key, None)
 
+    def test_admin_status_shows_available_when_status_stale(self):
+        charger = Charger.objects.create(
+            charger_id="ADMINSTALE",
+            last_status="Charging",
+        )
+        url = reverse("admin:ocpp_charger_changelist")
+        resp = self.client.get(url)
+        available_label = force_str(STATUS_BADGE_MAP["available"][0])
+        self.assertContains(resp, f">{available_label}<")
+
+    def test_recheck_charger_status_action_sends_trigger(self):
+        charger = Charger.objects.create(charger_id="RECHECK1")
+
+        class DummyConnection:
+            def __init__(self):
+                self.sent: list[str] = []
+
+            async def send(self, message):
+                self.sent.append(message)
+
+        ws = DummyConnection()
+        store.set_connection(charger.charger_id, charger.connector_id, ws)
+        try:
+            url = reverse("admin:ocpp_charger_changelist")
+            response = self.client.post(
+                url,
+                {
+                    "action": "recheck_charger_status",
+                    "index": 0,
+                    "select_across": 0,
+                    "_selected_action": [charger.pk],
+                },
+                follow=True,
+            )
+            self.assertEqual(response.status_code, 200)
+            self.assertTrue(ws.sent)
+            self.assertIn("TriggerMessage", ws.sent[0])
+            self.assertContains(response, "Requested status update")
+        finally:
+            store.pop_connection(charger.charger_id, charger.connector_id)
+            store.clear_pending_calls(charger.charger_id)
+
+    def test_reset_charger_action_skips_when_transaction_active(self):
+        charger = Charger.objects.create(charger_id="RESETADMIN")
+
+        class DummyConnection:
+            def __init__(self):
+                self.sent: list[str] = []
+
+            async def send(self, message):
+                self.sent.append(message)
+
+        ws = DummyConnection()
+        store.set_connection(charger.charger_id, charger.connector_id, ws)
+        tx_obj = Transaction.objects.create(
+            charger=charger,
+            connector_id=charger.connector_id,
+            start_time=timezone.now(),
+        )
+        store.set_transaction(charger.charger_id, charger.connector_id, tx_obj)
+        try:
+            url = reverse("admin:ocpp_charger_changelist")
+            response = self.client.post(
+                url,
+                {
+                    "action": "reset_chargers",
+                    "index": 0,
+                    "select_across": 0,
+                    "_selected_action": [charger.pk],
+                },
+                follow=True,
+            )
+            self.assertEqual(response.status_code, 200)
+            self.assertFalse(ws.sent)
+            self.assertContains(response, "stop the session first")
+        finally:
+            store.pop_connection(charger.charger_id, charger.connector_id)
+            store.pop_transaction(charger.charger_id, charger.connector_id)
+
     def test_admin_log_view_displays_entries(self):
         charger = Charger.objects.create(charger_id="LOG2")
         log_id = store.identity_key(charger.charger_id, charger.connector_id)
@@ -2178,6 +2645,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(
@@ -2427,6 +2924,81 @@ class ChargerAdminTests(TestCase):
             store.clear_log(pending_key, log_type="charger")
 
 
+class ChargerConfigurationAdminUnitTests(TestCase):
+    def setUp(self):
+        self.admin = ChargerConfigurationAdmin(ChargerConfiguration, AdminSite())
+        self.request_factory = RequestFactory()
+
+    def test_origin_display_returns_evcs_when_snapshot_present(self):
+        configuration = ChargerConfiguration.objects.create(
+            charger_identifier="CFG-EVCS",
+            evcs_snapshot_at=timezone.now(),
+        )
+        self.assertEqual(self.admin.origin_display(configuration), "EVCS")
+
+    def test_origin_display_returns_local_without_snapshot(self):
+        configuration = ChargerConfiguration.objects.create(
+            charger_identifier="CFG-LOCAL",
+        )
+        self.assertEqual(self.admin.origin_display(configuration), "Local")
+
+    def test_save_model_resets_snapshot_timestamp(self):
+        configuration = ChargerConfiguration.objects.create(
+            charger_identifier="CFG-SAVE",
+            evcs_snapshot_at=timezone.now(),
+        )
+        request = self.request_factory.post("/admin/ocpp/chargerconfiguration/")
+        self.admin.save_model(request, configuration, form=None, change=True)
+        configuration.refresh_from_db()
+        self.assertIsNone(configuration.evcs_snapshot_at)
+
+
+class ConfigurationTaskTests(TestCase):
+    def tearDown(self):
+        store.pending_calls.clear()
+
+    def test_check_charge_point_configuration_dispatches_request(self):
+        charger = Charger.objects.create(charger_id="TASKCFG")
+        ws = DummyWebSocket()
+        log_key = store.identity_key(charger.charger_id, charger.connector_id)
+        pending_key = store.pending_key(charger.charger_id)
+        store.clear_log(log_key, log_type="charger")
+        store.clear_log(pending_key, log_type="charger")
+        store.set_connection(charger.charger_id, charger.connector_id, ws)
+        try:
+            result = check_charge_point_configuration.run(charger.pk)
+            self.assertTrue(result)
+            self.assertEqual(len(ws.sent), 1)
+            frame = json.loads(ws.sent[0])
+            self.assertEqual(frame[0], 2)
+            self.assertEqual(frame[2], "GetConfiguration")
+            self.assertIn(frame[1], store.pending_calls)
+        finally:
+            store.pop_connection(charger.charger_id, charger.connector_id)
+            store.pending_calls.clear()
+            store.clear_log(log_key, log_type="charger")
+            store.clear_log(pending_key, log_type="charger")
+
+    def test_check_charge_point_configuration_without_connection(self):
+        charger = Charger.objects.create(charger_id="TASKNOCONN")
+        result = check_charge_point_configuration.run(charger.pk)
+        self.assertFalse(result)
+
+    def test_schedule_daily_checks_only_includes_root_chargers(self):
+        eligible = Charger.objects.create(charger_id="TASKROOT")
+        Charger.objects.create(charger_id="TASKCONN", connector_id=1)
+        with patch("ocpp.tasks.check_charge_point_configuration.delay") as mock_delay:
+            scheduled = schedule_daily_charge_point_configuration_checks.run()
+        self.assertEqual(scheduled, 1)
+        mock_delay.assert_called_once_with(eligible.pk)
+
+    def test_schedule_daily_checks_returns_zero_without_chargers(self):
+        with patch("ocpp.tasks.check_charge_point_configuration.delay") as mock_delay:
+            scheduled = schedule_daily_charge_point_configuration_checks.run()
+        self.assertEqual(scheduled, 0)
+        mock_delay.assert_not_called()
+
+
 class LocationAdminTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -2700,6 +3272,28 @@ class SimulatorAdminTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    def test_auto_registered_charger_location_name_sanitized(self):
+        async def exercise():
+            communicator = WebsocketCommunicator(
+                application, "/?cid=ACME%20Charger%20%231"
+            )
+            connected, _ = await communicator.connect()
+            self.assertTrue(connected)
+
+            await communicator.disconnect()
+
+            def fetch_location_name() -> str:
+                charger = (
+                    Charger.objects.select_related("location")
+                    .get(charger_id="ACME Charger #1")
+                )
+                return charger.location.name
+
+            location_name = await database_sync_to_async(fetch_location_name)()
+            self.assertEqual(location_name, "ACME_Charger_1")
+
+        async_to_sync(exercise)()
+
     async def test_query_string_cid_supported(self):
         communicator = WebsocketCommunicator(application, "/?cid=QSERIAL")
         connected, _ = await communicator.connect()
@@ -2860,6 +3454,44 @@ class SimulatorAdminTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    async def test_authorize_requires_rfid_accepts_allowed_tag_without_account(self):
+        charger_id = "AUTHWARN"
+        tag_value = "WARN01"
+        await database_sync_to_async(Charger.objects.create)(
+            charger_id=charger_id, require_rfid=True
+        )
+        await database_sync_to_async(RFID.objects.create)(rfid=tag_value, allowed=True)
+
+        pending_key = store.pending_key(charger_id)
+        store.clear_log(pending_key, log_type="charger")
+
+        communicator = WebsocketCommunicator(application, f"/{charger_id}/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        message_id = "auth-unlinked"
+        await communicator.send_json_to(
+            [2, message_id, "Authorize", {"idTag": tag_value}]
+        )
+        response = await communicator.receive_json_from()
+        self.assertEqual(response[0], 3)
+        self.assertEqual(response[1], message_id)
+        self.assertEqual(response[2], {"idTagInfo": {"status": "Accepted"}})
+
+        log_entries = store.get_logs(pending_key, log_type="charger")
+        self.assertTrue(
+            any(
+                "Authorized RFID" in entry
+                and tag_value in entry
+                and charger_id in entry
+                for entry in log_entries
+            ),
+            log_entries,
+        )
+
+        await communicator.disconnect()
+        store.clear_log(pending_key, log_type="charger")
+
     async def test_authorize_without_requirement_records_rfid(self):
         await database_sync_to_async(Charger.objects.create)(
             charger_id="AUTHOPT", require_rfid=False
@@ -2952,6 +3584,61 @@ class SimulatorAdminTests(TransactionTestCase):
         )
         self.assertEqual(tx.account_id, user.energy_account.id)
 
+    async def test_start_transaction_allows_allowed_tag_without_account(self):
+        charger_id = "STARTWARN"
+        tag_value = "WARN02"
+        await database_sync_to_async(Charger.objects.create)(
+            charger_id=charger_id, require_rfid=True
+        )
+        await database_sync_to_async(RFID.objects.create)(rfid=tag_value, allowed=True)
+
+        pending_key = store.pending_key(charger_id)
+        store.clear_log(pending_key, log_type="charger")
+
+        communicator = WebsocketCommunicator(application, f"/{charger_id}/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        start_payload = {
+            "meterStart": 5,
+            "idTag": tag_value,
+            "connectorId": 1,
+        }
+        await communicator.send_json_to([2, "start-1", "StartTransaction", start_payload])
+        response = await communicator.receive_json_from()
+        self.assertEqual(response[0], 3)
+        self.assertEqual(response[2]["idTagInfo"]["status"], "Accepted")
+        tx_id = response[2]["transactionId"]
+
+        tx = await database_sync_to_async(Transaction.objects.get)(
+            pk=tx_id, charger__charger_id=charger_id
+        )
+        self.assertIsNone(tx.account_id)
+
+        log_entries = store.get_logs(pending_key, log_type="charger")
+        self.assertTrue(
+            any(
+                "Authorized RFID" in entry
+                and tag_value in entry
+                and charger_id in entry
+                for entry in log_entries
+            ),
+            log_entries,
+        )
+
+        await communicator.send_json_to(
+            [
+                2,
+                "stop-1",
+                "StopTransaction",
+                {"transactionId": tx_id, "meterStop": 6},
+            ]
+        )
+        await communicator.receive_json_from()
+
+        await communicator.disconnect()
+        store.clear_log(pending_key, log_type="charger")
+
     async def test_status_fields_updated(self):
         communicator = WebsocketCommunicator(application, "/STAT/")
         connected, _ = await communicator.connect()
@@ -3017,8 +3704,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()
 
@@ -3045,6 +3731,10 @@ class ChargerLocationTests(TestCase):
         second = Charger.objects.create(charger_id="SHARE", connector_id=2)
         self.assertEqual(second.location, first.location)
 
+    def test_location_name_sanitized_when_auto_created(self):
+        charger = Charger.objects.create(charger_id="Name With spaces!#1")
+        self.assertEqual(charger.location.name, "Name_With_spaces_1")
+
 
 class MeterReadingTests(TransactionTestCase):
     async def test_meter_values_saved_as_readings(self):
@@ -3814,6 +4504,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()
@@ -4112,6 +4839,122 @@ class ChargerStatusViewTests(TestCase):
         self.assertAlmostEqual(resp.context["tx"].kw, 0.02)
         store.transactions.pop(key, None)
 
+    def test_usage_timeline_rendered_when_chart_unavailable(self):
+        original_logs = store.logs["charger"]
+        store.logs["charger"] = {}
+        self.addCleanup(lambda: store.logs.__setitem__("charger", original_logs))
+        fixed_now = timezone.now().replace(microsecond=0)
+        charger = Charger.objects.create(charger_id="TL1", connector_id=1)
+        log_key = store.identity_key(charger.charger_id, charger.connector_id)
+
+        def build_entry(delta, status):
+            timestamp = fixed_now - delta
+            payload = {
+                "connectorId": 1,
+                "status": status,
+                "timestamp": timestamp.isoformat(),
+            }
+            prefix = (timestamp.strftime("%Y-%m-%d %H:%M:%S.%f"))[:-3]
+            return f"{prefix} StatusNotification processed: {json.dumps(payload, sort_keys=True)}"
+
+        store.logs["charger"][log_key] = [
+            build_entry(timedelta(days=2), "Available"),
+            build_entry(timedelta(days=1), "Charging"),
+            build_entry(timedelta(hours=12), "Available"),
+        ]
+
+        data, _window = _usage_timeline(charger, [], now=fixed_now)
+        self.assertEqual(len(data), 1)
+        statuses = {segment["status"] for segment in data[0]["segments"]}
+        self.assertIn("charging", statuses)
+        self.assertIn("available", statuses)
+
+        with patch("ocpp.views.timezone.now", return_value=fixed_now):
+            resp = self.client.get(
+                reverse(
+                    "charger-status-connector",
+                    args=[charger.charger_id, charger.connector_slug],
+                )
+            )
+
+        self.assertContains(resp, "Usage (last 7 days)")
+        self.assertContains(resp, "usage-timeline-segment usage-charging")
+
+    def test_usage_timeline_includes_multiple_connectors(self):
+        original_logs = store.logs["charger"]
+        store.logs["charger"] = {}
+        self.addCleanup(lambda: store.logs.__setitem__("charger", original_logs))
+        fixed_now = timezone.now().replace(microsecond=0)
+        aggregate = Charger.objects.create(charger_id="TLAGG")
+        connector_one = Charger.objects.create(charger_id="TLAGG", connector_id=1)
+        connector_two = Charger.objects.create(charger_id="TLAGG", connector_id=2)
+
+        def build_entry(connector_id, delta, status):
+            timestamp = fixed_now - delta
+            payload = {
+                "connectorId": connector_id,
+                "status": status,
+                "timestamp": timestamp.isoformat(),
+            }
+            prefix = (timestamp.strftime("%Y-%m-%d %H:%M:%S.%f"))[:-3]
+            key = store.identity_key(aggregate.charger_id, connector_id)
+            store.logs["charger"].setdefault(key, []).append(
+                f"{prefix} StatusNotification processed: {json.dumps(payload, sort_keys=True)}"
+            )
+
+        build_entry(1, timedelta(days=3), "Available")
+        build_entry(2, timedelta(days=2), "Charging")
+
+        overview = [{"charger": connector_one}, {"charger": connector_two}]
+        data, _window = _usage_timeline(aggregate, overview, now=fixed_now)
+        self.assertEqual(len(data), 2)
+        self.assertTrue(all(entry["segments"] for entry in data))
+
+        with patch("ocpp.views.timezone.now", return_value=fixed_now):
+            resp = self.client.get(reverse("charger-status", args=[aggregate.charger_id]))
+
+        self.assertContains(resp, "Usage (last 7 days)")
+        self.assertContains(resp, connector_one.connector_label)
+        self.assertContains(resp, connector_two.connector_label)
+
+    def test_usage_timeline_merges_repeated_status_entries(self):
+        original_logs = store.logs["charger"]
+        store.logs["charger"] = {}
+        self.addCleanup(lambda: store.logs.__setitem__("charger", original_logs))
+        fixed_now = timezone.now().replace(microsecond=0)
+        charger = Charger.objects.create(
+            charger_id="TLDEDUP",
+            connector_id=1,
+            last_status="Available",
+        )
+
+        def build_entry(delta, status):
+            timestamp = fixed_now - delta
+            payload = {
+                "connectorId": 1,
+                "status": status,
+                "timestamp": timestamp.isoformat(),
+            }
+            prefix = (timestamp.strftime("%Y-%m-%d %H:%M:%S.%f"))[:-3]
+            return f"{prefix} StatusNotification processed: {json.dumps(payload, sort_keys=True)}"
+
+        log_key = store.identity_key(charger.charger_id, charger.connector_id)
+        store.logs["charger"][log_key] = [
+            build_entry(timedelta(days=6, hours=12), "Available"),
+            build_entry(timedelta(days=5), "Available"),
+            build_entry(timedelta(days=3, hours=6), "Charging"),
+            build_entry(timedelta(days=2), "Charging"),
+            build_entry(timedelta(days=1), "Available"),
+        ]
+
+        data, window = _usage_timeline(charger, [], now=fixed_now)
+        self.assertIsNotNone(window)
+        self.assertEqual(len(data), 1)
+        segments = data[0]["segments"]
+        self.assertGreaterEqual(len(segments), 1)
+        statuses = [segment["status"] for segment in segments]
+        self.assertEqual(statuses, ["available", "charging", "available"])
+
     def test_diagnostics_status_displayed(self):
         reported_at = timezone.now().replace(microsecond=0)
         charger = Charger.objects.create(
@@ -4442,6 +5285,49 @@ class LiveUpdateViewTests(TestCase):
         )
         self.assertEqual(aggregate_entry["state"], available_label)
 
+    def test_dashboard_connector_treats_finishing_as_available_without_session(self):
+        charger = Charger.objects.create(
+            charger_id="FINISH-STATE",
+            connector_id=1,
+            last_status="Finishing",
+        )
+
+        resp = self.client.get(reverse("ocpp-dashboard"))
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(resp.context)
+        context = resp.context
+        available_label = force_str(STATUS_BADGE_MAP["available"][0])
+        entry = next(
+            item
+            for item in context["chargers"]
+            if item["charger"].pk == charger.pk
+        )
+        self.assertEqual(entry["state"], available_label)
+
+    def test_dashboard_aggregate_treats_finishing_as_available_without_session(self):
+        aggregate = Charger.objects.create(
+            charger_id="FINISH-AGG",
+            connector_id=None,
+            last_status="Finishing",
+        )
+        Charger.objects.create(
+            charger_id=aggregate.charger_id,
+            connector_id=1,
+            last_status="Finishing",
+        )
+
+        resp = self.client.get(reverse("ocpp-dashboard"))
+        self.assertEqual(resp.status_code, 200)
+        self.assertIsNotNone(resp.context)
+        context = resp.context
+        available_label = force_str(STATUS_BADGE_MAP["available"][0])
+        aggregate_entry = next(
+            item
+            for item in context["chargers"]
+            if item["charger"].pk == aggregate.pk
+        )
+        self.assertEqual(aggregate_entry["state"], available_label)
+
     def test_dashboard_aggregate_uses_connection_when_status_missing(self):
         aggregate = Charger.objects.create(
             charger_id="DASHAGG-CONN", last_status="Charging"
@@ -4466,6 +5352,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)