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

ocpp/tests.py

@@ -1,12 +1,25 @@
+import os
 
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+
+import django
+
+django.setup()
+
+from asgiref.testing import ApplicationCommunicator
 from channels.testing import WebsocketCommunicator
 from channels.db import database_sync_to_async
-from django.test import Client, TransactionTestCase, TestCase
+from asgiref.sync import async_to_sync
+from django.test import Client, TransactionTestCase, TestCase, override_settings
 from unittest import skip
-from unittest.mock import patch
+from contextlib import suppress
+from types import SimpleNamespace
+from unittest.mock import patch, Mock
 from django.contrib.auth import get_user_model
 from django.urls import reverse
 from django.utils import timezone
+from django.utils.dateparse import parse_datetime
+from django.utils.translation import override, gettext as _
 from django.contrib.sites.models import Site
 from pages.models import Application, Module
 from nodes.models import Node, NodeRole
@@ -14,8 +27,8 @@ from nodes.models import Node, NodeRole
 from config.asgi import application
 
 from .models import Transaction, Charger, Simulator, MeterReading, Location
-from core.models import EnergyAccount, EnergyCredit
-from core.models import RFID
+from .consumers import CSMSConsumer
+from core.models import EnergyAccount, EnergyCredit, Reference, RFID
 from . import store
 from django.db.models.deletion import ProtectedError
 from decimal import Decimal
@@ -25,13 +38,78 @@ import asyncio
 from pathlib import Path
 from .simulator import SimulatorConfig, ChargePointSimulator
 import re
-from datetime import timedelta
+from datetime import datetime, timedelta
 from .tasks import purge_meter_readings
+from django.db import close_old_connections
+from django.db.utils import OperationalError
+from urllib.parse import unquote, urlparse
+
+
+class ClientWebsocketCommunicator(WebsocketCommunicator):
+    """WebsocketCommunicator that injects a client address into the scope."""
+
+    def __init__(
+        self,
+        application,
+        path,
+        *,
+        client=None,
+        headers=None,
+        subprotocols=None,
+        spec_version=None,
+    ):
+        if not isinstance(path, str):
+            raise TypeError(f"Expected str, got {type(path)}")
+        parsed = urlparse(path)
+        scope = {
+            "type": "websocket",
+            "path": unquote(parsed.path),
+            "query_string": parsed.query.encode("utf-8"),
+            "headers": headers or [],
+            "subprotocols": subprotocols or [],
+        }
+        if client is not None:
+            scope["client"] = client
+        if spec_version:
+            scope["spec_version"] = spec_version
+        self.scope = scope
+        ApplicationCommunicator.__init__(self, application, self.scope)
+        self.response_headers = None
+
 
+class DummyWebSocket:
+    """Simple websocket stub that records payloads sent by the view."""
+
+    def __init__(self):
+        self.sent: list[str] = []
+
+    async def send(self, message):
+        self.sent.append(message)
 
 
 class ChargerFixtureTests(TestCase):
-    fixtures = ["initial_data.json"]
+    fixtures = [
+        p.name
+        for p in (Path(__file__).resolve().parent / "fixtures").glob(
+            "initial_data__*.json"
+        )
+    ]
+
+    @classmethod
+    def setUpTestData(cls):
+        location = Location.objects.create(name="Simulator")
+        Charger.objects.create(
+            charger_id="CP1",
+            connector_id=1,
+            location=location,
+            require_rfid=False,
+        )
+        Charger.objects.create(
+            charger_id="CP2",
+            connector_id=2,
+            location=location,
+            require_rfid=True,
+        )
 
     def test_cp2_requires_rfid(self):
         cp2 = Charger.objects.get(charger_id="CP2")
@@ -44,12 +122,26 @@ class ChargerFixtureTests(TestCase):
     def test_charger_connector_ids(self):
         cp1 = Charger.objects.get(charger_id="CP1")
         cp2 = Charger.objects.get(charger_id="CP2")
-        self.assertEqual(cp1.connector_id, "1")
-        self.assertEqual(cp2.connector_id, "2")
+        self.assertEqual(cp1.connector_id, 1)
+        self.assertEqual(cp2.connector_id, 2)
         self.assertEqual(cp1.name, "Simulator #1")
         self.assertEqual(cp2.name, "Simulator #2")
 
 
+class ChargerUrlFallbackTests(TestCase):
+    @override_settings(ALLOWED_HOSTS=["fallback.example", "10.0.0.0/8"])
+    def test_reference_created_when_site_missing(self):
+        Site.objects.all().delete()
+        Site.objects.clear_cache()
+
+        charger = Charger.objects.create(charger_id="NO_SITE")
+        charger.refresh_from_db()
+
+        self.assertIsNotNone(charger.reference)
+        self.assertTrue(charger.reference.value.startswith("http://fallback.example"))
+        self.assertTrue(charger.reference.value.endswith("/c/NO_SITE/"))
+
+
 class SinkConsumerTests(TransactionTestCase):
     async def test_sink_replies(self):
         communicator = WebsocketCommunicator(application, "/ws/sink/")
@@ -64,17 +156,40 @@ class SinkConsumerTests(TransactionTestCase):
 
 
 class CSMSConsumerTests(TransactionTestCase):
+    async def _retry_db(self, func, attempts: int = 5, delay: float = 0.1):
+        """Run a database function, retrying if the database is locked."""
+        for _ in range(attempts):
+            try:
+                return await database_sync_to_async(func)()
+            except OperationalError:
+                await database_sync_to_async(close_old_connections)()
+                await asyncio.sleep(delay)
+        raise
+
+    async def _send_status_notification(self, serial: str, payload: dict):
+        communicator = WebsocketCommunicator(application, f"/{serial}/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.send_json_to([2, "1", "StatusNotification", payload])
+        response = await communicator.receive_json_from()
+        self.assertEqual(response, [3, "1", {}])
+
+        await communicator.disconnect()
+
     async def test_transaction_saved(self):
         communicator = WebsocketCommunicator(application, "/TEST/")
         connected, _ = await communicator.connect()
         self.assertTrue(connected)
 
-        await communicator.send_json_to([
-            2,
-            "1",
-            "StartTransaction",
-            {"meterStart": 10},
-        ])
+        await communicator.send_json_to(
+            [
+                2,
+                "1",
+                "StartTransaction",
+                {"meterStart": 10, "connectorId": 3},
+            ]
+        )
         response = await communicator.receive_json_from()
         tx_id = response[2]["transactionId"]
 
@@ -82,14 +197,17 @@ class CSMSConsumerTests(TransactionTestCase):
             pk=tx_id, charger__charger_id="TEST"
         )
         self.assertEqual(tx.meter_start, 10)
+        self.assertEqual(tx.connector_id, 3)
         self.assertIsNone(tx.stop_time)
 
-        await communicator.send_json_to([
-            2,
-            "2",
-            "StopTransaction",
-            {"transactionId": tx_id, "meterStop": 20},
-        ])
+        await communicator.send_json_to(
+            [
+                2,
+                "2",
+                "StopTransaction",
+                {"transactionId": tx_id, "meterStop": 20},
+            ]
+        )
         await communicator.receive_json_from()
 
         await database_sync_to_async(tx.refresh_from_db)()
@@ -117,6 +235,286 @@ class CSMSConsumerTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    async def test_start_transaction_sends_net_message(self):
+        location = await database_sync_to_async(Location.objects.create)(
+            name="Test Location"
+        )
+        await database_sync_to_async(Charger.objects.create)(
+            charger_id="NETMSG", location=location
+        )
+        communicator = WebsocketCommunicator(application, "/NETMSG/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        with patch("nodes.models.NetMessage.broadcast") as mock_broadcast:
+            await communicator.send_json_to(
+                [
+                    2,
+                    "1",
+                    "StartTransaction",
+                    {"meterStart": 1, "connectorId": 1},
+                ]
+            )
+            await communicator.receive_json_from()
+
+        await communicator.disconnect()
+
+        mock_broadcast.assert_called_once()
+        _, kwargs = mock_broadcast.call_args
+        self.assertEqual(kwargs["subject"], "NETMSG")
+        body = kwargs["body"]
+        self.assertRegex(body, r"^\d+\.\d kWh \d{2}:\d{2}$")
+
+    async def test_consumption_message_updates_existing_entry(self):
+        original_interval = CSMSConsumer.consumption_update_interval
+        CSMSConsumer.consumption_update_interval = 0.01
+        await database_sync_to_async(Charger.objects.create)(charger_id="UPDATEMSG")
+        communicator = WebsocketCommunicator(application, "/UPDATEMSG/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        message_mock = Mock()
+        message_mock.uuid = "mock-uuid"
+        message_mock.save = Mock()
+        message_mock.propagate = Mock()
+
+        filter_mock = Mock()
+        filter_mock.first.return_value = message_mock
+
+        broadcast_result = SimpleNamespace(uuid="mock-uuid")
+
+        try:
+            with patch(
+                "nodes.models.NetMessage.broadcast", return_value=broadcast_result
+            ) as mock_broadcast, patch(
+                "nodes.models.NetMessage.objects.filter", return_value=filter_mock
+            ):
+                await communicator.send_json_to(
+                    [2, "1", "StartTransaction", {"meterStart": 1}]
+                )
+                await communicator.receive_json_from()
+                mock_broadcast.assert_called_once()
+                await asyncio.sleep(0.05)
+                await communicator.disconnect()
+        finally:
+            CSMSConsumer.consumption_update_interval = original_interval
+            with suppress(Exception):
+                await communicator.disconnect()
+
+        self.assertTrue(message_mock.save.called)
+        self.assertTrue(message_mock.propagate.called)
+
+    async def test_consumption_message_final_update_on_disconnect(self):
+        await database_sync_to_async(Charger.objects.create)(charger_id="FINALMSG")
+        communicator = WebsocketCommunicator(application, "/FINALMSG/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        message_mock = Mock()
+        message_mock.uuid = "mock-uuid"
+        message_mock.save = Mock()
+        message_mock.propagate = Mock()
+
+        filter_mock = Mock()
+        filter_mock.first.return_value = message_mock
+
+        broadcast_result = SimpleNamespace(uuid="mock-uuid")
+
+        try:
+            with patch(
+                "nodes.models.NetMessage.broadcast", return_value=broadcast_result
+            ) as mock_broadcast, patch(
+                "nodes.models.NetMessage.objects.filter", return_value=filter_mock
+            ):
+                await communicator.send_json_to(
+                    [2, "1", "StartTransaction", {"meterStart": 1}]
+                )
+                await communicator.receive_json_from()
+                mock_broadcast.assert_called_once()
+                await communicator.disconnect()
+        finally:
+            with suppress(Exception):
+                await communicator.disconnect()
+
+        self.assertTrue(message_mock.save.called)
+        self.assertTrue(message_mock.propagate.called)
+
+    async def test_rfid_unbound_instance_created(self):
+        await database_sync_to_async(Charger.objects.create)(charger_id="NEWRFID")
+        communicator = WebsocketCommunicator(application, "/NEWRFID/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.send_json_to(
+            [2, "1", "StartTransaction", {"meterStart": 1, "idTag": "TAG456"}]
+        )
+        await communicator.receive_json_from()
+
+        tag = await database_sync_to_async(RFID.objects.get)(rfid="TAG456")
+        count = await database_sync_to_async(tag.energy_accounts.count)()
+        self.assertEqual(count, 0)
+
+        await communicator.disconnect()
+
+    async def test_firmware_status_notification_updates_database_and_views(self):
+        communicator = WebsocketCommunicator(application, "/FWSTAT/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        ts = timezone.now().replace(microsecond=0)
+        payload = {
+            "status": "Installing",
+            "statusInfo": "Applying patch",
+            "timestamp": ts.isoformat(),
+        }
+
+        await communicator.send_json_to(
+            [2, "1", "FirmwareStatusNotification", payload]
+        )
+        response = await communicator.receive_json_from()
+        self.assertEqual(response, [3, "1", {}])
+
+        def _fetch_status():
+            charger = Charger.objects.get(charger_id="FWSTAT", connector_id=None)
+            return (
+                charger.firmware_status,
+                charger.firmware_status_info,
+                charger.firmware_timestamp,
+            )
+
+        status, info, recorded_ts = await database_sync_to_async(_fetch_status)()
+        self.assertEqual(status, "Installing")
+        self.assertEqual(info, "Applying patch")
+        self.assertIsNotNone(recorded_ts)
+        self.assertEqual(recorded_ts.replace(microsecond=0), ts)
+
+        log_entries = store.get_logs(store.identity_key("FWSTAT", None), log_type="charger")
+        self.assertTrue(
+            any("FirmwareStatusNotification" in entry for entry in log_entries)
+        )
+
+        def _fetch_views():
+            User = get_user_model()
+            user = User.objects.create_user(username="fwstatus", password="pw")
+            client = Client()
+            client.force_login(user)
+            detail = client.get(reverse("charger-detail", args=["FWSTAT"]))
+            status_page = client.get(reverse("charger-status", args=["FWSTAT"]))
+            list_response = client.get(reverse("charger-list"))
+            return (
+                detail.status_code,
+                json.loads(detail.content.decode()),
+                status_page.status_code,
+                status_page.content.decode(),
+                list_response.status_code,
+                json.loads(list_response.content.decode()),
+            )
+
+        (
+            detail_code,
+            detail_payload,
+            status_code,
+            html,
+            list_code,
+            list_payload,
+        ) = await database_sync_to_async(_fetch_views)()
+        self.assertEqual(detail_code, 200)
+        self.assertEqual(status_code, 200)
+        self.assertEqual(list_code, 200)
+        self.assertEqual(detail_payload["firmwareStatus"], "Installing")
+        self.assertEqual(detail_payload["firmwareStatusInfo"], "Applying patch")
+        self.assertEqual(detail_payload["firmwareTimestamp"], ts.isoformat())
+        self.assertIn('id="firmware-status">Installing<', html)
+        self.assertIn('id="firmware-status-info">Applying patch<', html)
+        match = re.search(
+            r'id="firmware-timestamp"[^>]*data-iso="([^"]+)"', html
+        )
+        self.assertIsNotNone(match)
+        parsed_iso = datetime.fromisoformat(match.group(1))
+        self.assertAlmostEqual(parsed_iso.timestamp(), ts.timestamp(), places=3)
+
+        matching = [
+            item
+            for item in list_payload.get("chargers", [])
+            if item["charger_id"] == "FWSTAT" and item["connector_id"] is None
+        ]
+        self.assertTrue(matching)
+        self.assertEqual(matching[0]["firmwareStatus"], "Installing")
+        self.assertEqual(matching[0]["firmwareStatusInfo"], "Applying patch")
+        list_ts = datetime.fromisoformat(matching[0]["firmwareTimestamp"])
+        self.assertAlmostEqual(list_ts.timestamp(), ts.timestamp(), places=3)
+
+        store.clear_log(store.identity_key("FWSTAT", None), log_type="charger")
+
+        await communicator.disconnect()
+
+    async def test_firmware_status_notification_updates_connector_and_aggregate(
+        self,
+    ):
+        communicator = WebsocketCommunicator(application, "/FWCONN/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.send_json_to(
+            [
+                2,
+                "1",
+                "FirmwareStatusNotification",
+                {"connectorId": 2, "status": "Downloaded"},
+            ]
+        )
+        response = await communicator.receive_json_from()
+        self.assertEqual(response, [3, "1", {}])
+
+        def _fetch_chargers():
+            aggregate = Charger.objects.get(charger_id="FWCONN", connector_id=None)
+            connector = Charger.objects.get(charger_id="FWCONN", connector_id=2)
+            return (
+                aggregate.firmware_status,
+                aggregate.firmware_status_info,
+                aggregate.firmware_timestamp,
+                connector.firmware_status,
+                connector.firmware_status_info,
+                connector.firmware_timestamp,
+            )
+
+        (
+            aggregate_status,
+            aggregate_info,
+            aggregate_ts,
+            connector_status,
+            connector_info,
+            connector_ts,
+        ) = await database_sync_to_async(_fetch_chargers)()
+
+        self.assertEqual(aggregate_status, "Downloaded")
+        self.assertEqual(connector_status, "Downloaded")
+        self.assertEqual(aggregate_info, "")
+        self.assertEqual(connector_info, "")
+        self.assertIsNotNone(aggregate_ts)
+        self.assertIsNotNone(connector_ts)
+        self.assertAlmostEqual(
+            (connector_ts - aggregate_ts).total_seconds(), 0, delta=1.0
+        )
+
+        log_entries = store.get_logs(
+            store.identity_key("FWCONN", 2), log_type="charger"
+        )
+        self.assertTrue(
+            any("FirmwareStatusNotification" in entry for entry in log_entries)
+        )
+        log_entries_agg = store.get_logs(
+            store.identity_key("FWCONN", None), log_type="charger"
+        )
+        self.assertTrue(
+            any("FirmwareStatusNotification" in entry for entry in log_entries_agg)
+        )
+
+        store.clear_log(store.identity_key("FWCONN", 2), log_type="charger")
+        store.clear_log(store.identity_key("FWCONN", None), log_type="charger")
+
+        await communicator.disconnect()
+
     async def test_vin_recorded(self):
         await database_sync_to_async(Charger.objects.create)(charger_id="VINREC")
         communicator = WebsocketCommunicator(application, "/VINREC/")
@@ -153,8 +551,119 @@ class CSMSConsumerTests(TransactionTestCase):
         await communicator.send_json_to([2, "1", "MeterValues", payload])
         await communicator.receive_json_from()
 
-        charger = await database_sync_to_async(Charger.objects.get)(charger_id="NEWCID")
-        self.assertEqual(charger.connector_id, "7")
+        charger = await database_sync_to_async(Charger.objects.get)(
+            charger_id="NEWCID", connector_id=7
+        )
+        self.assertEqual(charger.connector_id, 7)
+
+        await communicator.disconnect()
+
+    async def test_new_charger_created_for_different_connector(self):
+        communicator = WebsocketCommunicator(application, "/DUPC/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        payload1 = {
+            "connectorId": 1,
+            "meterValue": [
+                {
+                    "timestamp": timezone.now().isoformat(),
+                    "sampledValue": [{"value": "1"}],
+                }
+            ],
+        }
+        await communicator.send_json_to([2, "1", "MeterValues", payload1])
+        await communicator.receive_json_from()
+        await communicator.disconnect()
+        await communicator.wait()
+        await database_sync_to_async(close_old_connections)()
+
+        communicator = WebsocketCommunicator(application, "/DUPC/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+        payload2 = {
+            "connectorId": 2,
+            "meterValue": [
+                {
+                    "timestamp": timezone.now().isoformat(),
+                    "sampledValue": [{"value": "1"}],
+                }
+            ],
+        }
+        await communicator.send_json_to([2, "1", "MeterValues", payload2])
+        await communicator.receive_json_from()
+        await communicator.disconnect()
+        await communicator.wait()
+        await database_sync_to_async(close_old_connections)()
+
+        count = await self._retry_db(
+            lambda: Charger.objects.filter(charger_id="DUPC").count()
+        )
+        self.assertEqual(count, 3)
+        connectors = await self._retry_db(
+            lambda: list(
+                Charger.objects.filter(charger_id="DUPC").values_list(
+                    "connector_id", flat=True
+                )
+            )
+        )
+        self.assertIn(1, connectors)
+        self.assertIn(2, connectors)
+        self.assertIn(None, connectors)
+
+    async def test_console_reference_created_for_aggregate_connector(self):
+        communicator = ClientWebsocketCommunicator(
+            application,
+            "/CONREF/",
+            client=("203.0.113.5", 12345),
+        )
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.send_json_to([2, "1", "BootNotification", {}])
+        await communicator.receive_json_from()
+
+        reference = await database_sync_to_async(
+            lambda: Reference.objects.get(alt_text="CONREF Console")
+        )()
+        self.assertEqual(reference.value, "http://203.0.113.5:8900")
+        self.assertTrue(reference.show_in_header)
+
+        await communicator.send_json_to(
+            [
+                2,
+                "2",
+                "StatusNotification",
+                {"connectorId": 1, "status": "Available"},
+            ]
+        )
+        await communicator.receive_json_from()
+
+        count = await database_sync_to_async(
+            lambda: Reference.objects.filter(alt_text="CONREF Console").count()
+        )()
+        self.assertEqual(count, 1)
+
+        await communicator.disconnect()
+
+    async def test_console_reference_uses_forwarded_for_header(self):
+        communicator = ClientWebsocketCommunicator(
+            application,
+            "/FORWARDED/",
+            client=("127.0.0.1", 23456),
+            headers=[(b"x-forwarded-for", b"198.51.100.75, 127.0.0.1")],
+        )
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+        self.assertIn("198.51.100.75", store.ip_connections)
+
+        await communicator.send_json_to([2, "1", "BootNotification", {}])
+        await communicator.receive_json_from()
+
+        reference = await database_sync_to_async(
+            lambda: Reference.objects.get(alt_text="FORWARDED Console")
+        )()
+        self.assertEqual(reference.value, "http://198.51.100.75:8900")
 
         await communicator.disconnect()
 
@@ -208,6 +717,58 @@ class CSMSConsumerTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    async def test_diagnostics_status_notification_updates_records(self):
+        communicator = WebsocketCommunicator(application, "/DIAGCP/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        reported_at = timezone.now().replace(microsecond=0)
+        payload = {
+            "status": "Uploaded",
+            "connectorId": 5,
+            "uploadLocation": "https://example.com/diag.tar",
+            "timestamp": reported_at.isoformat(),
+        }
+
+        await communicator.send_json_to(
+            [2, "1", "DiagnosticsStatusNotification", payload]
+        )
+        response = await communicator.receive_json_from()
+        self.assertEqual(response[0], 3)
+        self.assertEqual(response[2], {})
+
+        def _fetch():
+            aggregate = Charger.objects.get(charger_id="DIAGCP", connector_id=None)
+            connector = Charger.objects.get(charger_id="DIAGCP", connector_id=5)
+            return aggregate, connector
+
+        aggregate, connector = await database_sync_to_async(_fetch)()
+        self.assertEqual(aggregate.diagnostics_status, "Uploaded")
+        self.assertEqual(connector.diagnostics_status, "Uploaded")
+        self.assertEqual(
+            aggregate.diagnostics_location, "https://example.com/diag.tar"
+        )
+        self.assertEqual(
+            connector.diagnostics_location, "https://example.com/diag.tar"
+        )
+        self.assertEqual(aggregate.diagnostics_timestamp, reported_at)
+        self.assertEqual(connector.diagnostics_timestamp, reported_at)
+
+        connector_logs = store.get_logs(
+            store.identity_key("DIAGCP", 5), log_type="charger"
+        )
+        aggregate_logs = store.get_logs(
+            store.identity_key("DIAGCP", None), log_type="charger"
+        )
+        self.assertTrue(
+            any("DiagnosticsStatusNotification" in entry for entry in connector_logs)
+        )
+        self.assertTrue(
+            any("DiagnosticsStatusNotification" in entry for entry in aggregate_logs)
+        )
+
+        await communicator.disconnect()
+
     async def test_temperature_recorded(self):
         charger = await database_sync_to_async(Charger.objects.create)(
             charger_id="TEMP1"
@@ -245,6 +806,106 @@ class CSMSConsumerTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    def test_status_notification_updates_models_and_views(self):
+        serial = "STATUS-CP"
+        payload = {
+            "connectorId": 1,
+            "status": "Faulted",
+            "errorCode": "GroundFailure",
+            "info": "Relay malfunction",
+            "vendorId": "ACME",
+            "timestamp": "2024-01-01T12:34:56Z",
+        }
+
+        async_to_sync(self._send_status_notification)(serial, payload)
+
+        expected_ts = parse_datetime(payload["timestamp"])
+        aggregate = Charger.objects.get(charger_id=serial, connector_id=None)
+        connector = Charger.objects.get(charger_id=serial, connector_id=1)
+
+        vendor_data = {"info": payload["info"], "vendorId": payload["vendorId"]}
+        self.assertEqual(aggregate.last_status, payload["status"])
+        self.assertEqual(aggregate.last_error_code, payload["errorCode"])
+        self.assertEqual(aggregate.last_status_vendor_info, vendor_data)
+        self.assertEqual(aggregate.last_status_timestamp, expected_ts)
+        self.assertEqual(connector.last_status, payload["status"])
+        self.assertEqual(connector.last_error_code, payload["errorCode"])
+        self.assertEqual(connector.last_status_vendor_info, vendor_data)
+        self.assertEqual(connector.last_status_timestamp, expected_ts)
+
+        connector_log = store.get_logs(
+            store.identity_key(serial, 1), log_type="charger"
+        )
+        self.assertTrue(
+            any("StatusNotification processed" in entry for entry in connector_log)
+        )
+
+        user = get_user_model().objects.create_user(
+            username="status", email="status@example.com", password="pwd"
+        )
+        self.client.force_login(user)
+
+        list_response = self.client.get(reverse("charger-list"))
+        self.assertEqual(list_response.status_code, 200)
+        chargers = list_response.json()["chargers"]
+        aggregate_entry = next(
+            item
+            for item in chargers
+            if item["charger_id"] == serial and item["connector_id"] is None
+        )
+        connector_entry = next(
+            item
+            for item in chargers
+            if item["charger_id"] == serial and item["connector_id"] == 1
+        )
+        expected_iso = expected_ts.isoformat()
+        self.assertEqual(aggregate_entry["lastStatus"], payload["status"])
+        self.assertEqual(aggregate_entry["lastErrorCode"], payload["errorCode"])
+        self.assertEqual(aggregate_entry["lastStatusVendorInfo"], vendor_data)
+        self.assertEqual(aggregate_entry["lastStatusTimestamp"], expected_iso)
+        self.assertEqual(aggregate_entry["status"], "Faulted (GroundFailure)")
+        self.assertEqual(aggregate_entry["statusColor"], "#dc3545")
+        self.assertEqual(connector_entry["lastStatus"], payload["status"])
+        self.assertEqual(connector_entry["lastErrorCode"], payload["errorCode"])
+        self.assertEqual(connector_entry["lastStatusVendorInfo"], vendor_data)
+        self.assertEqual(connector_entry["lastStatusTimestamp"], expected_iso)
+        self.assertEqual(connector_entry["status"], "Faulted (GroundFailure)")
+        self.assertEqual(connector_entry["statusColor"], "#dc3545")
+
+        detail_response = self.client.get(
+            reverse("charger-detail-connector", args=[serial, 1])
+        )
+        self.assertEqual(detail_response.status_code, 200)
+        detail_payload = detail_response.json()
+        self.assertEqual(detail_payload["lastStatus"], payload["status"])
+        self.assertEqual(detail_payload["lastErrorCode"], payload["errorCode"])
+        self.assertEqual(detail_payload["lastStatusVendorInfo"], vendor_data)
+        self.assertEqual(detail_payload["lastStatusTimestamp"], expected_iso)
+        self.assertEqual(detail_payload["status"], "Faulted (GroundFailure)")
+        self.assertEqual(detail_payload["statusColor"], "#dc3545")
+
+        status_resp = self.client.get(
+            reverse("charger-status-connector", args=[serial, "1"])
+        )
+        self.assertContains(status_resp, "Faulted (GroundFailure)")
+        self.assertContains(status_resp, "Error code: GroundFailure")
+        self.assertContains(status_resp, "Vendor: ACME")
+        self.assertContains(status_resp, "Info: Relay malfunction")
+        self.assertContains(status_resp, "background-color: #dc3545")
+
+        aggregate_status = self.client.get(reverse("charger-status", args=[serial]))
+        self.assertContains(aggregate_status, "Reported status")
+        self.assertContains(aggregate_status, "Info: Relay malfunction")
+
+        page_resp = self.client.get(reverse("charger-page", args=[serial]))
+        self.assertContains(page_resp, "Faulted (GroundFailure)")
+        self.assertContains(page_resp, "Vendor")
+        self.assertContains(page_resp, "Relay malfunction")
+        self.assertContains(page_resp, "background-color: #dc3545")
+
+        store.clear_log(store.identity_key(serial, 1), log_type="charger")
+        store.clear_log(store.identity_key(serial, None), log_type="charger")
+
     async def test_message_logged_and_session_file_created(self):
         cid = "LOGTEST1"
         log_path = Path("logs") / f"charger.{cid}.log"
@@ -258,21 +919,25 @@ class CSMSConsumerTests(TransactionTestCase):
         connected, _ = await communicator.connect()
         self.assertTrue(connected)
 
-        await communicator.send_json_to([
-            2,
-            "1",
-            "StartTransaction",
-            {"meterStart": 1},
-        ])
+        await communicator.send_json_to(
+            [
+                2,
+                "1",
+                "StartTransaction",
+                {"meterStart": 1},
+            ]
+        )
         response = await communicator.receive_json_from()
         tx_id = response[2]["transactionId"]
 
-        await communicator.send_json_to([
-            2,
-            "2",
-            "StopTransaction",
-            {"transactionId": tx_id, "meterStop": 2},
-        ])
+        await communicator.send_json_to(
+            [
+                2,
+                "2",
+                "StopTransaction",
+                {"transactionId": tx_id, "meterStop": 2},
+            ]
+        )
         await communicator.receive_json_from()
         await communicator.disconnect()
 
@@ -313,12 +978,14 @@ class CSMSConsumerTests(TransactionTestCase):
         connected, _ = await communicator.connect()
         self.assertTrue(connected)
 
-        await communicator.send_json_to([
-            2,
-            "1",
-            "StartTransaction",
-            {"meterStart": 5},
-        ])
+        await communicator.send_json_to(
+            [
+                2,
+                "1",
+                "StartTransaction",
+                {"meterStart": 5},
+            ]
+        )
         await communicator.receive_json_from()
 
         await communicator.disconnect()
@@ -333,7 +1000,8 @@ class CSMSConsumerTests(TransactionTestCase):
         communicator1 = WebsocketCommunicator(application, "/DUPLICATE/")
         connected, _ = await communicator1.connect()
         self.assertTrue(connected)
-        first_consumer = store.connections.get("DUPLICATE")
+        pending_key = store.pending_key("DUPLICATE")
+        first_consumer = store.connections.get(pending_key)
 
         communicator2 = WebsocketCommunicator(application, "/DUPLICATE/")
         connected2, _ = await communicator2.connect()
@@ -341,9 +1009,119 @@ class CSMSConsumerTests(TransactionTestCase):
 
         # The first communicator should be closed when the second connects.
         await communicator1.wait()
-        self.assertIsNot(store.connections.get("DUPLICATE"), first_consumer)
+        self.assertIsNot(store.connections.get(pending_key), first_consumer)
+
+        await communicator2.disconnect()
+
+    async def test_connectors_share_serial_without_disconnecting(self):
+        communicator1 = WebsocketCommunicator(application, "/MULTI/")
+        connected1, _ = await communicator1.connect()
+        self.assertTrue(connected1)
+        await communicator1.send_json_to(
+            [
+                2,
+                "1",
+                "StartTransaction",
+                {"connectorId": 1, "meterStart": 10},
+            ]
+        )
+        await communicator1.receive_json_from()
+
+        communicator2 = WebsocketCommunicator(application, "/MULTI/")
+        connected2, _ = await communicator2.connect()
+        self.assertTrue(connected2)
+        await communicator2.send_json_to(
+            [
+                2,
+                "2",
+                "StartTransaction",
+                {"connectorId": 2, "meterStart": 10},
+            ]
+        )
+        await communicator2.receive_json_from()
 
+        key1 = store.identity_key("MULTI", 1)
+        key2 = store.identity_key("MULTI", 2)
+        self.assertIn(key1, store.connections)
+        self.assertIn(key2, store.connections)
+        self.assertIsNot(store.connections[key1], store.connections[key2])
+
+        await communicator1.disconnect()
         await communicator2.disconnect()
+        store.transactions.pop(key1, None)
+        store.transactions.pop(key2, None)
+
+
+    async def test_rate_limit_blocks_third_connection(self):
+        store.ip_connections.clear()
+        ip = "203.0.113.10"
+        communicator1 = ClientWebsocketCommunicator(
+            application, "/IPLIMIT1/", client=(ip, 1001)
+        )
+        communicator2 = ClientWebsocketCommunicator(
+            application, "/IPLIMIT2/", client=(ip, 1002)
+        )
+        communicator3 = ClientWebsocketCommunicator(
+            application, "/IPLIMIT3/", client=(ip, 1003)
+        )
+        other = ClientWebsocketCommunicator(
+            application, "/OTHERIP/", client=("198.51.100.5", 2001)
+        )
+        connected1 = connected2 = connected_other = False
+        try:
+            connected1, _ = await communicator1.connect()
+            self.assertTrue(connected1)
+            connected2, _ = await communicator2.connect()
+            self.assertTrue(connected2)
+            connected3, code = await communicator3.connect()
+            self.assertFalse(connected3)
+            self.assertEqual(code, 4003)
+            connected_other, _ = await other.connect()
+            self.assertTrue(connected_other)
+        finally:
+            if connected1:
+                await communicator1.disconnect()
+            if connected2:
+                await communicator2.disconnect()
+            if connected_other:
+                await other.disconnect()
+
+    async def test_rate_limit_allows_reconnect_after_disconnect(self):
+        store.ip_connections.clear()
+        ip = "203.0.113.20"
+        communicator1 = ClientWebsocketCommunicator(
+            application, "/LIMITRESET1/", client=(ip, 3001)
+        )
+        communicator2 = ClientWebsocketCommunicator(
+            application, "/LIMITRESET2/", client=(ip, 3002)
+        )
+        communicator3 = ClientWebsocketCommunicator(
+            application, "/LIMITRESET3/", client=(ip, 3003)
+        )
+        communicator3_retry = None
+        connected1 = connected2 = connected3_retry = False
+        try:
+            connected1, _ = await communicator1.connect()
+            self.assertTrue(connected1)
+            connected2, _ = await communicator2.connect()
+            self.assertTrue(connected2)
+            connected3, code = await communicator3.connect()
+            self.assertFalse(connected3)
+            self.assertEqual(code, 4003)
+            await communicator1.disconnect()
+            connected1 = False
+            communicator3_retry = ClientWebsocketCommunicator(
+                application, "/LIMITRESET4/", client=(ip, 3004)
+            )
+            connected3_retry, _ = await communicator3_retry.connect()
+            self.assertTrue(connected3_retry)
+        finally:
+            if connected1:
+                await communicator1.disconnect()
+            if connected2:
+                await communicator2.disconnect()
+            if connected3_retry and communicator3_retry is not None:
+                await communicator3_retry.disconnect()
 
 
 class ChargerLandingTests(TestCase):
@@ -359,10 +1137,17 @@ class ChargerLandingTests(TestCase):
 
         response = self.client.get(reverse("charger-page", args=["PAGE1"]))
         self.assertEqual(response.status_code, 200)
-        self.assertContains(
-            response,
-            "Plug in your vehicle and slide your RFID card over the reader to begin charging.",
-        )
+        self.assertEqual(response.context["LANGUAGE_CODE"], "es")
+        with override("es"):
+            self.assertContains(
+                response,
+                _(
+                    "Plug in your vehicle and slide your RFID card over the reader to begin charging."
+                ),
+            )
+            self.assertContains(response, _("Advanced View"))
+        status_url = reverse("charger-status-connector", args=["PAGE1", "all"])
+        self.assertContains(response, status_url)
 
     def test_status_page_renders(self):
         charger = Charger.objects.create(charger_id="PAGE2")
@@ -377,10 +1162,23 @@ class ChargerLandingTests(TestCase):
             meter_start=1000,
             start_time=timezone.now(),
         )
-        store.transactions[charger.charger_id] = tx
+        key = store.identity_key(charger.charger_id, charger.connector_id)
+        store.transactions[key] = tx
         resp = self.client.get(reverse("charger-page", args=["STATS"]))
-        self.assertContains(resp, "progress")
-        store.transactions.pop(charger.charger_id, None)
+        self.assertContains(resp, "progress-bar")
+        store.transactions.pop(key, None)
+
+    def test_display_name_used_on_public_pages(self):
+        charger = Charger.objects.create(
+            charger_id="NAMED",
+            display_name="Entrada",
+        )
+        landing = self.client.get(reverse("charger-page", args=["NAMED"]))
+        self.assertContains(landing, "Entrada")
+        status = self.client.get(
+            reverse("charger-status-connector", args=["NAMED", "all"])
+        )
+        self.assertContains(status, "Entrada")
 
     def test_total_includes_ongoing_transaction(self):
         charger = Charger.objects.create(charger_id="ONGOING")
@@ -389,7 +1187,8 @@ class ChargerLandingTests(TestCase):
             meter_start=1000,
             start_time=timezone.now(),
         )
-        store.transactions[charger.charger_id] = tx
+        key = store.identity_key(charger.charger_id, charger.connector_id)
+        store.transactions[key] = tx
         MeterReading.objects.create(
             charger=charger,
             transaction=tx,
@@ -399,10 +1198,29 @@ class ChargerLandingTests(TestCase):
             unit="W",
         )
         resp = self.client.get(reverse("charger-status", args=["ONGOING"]))
-        self.assertContains(
-            resp, 'Total Energy: <span id="total-kw">1.50</span> kW'
+        self.assertContains(resp, 'Total Energy: <span id="total-kw">1.50</span> kW')
+        store.transactions.pop(key, None)
+
+    def test_connector_specific_routes_render(self):
+        Charger.objects.create(charger_id="ROUTED")
+        connector = Charger.objects.create(charger_id="ROUTED", connector_id=1)
+        page = self.client.get(reverse("charger-page-connector", args=["ROUTED", "1"]))
+        self.assertEqual(page.status_code, 200)
+        status = self.client.get(
+            reverse("charger-status-connector", args=["ROUTED", "1"])
+        )
+        self.assertEqual(status.status_code, 200)
+        search = self.client.get(
+            reverse("charger-session-search-connector", args=["ROUTED", "1"])
         )
-        store.transactions.pop(charger.charger_id, None)
+        self.assertEqual(search.status_code, 200)
+        log_id = store.identity_key("ROUTED", connector.connector_id)
+        store.add_log(log_id, "entry", log_type="charger")
+        log = self.client.get(
+            reverse("charger-log-connector", args=["ROUTED", "1"]) + "?type=charger"
+        )
+        self.assertContains(log, "entry")
+        store.clear_log(log_id, log_type="charger")
 
     def test_temperature_displayed(self):
         charger = Charger.objects.create(
@@ -413,20 +1231,22 @@ class ChargerLandingTests(TestCase):
         self.assertContains(resp, "21.5")
 
     def test_log_page_renders_without_charger(self):
-        store.add_log("LOG1", "hello", log_type="charger")
-        entry = store.get_logs("LOG1", log_type="charger")[0]
+        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$")
         resp = self.client.get(reverse("charger-log", args=["LOG1"]) + "?type=charger")
         self.assertEqual(resp.status_code, 200)
         self.assertContains(resp, "hello")
-        store.clear_log("LOG1", log_type="charger")
+        store.clear_log(log_id, log_type="charger")
 
     def test_log_page_is_case_insensitive(self):
-        store.add_log("cp2", "entry", log_type="charger")
+        log_id = store.identity_key("cp2", None)
+        store.add_log(log_id, "entry", log_type="charger")
         resp = self.client.get(reverse("charger-log", args=["CP2"]) + "?type=charger")
         self.assertEqual(resp.status_code, 200)
         self.assertContains(resp, "entry")
-        store.clear_log("cp2", log_type="charger")
+        store.clear_log(log_id, log_type="charger")
 
 
 class SimulatorLandingTests(TestCase):
@@ -471,7 +1291,7 @@ class ChargerAdminTests(TestCase):
         url = reverse("admin:ocpp_charger_changelist")
         resp = self.client.get(url)
         self.assertContains(resp, charger.get_absolute_url())
-        status_url = reverse("charger-status", args=["ADMIN1"])
+        status_url = reverse("charger-status-connector", args=["ADMIN1", "all"])
         self.assertContains(resp, status_url)
 
     def test_admin_does_not_list_qr_link(self):
@@ -484,9 +1304,19 @@ class ChargerAdminTests(TestCase):
         charger = Charger.objects.create(charger_id="LOG1")
         url = reverse("admin:ocpp_charger_changelist")
         resp = self.client.get(url)
-        log_url = reverse("charger-log", args=["LOG1"]) + "?type=charger"
+        log_url = reverse("admin:ocpp_charger_log", args=[charger.pk])
         self.assertContains(resp, log_url)
 
+    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)
+        store.add_log(log_id, "entry", log_type="charger")
+        url = reverse("admin:ocpp_charger_log", args=[charger.pk])
+        resp = self.client.get(url)
+        self.assertEqual(resp.status_code, 200)
+        self.assertContains(resp, "entry")
+        store.clear_log(log_id, log_type="charger")
+
     def test_admin_change_links_landing_page(self):
         charger = Charger.objects.create(charger_id="CHANGE1")
         url = reverse("admin:ocpp_charger_change", args=[charger.pk])
@@ -525,12 +1355,14 @@ class ChargerAdminTests(TestCase):
             timestamp=timezone.now(),
             value=1,
         )
-        store.add_log("PURGE1", "entry", log_type="charger")
+        store.add_log(store.identity_key("PURGE1", None), "entry", log_type="charger")
         url = reverse("admin:ocpp_charger_changelist")
-        self.client.post(url, {"action": "purge_data", "_selected_action": [charger.pk]})
+        self.client.post(
+            url, {"action": "purge_data", "_selected_action": [charger.pk]}
+        )
         self.assertFalse(Transaction.objects.filter(charger=charger).exists())
         self.assertFalse(MeterReading.objects.filter(charger=charger).exists())
-        self.assertNotIn("PURGE1", store.logs["charger"])
+        self.assertNotIn(store.identity_key("PURGE1", None), store.logs["charger"])
 
     def test_delete_requires_purge(self):
         charger = Charger.objects.create(charger_id="DEL1")
@@ -543,11 +1375,44 @@ class ChargerAdminTests(TestCase):
             self.client.post(delete_url, {"post": "yes"})
         self.assertTrue(Charger.objects.filter(pk=charger.pk).exists())
         url = reverse("admin:ocpp_charger_changelist")
-        self.client.post(url, {"action": "purge_data", "_selected_action": [charger.pk]})
+        self.client.post(
+            url, {"action": "purge_data", "_selected_action": [charger.pk]}
+        )
         self.client.post(delete_url, {"post": "yes"})
         self.assertFalse(Charger.objects.filter(pk=charger.pk).exists())
 
 
+class LocationAdminTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User = get_user_model()
+        self.admin = User.objects.create_superuser(
+            username="loc-admin", password="secret", email="loc@example.com"
+        )
+        self.client.force_login(self.admin)
+
+    def test_change_form_lists_related_chargers(self):
+        location = Location.objects.create(name="LocAdmin")
+        base = Charger.objects.create(charger_id="LOCBASE", location=location)
+        connector = Charger.objects.create(
+            charger_id="LOCALTWO",
+            connector_id=1,
+            location=location,
+        )
+
+        url = reverse("admin:ocpp_location_change", args=[location.pk])
+        resp = self.client.get(url)
+        self.assertEqual(resp.status_code, 200)
+
+        base_change_url = reverse("admin:ocpp_charger_change", args=[base.pk])
+        connector_change_url = reverse("admin:ocpp_charger_change", args=[connector.pk])
+
+        self.assertContains(resp, base_change_url)
+        self.assertContains(resp, connector_change_url)
+        self.assertContains(resp, f"Charge Point: {base.charger_id}")
+        self.assertContains(resp, f"Charge Point: {connector.charger_id} #1")
+
+
 class TransactionAdminTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -572,7 +1437,7 @@ class TransactionAdminTests(TestCase):
         self.assertContains(resp, str(reading.value))
 
 
-class SimulatorAdminTests(TestCase):
+class SimulatorAdminTests(TransactionTestCase):
     def setUp(self):
         self.client = Client()
         User = get_user_model()
@@ -580,21 +1445,88 @@ class SimulatorAdminTests(TestCase):
             username="admin2", password="secret", email="admin2@example.com"
         )
         self.client.force_login(self.admin)
+        store.simulators.clear()
+        store.logs["simulator"].clear()
+        store.log_names["simulator"].clear()
 
     def test_admin_lists_log_link(self):
         sim = Simulator.objects.create(name="SIM", cp_path="SIMX")
         url = reverse("admin:ocpp_simulator_changelist")
         resp = self.client.get(url)
-        log_url = reverse("charger-log", args=["SIMX"]) + "?type=simulator"
+        log_url = reverse("admin:ocpp_simulator_log", args=[sim.pk])
+        self.assertContains(resp, log_url)
+
+    def test_admin_log_view_displays_entries(self):
+        sim = Simulator.objects.create(name="SIMLOG", cp_path="SIMLOG")
+        store.add_log("SIMLOG", "entry", log_type="simulator")
+        url = reverse("admin:ocpp_simulator_log", args=[sim.pk])
+        resp = self.client.get(url)
+        self.assertEqual(resp.status_code, 200)
+        self.assertContains(resp, "entry")
+        store.clear_log("SIMLOG", log_type="simulator")
+
+    @patch("ocpp.admin.ChargePointSimulator.start")
+    def test_start_simulator_message_includes_log_link(self, mock_start):
+        sim = Simulator.objects.create(name="SIMMSG", cp_path="SIMMSG")
+        mock_start.return_value = (True, "Connection accepted", "/tmp/sim.log")
+        url = reverse("admin:ocpp_simulator_changelist")
+        resp = self.client.post(
+            url,
+            {"action": "start_simulator", "_selected_action": [sim.pk]},
+            follow=True,
+        )
+        self.assertEqual(resp.status_code, 200)
+        log_url = reverse("admin:ocpp_simulator_log", args=[sim.pk])
+        self.assertContains(resp, "View Log")
         self.assertContains(resp, log_url)
+        self.assertContains(resp, "/tmp/sim.log")
+        mock_start.assert_called_once()
+        store.simulators.clear()
 
     def test_admin_shows_ws_url(self):
-        sim = Simulator.objects.create(name="SIM2", cp_path="SIMY", host="h",
-                                      ws_port=1111)
+        sim = Simulator.objects.create(
+            name="SIM2", cp_path="SIMY", host="h", ws_port=1111
+        )
         url = reverse("admin:ocpp_simulator_changelist")
         resp = self.client.get(url)
         self.assertContains(resp, "ws://h:1111/SIMY/")
 
+    def test_admin_ws_url_without_port(self):
+        sim = Simulator.objects.create(
+            name="SIMNP", cp_path="SIMNP", host="h", ws_port=None
+        )
+        url = reverse("admin:ocpp_simulator_changelist")
+        resp = self.client.get(url)
+        self.assertContains(resp, "ws://h/SIMNP/")
+
+    def test_send_open_door_action_requires_running_simulator(self):
+        sim = Simulator.objects.create(name="SIMDO", cp_path="SIMDO")
+        url = reverse("admin:ocpp_simulator_changelist")
+        resp = self.client.post(
+            url,
+            {"action": "send_open_door", "_selected_action": [sim.pk]},
+            follow=True,
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.assertContains(resp, "simulator is not running")
+        self.assertFalse(Simulator.objects.get(pk=sim.pk).door_open)
+
+    def test_send_open_door_action_triggers_simulator(self):
+        sim = Simulator.objects.create(name="SIMTRIG", cp_path="SIMTRIG")
+        stub = SimpleNamespace(trigger_door_open=Mock())
+        store.simulators[sim.pk] = stub
+        url = reverse("admin:ocpp_simulator_changelist")
+        resp = self.client.post(
+            url,
+            {"action": "send_open_door", "_selected_action": [sim.pk]},
+            follow=True,
+        )
+        self.assertEqual(resp.status_code, 200)
+        stub.trigger_door_open.assert_called_once()
+        self.assertContains(resp, "DoorOpen status notification sent")
+        self.assertFalse(Simulator.objects.get(pk=sim.pk).door_open)
+        store.simulators.pop(sim.pk, None)
+
     def test_as_config_includes_custom_fields(self):
         sim = Simulator.objects.create(
             name="SIM3",
@@ -612,12 +1544,53 @@ class SimulatorAdminTests(TestCase):
         self.assertEqual(cfg.pre_charge_delay, 5)
         self.assertEqual(cfg.vin, "WP0ZZZ99999999999")
 
+    def _post_simulator_change(self, sim: Simulator, **overrides):
+        url = reverse("admin:ocpp_simulator_change", args=[sim.pk])
+        data = {
+            "name": sim.name,
+            "cp_path": sim.cp_path,
+            "host": sim.host,
+            "ws_port": sim.ws_port or "",
+            "rfid": sim.rfid,
+            "duration": sim.duration,
+            "interval": sim.interval,
+            "pre_charge_delay": sim.pre_charge_delay,
+            "kw_max": sim.kw_max,
+            "repeat": "on" if sim.repeat else "",
+            "username": sim.username,
+            "password": sim.password,
+            "door_open": "on" if overrides.get("door_open", False) else "",
+            "_save": "Save",
+        }
+        data.update(overrides)
+        return self.client.post(url, data, follow=True)
+
+    def test_save_model_triggers_door_open(self):
+        sim = Simulator.objects.create(name="SIMSAVE", cp_path="SIMSAVE")
+        stub = SimpleNamespace(trigger_door_open=Mock())
+        store.simulators[sim.pk] = stub
+        resp = self._post_simulator_change(sim, door_open="on")
+        self.assertEqual(resp.status_code, 200)
+        stub.trigger_door_open.assert_called_once()
+        self.assertContains(resp, "DoorOpen status notification sent")
+        self.assertFalse(Simulator.objects.get(pk=sim.pk).door_open)
+        store.simulators.pop(sim.pk, None)
+
+    def test_save_model_reports_error_when_not_running(self):
+        sim = Simulator.objects.create(name="SIMERR", cp_path="SIMERR")
+        resp = self._post_simulator_change(sim, door_open="on")
+        self.assertEqual(resp.status_code, 200)
+        self.assertContains(resp, "simulator is not running")
+        self.assertFalse(Simulator.objects.get(pk=sim.pk).door_open)
+
     async def test_unknown_charger_auto_registered(self):
         communicator = WebsocketCommunicator(application, "/NEWCHG/")
         connected, _ = await communicator.connect()
         self.assertTrue(connected)
 
-        exists = await database_sync_to_async(Charger.objects.filter(charger_id="NEWCHG").exists)()
+        exists = await database_sync_to_async(
+            Charger.objects.filter(charger_id="NEWCHG").exists
+        )()
         self.assertTrue(exists)
 
         charger = await database_sync_to_async(Charger.objects.get)(charger_id="NEWCHG")
@@ -636,21 +1609,27 @@ class SimulatorAdminTests(TestCase):
         self.assertEqual(charger.last_path, "/foo/NEST/")
 
     async def test_rfid_required_rejects_invalid(self):
-        await database_sync_to_async(Charger.objects.create)(charger_id="RFID", require_rfid=True)
+        await database_sync_to_async(Charger.objects.create)(
+            charger_id="RFID", require_rfid=True
+        )
         communicator = WebsocketCommunicator(application, "/RFID/")
         connected, _ = await communicator.connect()
         self.assertTrue(connected)
 
-        await communicator.send_json_to([
-            2,
-            "1",
-            "StartTransaction",
-            {"meterStart": 0},
-        ])
+        await communicator.send_json_to(
+            [
+                2,
+                "1",
+                "StartTransaction",
+                {"meterStart": 0},
+            ]
+        )
         response = await communicator.receive_json_from()
         self.assertEqual(response[2]["idTagInfo"]["status"], "Invalid")
 
-        exists = await database_sync_to_async(Transaction.objects.filter(charger__charger_id="RFID").exists)()
+        exists = await database_sync_to_async(
+            Transaction.objects.filter(charger__charger_id="RFID").exists
+        )()
         self.assertFalse(exists)
 
         await communicator.disconnect()
@@ -668,22 +1647,28 @@ class SimulatorAdminTests(TestCase):
         )
         tag = await database_sync_to_async(RFID.objects.create)(rfid="CARDX")
         await database_sync_to_async(acc.rfids.add)(tag)
-        await database_sync_to_async(Charger.objects.create)(charger_id="RFIDOK", require_rfid=True)
+        await database_sync_to_async(Charger.objects.create)(
+            charger_id="RFIDOK", require_rfid=True
+        )
         communicator = WebsocketCommunicator(application, "/RFIDOK/")
         connected, _ = await communicator.connect()
         self.assertTrue(connected)
 
-        await communicator.send_json_to([
-            2,
-            "1",
-            "StartTransaction",
-            {"meterStart": 5, "idTag": "CARDX"},
-        ])
+        await communicator.send_json_to(
+            [
+                2,
+                "1",
+                "StartTransaction",
+                {"meterStart": 5, "idTag": "CARDX"},
+            ]
+        )
         response = await communicator.receive_json_from()
         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="RFIDOK")
+        tx = await database_sync_to_async(Transaction.objects.get)(
+            pk=tx_id, charger__charger_id="RFIDOK"
+        )
         self.assertEqual(tx.account_id, user.energy_account.id)
 
     async def test_status_fields_updated(self):
@@ -709,7 +1694,10 @@ class SimulatorAdminTests(TestCase):
         await communicator.receive_json_from()
 
         await database_sync_to_async(charger.refresh_from_db)()
-        self.assertEqual(charger.last_meter_values.get("meterValue")[0]["sampledValue"][0]["value"], "42")
+        self.assertEqual(
+            charger.last_meter_values.get("meterValue")[0]["sampledValue"][0]["value"],
+            "42",
+        )
 
         await communicator.disconnect()
 
@@ -724,6 +1712,18 @@ class ChargerLocationTests(TestCase):
         self.assertAlmostEqual(float(charger.longitude), -20.654321)
         self.assertEqual(charger.name, "Loc1")
 
+    def test_location_created_when_missing(self):
+        charger = Charger.objects.create(charger_id="AUTOLOC")
+        self.assertIsNotNone(charger.location)
+        self.assertEqual(charger.location.name, "AUTOLOC")
+
+    def test_location_reused_for_matching_serial(self):
+        first = Charger.objects.create(charger_id="SHARE", connector_id=1)
+        first.location.name = "Custom"
+        first.location.save()
+        second = Charger.objects.create(charger_id="SHARE", connector_id=2)
+        self.assertEqual(second.location, first.location)
+
 
 class MeterReadingTests(TransactionTestCase):
     async def test_meter_values_saved_as_readings(self):
@@ -750,10 +1750,14 @@ class MeterReadingTests(TransactionTestCase):
         await communicator.send_json_to([2, "1", "MeterValues", payload])
         await communicator.receive_json_from()
 
-        reading = await database_sync_to_async(MeterReading.objects.get)(charger__charger_id="MR1")
+        reading = await database_sync_to_async(MeterReading.objects.get)(
+            charger__charger_id="MR1"
+        )
         self.assertEqual(reading.transaction_id, 100)
         self.assertEqual(str(reading.value), "2.749")
-        tx = await database_sync_to_async(Transaction.objects.get)(pk=100, charger__charger_id="MR1")
+        tx = await database_sync_to_async(Transaction.objects.get)(
+            pk=100, charger__charger_id="MR1"
+        )
         self.assertEqual(tx.meter_start, 2749)
 
         await communicator.disconnect()
@@ -819,7 +1823,9 @@ class ChargePointSimulatorTests(TransactionTestCase):
                     )
                     break
 
-        server = await websockets.serve(handler, "127.0.0.1", 0, subprotocols=["ocpp1.6"])
+        server = await websockets.serve(
+            handler, "127.0.0.1", 0, subprotocols=["ocpp1.6"]
+        )
         port = server.sockets[0].getsockname()[1]
 
         try:
@@ -833,6 +1839,8 @@ class ChargePointSimulatorTests(TransactionTestCase):
                 kw_min=0.1,
                 kw_max=0.2,
                 pre_charge_delay=0.0,
+                serial_number="SN123",
+                connector_id=7,
             )
             sim = ChargePointSimulator(cfg)
             await sim._run_session()
@@ -843,8 +1851,11 @@ class ChargePointSimulatorTests(TransactionTestCase):
         actions = [msg[2] for msg in received]
         self.assertIn("BootNotification", actions)
         self.assertIn("StartTransaction", actions)
+        boot_msg = next(msg for msg in received if msg[2] == "BootNotification")
+        self.assertEqual(boot_msg[3].get("serialNumber"), "SN123")
         start_msg = next(msg for msg in received if msg[2] == "StartTransaction")
         self.assertEqual(start_msg[3].get("vin"), "WP0ZZZ12345678901")
+        self.assertEqual(start_msg[3].get("connectorId"), 7)
 
     async def test_start_returns_status_and_log(self):
         async def handler(ws):
@@ -867,9 +1878,7 @@ class ChargePointSimulatorTests(TransactionTestCase):
                     )
                 elif action == "Authorize":
                     await ws.send(
-                        json.dumps(
-                            [3, data[1], {"idTagInfo": {"status": "Accepted"}}]
-                        )
+                        json.dumps([3, data[1], {"idTagInfo": {"status": "Accepted"}}])
                     )
                 elif action == "StartTransaction":
                     await ws.send(
@@ -886,15 +1895,15 @@ class ChargePointSimulatorTests(TransactionTestCase):
                     )
                 elif action == "StopTransaction":
                     await ws.send(
-                        json.dumps(
-                            [3, data[1], {"idTagInfo": {"status": "Accepted"}}]
-                        )
+                        json.dumps([3, data[1], {"idTagInfo": {"status": "Accepted"}}])
                     )
                     break
                 else:
                     await ws.send(json.dumps([3, data[1], {}]))
 
-        server = await websockets.serve(handler, "127.0.0.1", 0, subprotocols=["ocpp1.6"])
+        server = await websockets.serve(
+            handler, "127.0.0.1", 0, subprotocols=["ocpp1.6"]
+        )
         port = server.sockets[0].getsockname()[1]
 
         cfg = SimulatorConfig(
@@ -927,9 +1936,7 @@ class ChargePointSimulatorTests(TransactionTestCase):
                 data = json.loads(msg)
                 action = data[2]
                 if action == "BootNotification":
-                    await ws.send(
-                        json.dumps([3, data[1], {"status": "Accepted"}])
-                    )
+                    await ws.send(json.dumps([3, data[1], {"status": "Accepted"}]))
                 elif action == "Authorize":
                     await ws.send(
                         json.dumps([3, data[1], {"idTagInfo": {"status": "Accepted"}}])
@@ -937,7 +1944,9 @@ class ChargePointSimulatorTests(TransactionTestCase):
                     await ws.close()
                     break
 
-        server = await websockets.serve(handler, "127.0.0.1", 0, subprotocols=["ocpp1.6"])
+        server = await websockets.serve(
+            handler, "127.0.0.1", 0, subprotocols=["ocpp1.6"]
+        )
         port = server.sockets[0].getsockname()[1]
 
         cfg = SimulatorConfig(
@@ -973,7 +1982,12 @@ class ChargePointSimulatorTests(TransactionTestCase):
                 action = data[2]
                 if action == "BootNotification":
                     await ws.send(json.dumps([3, data[1], {"status": "Accepted"}]))
-                elif action in {"Authorize", "StatusNotification", "Heartbeat", "MeterValues"}:
+                elif action in {
+                    "Authorize",
+                    "StatusNotification",
+                    "Heartbeat",
+                    "MeterValues",
+                }:
                     await ws.send(json.dumps([3, data[1], {}]))
                 elif action == "StartTransaction":
                     await ws.send(
@@ -981,15 +1995,22 @@ class ChargePointSimulatorTests(TransactionTestCase):
                             [
                                 3,
                                 data[1],
-                                {"transactionId": 1, "idTagInfo": {"status": "Accepted"}},
+                                {
+                                    "transactionId": 1,
+                                    "idTagInfo": {"status": "Accepted"},
+                                },
                             ]
                         )
                     )
                 elif action == "StopTransaction":
-                    await ws.send(json.dumps([3, data[1], {"idTagInfo": {"status": "Accepted"}}]))
+                    await ws.send(
+                        json.dumps([3, data[1], {"idTagInfo": {"status": "Accepted"}}])
+                    )
                     break
 
-        server = await websockets.serve(handler, "127.0.0.1", 0, subprotocols=["ocpp1.6"])
+        server = await websockets.serve(
+            handler, "127.0.0.1", 0, subprotocols=["ocpp1.6"]
+        )
         port = server.sockets[0].getsockname()[1]
 
         try:
@@ -1020,13 +2041,16 @@ class ChargePointSimulatorTests(TransactionTestCase):
             async for _ in ws:
                 pass
 
-        server = await websockets.serve(handler, "127.0.0.1", 0, subprotocols=["ocpp1.6"])
+        server = await websockets.serve(
+            handler, "127.0.0.1", 0, subprotocols=["ocpp1.6"]
+        )
         port = server.sockets[0].getsockname()[1]
 
         cfg = SimulatorConfig(host="127.0.0.1", ws_port=port, cp_path="SIMTO/")
         sim = ChargePointSimulator(cfg)
         store.simulators[99] = sim
         try:
+
             async def fake_wait_for(coro, timeout):
                 coro.close()
                 raise asyncio.TimeoutError
@@ -1042,6 +2066,80 @@ class ChargePointSimulatorTests(TransactionTestCase):
             server.close()
             await server.wait_closed()
 
+    async def test_door_open_event_sends_notifications(self):
+        status_payloads = []
+
+        async def handler(ws):
+            async for msg in ws:
+                data = json.loads(msg)
+                action = data[2]
+                if action == "BootNotification":
+                    await ws.send(
+                        json.dumps(
+                            [
+                                3,
+                                data[1],
+                                {"status": "Accepted", "currentTime": "2024-01-01T00:00:00Z"},
+                            ]
+                        )
+                    )
+                elif action == "Authorize":
+                    await ws.send(json.dumps([3, data[1], {"idTagInfo": {"status": "Accepted"}}]))
+                elif action == "StatusNotification":
+                    status_payloads.append(data[3])
+                    await ws.send(json.dumps([3, data[1], {}]))
+                elif action == "StartTransaction":
+                    await ws.send(
+                        json.dumps(
+                            [
+                                3,
+                                data[1],
+                                {"transactionId": 1, "idTagInfo": {"status": "Accepted"}},
+                            ]
+                        )
+                    )
+                elif action == "MeterValues":
+                    await ws.send(json.dumps([3, data[1], {}]))
+                elif action == "StopTransaction":
+                    await ws.send(json.dumps([3, data[1], {"idTagInfo": {"status": "Accepted"}}]))
+                    break
+
+        server = await websockets.serve(
+            handler, "127.0.0.1", 0, subprotocols=["ocpp1.6"]
+        )
+        port = server.sockets[0].getsockname()[1]
+
+        cfg = SimulatorConfig(
+            host="127.0.0.1",
+            ws_port=port,
+            cp_path="SIMDOOR/",
+            duration=0.2,
+            interval=0.05,
+            pre_charge_delay=0.0,
+        )
+        sim = ChargePointSimulator(cfg)
+        sim.trigger_door_open()
+        try:
+            await sim._run_session()
+        finally:
+            server.close()
+            await server.wait_closed()
+            store.clear_log(cfg.cp_path, log_type="simulator")
+
+        door_open_messages = [p for p in status_payloads if p.get("errorCode") == "DoorOpen"]
+        door_closed_messages = [p for p in status_payloads if p.get("errorCode") == "NoError"]
+        self.assertTrue(door_open_messages)
+        self.assertTrue(door_closed_messages)
+        first_open = next(
+            idx for idx, payload in enumerate(status_payloads) if payload.get("errorCode") == "DoorOpen"
+        )
+        first_close = next(
+            idx for idx, payload in enumerate(status_payloads) if payload.get("errorCode") == "NoError"
+        )
+        self.assertLess(first_open, first_close)
+        self.assertEqual(door_open_messages[0].get("status"), "Faulted")
+        self.assertEqual(door_closed_messages[0].get("status"), "Available")
+
 
 class PurgeMeterReadingsTaskTests(TestCase):
     def test_purge_old_meter_readings(self):
@@ -1066,7 +2164,9 @@ class PurgeMeterReadingsTaskTests(TestCase):
 
         self.assertEqual(MeterReading.objects.count(), 1)
         self.assertTrue(
-            MeterReading.objects.filter(timestamp__gte=recent - timedelta(minutes=1)).exists()
+            MeterReading.objects.filter(
+                timestamp__gte=recent - timedelta(minutes=1)
+            ).exists()
         )
         self.assertTrue(Transaction.objects.filter(pk=tx.pk).exists())
 
@@ -1090,19 +2190,21 @@ class PurgeMeterReadingsTaskTests(TestCase):
 class TransactionKwTests(TestCase):
     def test_kw_sums_meter_readings(self):
         charger = Charger.objects.create(charger_id="SUM1")
-        tx = Transaction.objects.create(charger=charger, start_time=timezone.now())
+        tx = Transaction.objects.create(
+            charger=charger, start_time=timezone.now(), meter_start=0
+        )
         MeterReading.objects.create(
             charger=charger,
             transaction=tx,
             timestamp=timezone.now(),
-            value=Decimal("1.0"),
-            unit="kW",
+            value=Decimal("1000"),
+            unit="W",
         )
         MeterReading.objects.create(
             charger=charger,
             transaction=tx,
             timestamp=timezone.now(),
-            value=Decimal("500"),
+            value=Decimal("1500"),
             unit="W",
         )
         self.assertAlmostEqual(tx.kw, 1.5)
@@ -1113,15 +2215,95 @@ class TransactionKwTests(TestCase):
         self.assertEqual(tx.kw, 0.0)
 
 
+class DispatchActionViewTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User = get_user_model()
+        self.user = User.objects.create_user(username="dispatch", password="pw")
+        self.client.force_login(self.user)
+        try:
+            self.previous_loop = asyncio.get_event_loop()
+        except RuntimeError:
+            self.previous_loop = None
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self.loop)
+        self.addCleanup(self._close_loop)
+        self.charger = Charger.objects.create(
+            charger_id="DISPATCH", connector_id=1
+        )
+        self.ws = DummyWebSocket()
+        store.set_connection(
+            self.charger.charger_id, self.charger.connector_id, self.ws
+        )
+        self.addCleanup(
+            store.pop_connection,
+            self.charger.charger_id,
+            self.charger.connector_id,
+        )
+        self.log_key = store.identity_key(
+            self.charger.charger_id, self.charger.connector_id
+        )
+        store.clear_log(self.log_key, log_type="charger")
+        self.addCleanup(store.clear_log, self.log_key, "charger")
+        self.url = reverse(
+            "charger-action-connector",
+            args=[self.charger.charger_id, self.charger.connector_slug],
+        )
+
+    def _close_loop(self):
+        try:
+            if not self.loop.is_closed():
+                self.loop.run_until_complete(asyncio.sleep(0))
+        except RuntimeError:
+            pass
+        finally:
+            if not self.loop.is_closed():
+                self.loop.close()
+            asyncio.set_event_loop(self.previous_loop)
+
+    def test_remote_start_requires_id_tag(self):
+        response = self.client.post(
+            self.url,
+            data=json.dumps({"action": "remote_start"}),
+            content_type="application/json",
+        )
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(response.json().get("detail"), "idTag required")
+        self.loop.run_until_complete(asyncio.sleep(0))
+        self.assertEqual(self.ws.sent, [])
+
+    def test_remote_start_dispatches_frame(self):
+        response = self.client.post(
+            self.url,
+            data=json.dumps({"action": "remote_start", "idTag": "RF1234"}),
+            content_type="application/json",
+        )
+        self.assertEqual(response.status_code, 200)
+        self.loop.run_until_complete(asyncio.sleep(0))
+        self.assertEqual(len(self.ws.sent), 1)
+        frame = json.loads(self.ws.sent[0])
+        self.assertEqual(frame[0], 2)
+        self.assertEqual(frame[2], "RemoteStartTransaction")
+        self.assertEqual(frame[3]["idTag"], "RF1234")
+        self.assertEqual(frame[3]["connectorId"], 1)
+        log_entries = store.logs["charger"].get(self.log_key, [])
+        self.assertTrue(
+            any("RemoteStartTransaction" in entry for entry in log_entries)
+        )
+
+
 class ChargerStatusViewTests(TestCase):
     def setUp(self):
         self.client = Client()
         User = get_user_model()
         self.user = User.objects.create_user(username="status", password="pwd")
         self.client.force_login(self.user)
+
     def test_chart_data_populated_from_existing_readings(self):
-        charger = Charger.objects.create(charger_id="VIEW1")
-        tx = Transaction.objects.create(charger=charger, start_time=timezone.now())
+        charger = Charger.objects.create(charger_id="VIEW1", connector_id=1)
+        tx = Transaction.objects.create(
+            charger=charger, start_time=timezone.now(), meter_start=0
+        )
         t0 = timezone.now()
         MeterReading.objects.create(
             charger=charger,
@@ -1134,17 +2316,109 @@ class ChargerStatusViewTests(TestCase):
             charger=charger,
             transaction=tx,
             timestamp=t0 + timedelta(seconds=10),
-            value=Decimal("500"),
+            value=Decimal("1500"),
             unit="W",
         )
-        store.transactions[charger.charger_id] = tx
-        resp = self.client.get(reverse("charger-status", args=[charger.charger_id]))
+        key = store.identity_key(charger.charger_id, charger.connector_id)
+        store.transactions[key] = tx
+        resp = self.client.get(
+            reverse(
+                "charger-status-connector",
+                args=[charger.charger_id, charger.connector_slug],
+            )
+        )
         self.assertEqual(resp.status_code, 200)
-        chart = json.loads(resp.context["chart_data"])
+        chart = resp.context["chart_data"]
+        self.assertEqual(len(chart["labels"]), 2)
+        self.assertEqual(len(chart["datasets"]), 1)
+        values = chart["datasets"][0]["values"]
+        self.assertEqual(chart["datasets"][0]["connector_id"], 1)
+        self.assertAlmostEqual(values[0], 1.0)
+        self.assertAlmostEqual(values[1], 1.5)
+        store.transactions.pop(key, None)
+
+    def test_chart_data_uses_meter_start_for_register_values(self):
+        charger = Charger.objects.create(charger_id="VIEWREG", connector_id=1)
+        tx = Transaction.objects.create(
+            charger=charger, start_time=timezone.now(), meter_start=746060
+        )
+        t0 = timezone.now()
+        MeterReading.objects.create(
+            charger=charger,
+            transaction=tx,
+            timestamp=t0,
+            measurand="Energy.Active.Import.Register",
+            value=Decimal("746.060"),
+            unit="kWh",
+        )
+        MeterReading.objects.create(
+            charger=charger,
+            transaction=tx,
+            timestamp=t0 + timedelta(seconds=10),
+            measurand="Energy.Active.Import.Register",
+            value=Decimal("746.080"),
+            unit="kWh",
+        )
+        key = store.identity_key(charger.charger_id, charger.connector_id)
+        store.transactions[key] = tx
+        resp = self.client.get(
+            reverse(
+                "charger-status-connector",
+                args=[charger.charger_id, charger.connector_slug],
+            )
+        )
+        chart = resp.context["chart_data"]
         self.assertEqual(len(chart["labels"]), 2)
-        self.assertAlmostEqual(chart["values"][0], 1.0)
-        self.assertAlmostEqual(chart["values"][1], 1.5)
-        store.transactions.pop(charger.charger_id, None)
+        self.assertEqual(len(chart["datasets"]), 1)
+        values = chart["datasets"][0]["values"]
+        self.assertEqual(chart["datasets"][0]["connector_id"], 1)
+        self.assertAlmostEqual(values[0], 0.0)
+        self.assertAlmostEqual(values[1], 0.02)
+        self.assertAlmostEqual(resp.context["tx"].kw, 0.02)
+        store.transactions.pop(key, None)
+
+    def test_diagnostics_status_displayed(self):
+        reported_at = timezone.now().replace(microsecond=0)
+        charger = Charger.objects.create(
+            charger_id="DIAGPAGE",
+            diagnostics_status="Uploaded",
+            diagnostics_location="https://example.com/report.tar",
+            diagnostics_timestamp=reported_at,
+        )
+
+        resp = self.client.get(reverse("charger-status", args=[charger.charger_id]))
+        self.assertEqual(resp.status_code, 200)
+        self.assertContains(resp, "Diagnostics")
+        self.assertContains(resp, "id=\"diagnostics-status\"")
+        self.assertContains(resp, "Uploaded")
+        self.assertContains(resp, "id=\"diagnostics-timestamp\"")
+        self.assertContains(resp, "id=\"diagnostics-location\"")
+        self.assertContains(resp, "https://example.com/report.tar")
+
+    def test_connector_status_prefers_connector_diagnostics(self):
+        aggregate = Charger.objects.create(
+            charger_id="DIAGCONN",
+            diagnostics_status="Uploaded",
+        )
+        connector = Charger.objects.create(
+            charger_id="DIAGCONN",
+            connector_id=1,
+            diagnostics_status="Uploading",
+        )
+
+        aggregate_resp = self.client.get(
+            reverse("charger-status", args=[aggregate.charger_id])
+        )
+        self.assertContains(aggregate_resp, "Uploaded")
+        self.assertNotContains(aggregate_resp, "Uploading")
+
+        connector_resp = self.client.get(
+            reverse(
+                "charger-status-connector",
+                args=[connector.charger_id, connector.connector_slug],
+            )
+        )
+        self.assertContains(connector_resp, "Uploading")
 
     def test_sessions_are_linked(self):
         charger = Charger.objects.create(charger_id="LINK1")
@@ -1157,9 +2431,27 @@ class ChargerStatusViewTests(TestCase):
         resp = self.client.get(reverse("charger-status", args=[charger.charger_id]))
         self.assertContains(resp, reverse("charger-page", args=[charger.charger_id]))
 
+    def test_configuration_link_hidden_for_non_staff(self):
+        charger = Charger.objects.create(charger_id="CFG-HIDE")
+        response = self.client.get(reverse("charger-status", args=[charger.charger_id]))
+        admin_url = reverse("admin:ocpp_charger_change", args=[charger.pk])
+        self.assertNotContains(response, admin_url)
+        self.assertNotContains(response, _("Configuration"))
+
+    def test_configuration_link_visible_for_staff(self):
+        charger = Charger.objects.create(charger_id="CFG-SHOW")
+        self.user.is_staff = True
+        self.user.save(update_fields=["is_staff"])
+        response = self.client.get(reverse("charger-status", args=[charger.charger_id]))
+        admin_url = reverse("admin:ocpp_charger_change", args=[charger.pk])
+        self.assertContains(response, admin_url)
+        self.assertContains(response, _("Configuration"))
+
     def test_past_session_chart(self):
-        charger = Charger.objects.create(charger_id="PAST1")
-        tx = Transaction.objects.create(charger=charger, start_time=timezone.now())
+        charger = Charger.objects.create(charger_id="PAST1", connector_id=1)
+        tx = Transaction.objects.create(
+            charger=charger, start_time=timezone.now(), meter_start=0
+        )
         t0 = timezone.now()
         MeterReading.objects.create(
             charger=charger,
@@ -1172,17 +2464,147 @@ class ChargerStatusViewTests(TestCase):
             charger=charger,
             transaction=tx,
             timestamp=t0 + timedelta(seconds=10),
-            value=Decimal("1000"),
+            value=Decimal("1500"),
             unit="W",
         )
         resp = self.client.get(
-            reverse("charger-status", args=[charger.charger_id]) + f"?session={tx.id}"
+            reverse(
+                "charger-status-connector",
+                args=[charger.charger_id, charger.connector_slug],
+            )
+            + f"?session={tx.id}"
         )
         self.assertContains(resp, "Back to live")
-        chart = json.loads(resp.context["chart_data"])
+        chart = resp.context["chart_data"]
         self.assertEqual(len(chart["labels"]), 2)
+        self.assertEqual(len(chart["datasets"]), 1)
+        self.assertEqual(chart["datasets"][0]["connector_id"], 1)
         self.assertTrue(resp.context["past_session"])
 
+    def test_aggregate_chart_includes_multiple_connectors(self):
+        aggregate = Charger.objects.create(charger_id="VIEWAGG")
+        connector_one = Charger.objects.create(charger_id="VIEWAGG", connector_id=1)
+        connector_two = Charger.objects.create(charger_id="VIEWAGG", connector_id=2)
+        base_time = timezone.now()
+        tx_one = Transaction.objects.create(
+            charger=connector_one, start_time=base_time, meter_start=0
+        )
+        tx_two = Transaction.objects.create(
+            charger=connector_two, start_time=base_time, meter_start=0
+        )
+        MeterReading.objects.create(
+            charger=connector_one,
+            transaction=tx_one,
+            timestamp=base_time,
+            value=Decimal("1000"),
+            unit="W",
+        )
+        MeterReading.objects.create(
+            charger=connector_one,
+            transaction=tx_one,
+            timestamp=base_time + timedelta(seconds=15),
+            value=Decimal("1500"),
+            unit="W",
+        )
+        MeterReading.objects.create(
+            charger=connector_two,
+            transaction=tx_two,
+            timestamp=base_time + timedelta(seconds=5),
+            value=Decimal("2000"),
+            unit="W",
+        )
+        MeterReading.objects.create(
+            charger=connector_two,
+            transaction=tx_two,
+            timestamp=base_time + timedelta(seconds=20),
+            value=Decimal("2600"),
+            unit="W",
+        )
+        key_one = store.identity_key(
+            connector_one.charger_id, connector_one.connector_id
+        )
+        key_two = store.identity_key(
+            connector_two.charger_id, connector_two.connector_id
+        )
+        store.transactions[key_one] = tx_one
+        store.transactions[key_two] = tx_two
+        try:
+            resp = self.client.get(
+                reverse("charger-status", args=[aggregate.charger_id])
+            )
+            chart = resp.context["chart_data"]
+            self.assertTrue(resp.context["show_chart"])
+            self.assertEqual(len(chart["datasets"]), 2)
+            data_map = {
+                dataset["label"]: dataset["values"] for dataset in chart["datasets"]
+            }
+            connector_id_map = {
+                dataset["label"]: dataset.get("connector_id")
+                for dataset in chart["datasets"]
+            }
+            label_one = str(connector_one.connector_label)
+            label_two = str(connector_two.connector_label)
+            self.assertEqual(set(data_map), {label_one, label_two})
+            self.assertEqual(len(data_map[label_one]), len(chart["labels"]))
+            self.assertEqual(len(data_map[label_two]), len(chart["labels"]))
+            self.assertTrue(any(value is not None for value in data_map[label_one]))
+            self.assertTrue(any(value is not None for value in data_map[label_two]))
+            self.assertEqual(connector_id_map[label_one], connector_one.connector_id)
+            self.assertEqual(connector_id_map[label_two], connector_two.connector_id)
+        finally:
+            store.transactions.pop(key_one, None)
+            store.transactions.pop(key_two, None)
+
+
+class ChargerApiDiagnosticsTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User = get_user_model()
+        self.user = User.objects.create_user(username="diagapi", password="pwd")
+        self.client.force_login(self.user)
+
+    def test_detail_includes_diagnostics_fields(self):
+        reported_at = timezone.now().replace(microsecond=0)
+        charger = Charger.objects.create(
+            charger_id="APIDIAG",
+            diagnostics_status="Uploaded",
+            diagnostics_timestamp=reported_at,
+            diagnostics_location="https://example.com/diag.tar",
+        )
+
+        resp = self.client.get(reverse("charger-detail", args=[charger.charger_id]))
+        self.assertEqual(resp.status_code, 200)
+        payload = resp.json()
+        self.assertEqual(payload["diagnosticsStatus"], "Uploaded")
+        self.assertEqual(
+            payload["diagnosticsTimestamp"], reported_at.isoformat()
+        )
+        self.assertEqual(
+            payload["diagnosticsLocation"], "https://example.com/diag.tar"
+        )
+
+    def test_list_includes_diagnostics_fields(self):
+        reported_at = timezone.now().replace(microsecond=0)
+        Charger.objects.create(
+            charger_id="APILIST",
+            diagnostics_status="Idle",
+            diagnostics_timestamp=reported_at,
+            diagnostics_location="s3://bucket/diag.zip",
+        )
+
+        resp = self.client.get(reverse("charger-list"))
+        self.assertEqual(resp.status_code, 200)
+        payload = resp.json()
+        self.assertIn("chargers", payload)
+        target = next(
+            item
+            for item in payload["chargers"]
+            if item["charger_id"] == "APILIST" and item["connector_id"] is None
+        )
+        self.assertEqual(target["diagnosticsStatus"], "Idle")
+        self.assertEqual(target["diagnosticsLocation"], "s3://bucket/diag.zip")
+        self.assertEqual(target["diagnosticsTimestamp"], reported_at.isoformat())
+
 
 class ChargerSessionPaginationTests(TestCase):
     def setUp(self):
@@ -1199,7 +2621,9 @@ class ChargerSessionPaginationTests(TestCase):
             )
 
     def test_only_ten_transactions_shown(self):
-        resp = self.client.get(reverse("charger-status", args=[self.charger.charger_id]))
+        resp = self.client.get(
+            reverse("charger-status", args=[self.charger.charger_id])
+        )
         self.assertEqual(resp.status_code, 200)
         self.assertEqual(len(resp.context["transactions"]), 10)
         self.assertTrue(resp.context["page_obj"].has_next())
@@ -1214,20 +2638,35 @@ class ChargerSessionPaginationTests(TestCase):
         self.assertEqual(len(resp.context["transactions"]), 15)
 
 
-class EfficiencyCalculatorViewTests(TestCase):
+class LiveUpdateViewTests(TestCase):
     def setUp(self):
         User = get_user_model()
-        self.user = User.objects.create_user(
-            username="eff", password="secret", email="eff@example.com"
-        )
+        self.user = User.objects.create_user(username="lu", password="pw")
         self.client.force_login(self.user)
 
-    def test_get_view(self):
-        url = reverse("ev-efficiency")
-        resp = self.client.get(url)
-        self.assertContains(resp, "EV Efficiency Calculator")
+    def test_dashboard_includes_interval(self):
+        resp = self.client.get(reverse("ocpp-dashboard"))
+        self.assertEqual(resp.context["request"].live_update_interval, 5)
+        self.assertContains(resp, "setInterval(() => location.reload()")
+
+    def test_cp_simulator_includes_interval(self):
+        resp = self.client.get(reverse("cp-simulator"))
+        self.assertEqual(resp.context["request"].live_update_interval, 5)
+        self.assertContains(resp, "setInterval(() => location.reload()")
+
+    def test_dashboard_hides_private_chargers(self):
+        public = Charger.objects.create(charger_id="PUBLICCP")
+        private = Charger.objects.create(
+            charger_id="PRIVATECP", public_display=False
+        )
+
+        resp = self.client.get(reverse("ocpp-dashboard"))
+        chargers = [item["charger"] for item in resp.context["chargers"]]
+        self.assertIn(public, chargers)
+        self.assertNotIn(private, chargers)
 
-    def test_post_calculation(self):
-        url = reverse("ev-efficiency")
-        resp = self.client.post(url, {"distance": "100", "energy": "20"})
-        self.assertContains(resp, "5.00")
+        list_response = self.client.get(reverse("charger-list"))
+        payload = list_response.json()
+        ids = [item["charger_id"] for item in payload["chargers"]]
+        self.assertIn(public.charger_id, ids)
+        self.assertNotIn(private.charger_id, ids)