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

ocpp/consumers.py

@@ -5,6 +5,7 @@ from datetime import datetime
 import asyncio
 import inspect
 import json
+import logging
 from urllib.parse import parse_qs
 from django.utils import timezone
 from core.models import EnergyAccount, Reference, RFID as CoreRFID
@@ -32,6 +33,9 @@ from .evcs_discovery import (
 FORWARDED_PAIR_RE = re.compile(r"for=(?:\"?)(?P<value>[^;,\"\s]+)(?:\"?)", re.IGNORECASE)
 
 
+logger = logging.getLogger(__name__)
+
+
 # Query parameter keys that may contain the charge point serial. Keys are
 # matched case-insensitively and trimmed before use.
 SERIAL_QUERY_PARAM_NAMES = (
@@ -309,6 +313,19 @@ class CSMSConsumer(AsyncWebsocketConsumer):
 
         return await database_sync_to_async(_ensure)()
 
+    def _log_unlinked_rfid(self, rfid: str) -> None:
+        """Record a warning when an RFID is authorized without an account."""
+
+        message = (
+            f"Authorized RFID {rfid} on charger {self.charger_id} without linked energy account"
+        )
+        logger.warning(message)
+        store.add_log(
+            store.pending_key(self.charger_id),
+            message,
+            log_type="charger",
+        )
+
     async def _assign_connector(self, connector: int | str | None) -> None:
         """Ensure ``self.charger`` matches the provided connector id."""
         if connector in (None, "", "-"):
@@ -1395,13 +1412,25 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             elif action == "Authorize":
                 id_tag = payload.get("idTag")
                 account = await self._get_account(id_tag)
+                status = "Invalid"
                 if self.charger.require_rfid:
-                    status = (
-                        "Accepted"
-                        if account
-                        and await database_sync_to_async(account.can_authorize)()
-                        else "Invalid"
-                    )
+                    tag = None
+                    tag_created = False
+                    if id_tag:
+                        tag, tag_created = await database_sync_to_async(
+                            CoreRFID.register_scan
+                        )(id_tag)
+                    if account:
+                        if await database_sync_to_async(account.can_authorize)():
+                            status = "Accepted"
+                    elif (
+                        id_tag
+                        and tag
+                        and not tag_created
+                        and tag.allowed
+                    ):
+                        status = "Accepted"
+                        self._log_unlinked_rfid(tag.rfid)
                 else:
                     await self._ensure_rfid_seen(id_tag)
                     status = "Accepted"
@@ -1475,23 +1504,38 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                 reply_payload = {}
             elif action == "StartTransaction":
                 id_tag = payload.get("idTag")
-                account = await self._get_account(id_tag)
+                tag = None
+                tag_created = False
                 if id_tag:
-                    if self.charger.require_rfid:
-                        await database_sync_to_async(CoreRFID.register_scan)(
-                            id_tag.upper()
-                        )
-                    else:
-                        await self._ensure_rfid_seen(id_tag)
+                    tag, tag_created = await database_sync_to_async(
+                        CoreRFID.register_scan
+                    )(id_tag)
+                account = await self._get_account(id_tag)
+                if id_tag and not self.charger.require_rfid:
+                    seen_tag = await self._ensure_rfid_seen(id_tag)
+                    if seen_tag:
+                        tag = seen_tag
                 await self._assign_connector(payload.get("connectorId"))
+                authorized = True
+                authorized_via_tag = False
                 if self.charger.require_rfid:
-                    authorized = (
-                        account is not None
-                        and await database_sync_to_async(account.can_authorize)()
-                    )
-                else:
-                    authorized = True
+                    if account is not None:
+                        authorized = await database_sync_to_async(
+                            account.can_authorize
+                        )()
+                    elif (
+                        id_tag
+                        and tag
+                        and not tag_created
+                        and getattr(tag, "allowed", False)
+                    ):
+                        authorized = True
+                        authorized_via_tag = True
+                    else:
+                        authorized = False
                 if authorized:
+                    if authorized_via_tag and tag:
+                        self._log_unlinked_rfid(tag.rfid)
                     start_timestamp = _parse_ocpp_timestamp(payload.get("timestamp"))
                     received_start = timezone.now()
                     tx_obj = await database_sync_to_async(Transaction.objects.create)(

ocpp/test_rfid.py

@@ -131,7 +131,7 @@ class ScanNextViewTests(TestCase):
         self.assertEqual(
             resp.json(), {"rfid": "ABCD1234", "label_id": 1, "created": False}
         )
-        mock_validate.assert_called_once_with("ABCD1234", kind=None)
+        mock_validate.assert_called_once_with("ABCD1234", kind=None, endianness=None)
 
     @patch("config.middleware.Node.get_local", return_value=None)
     @patch("config.middleware.get_site")
@@ -342,16 +342,20 @@ class ValidateRfidValueTests(SimpleTestCase):
         tag.released = False
         tag.reference = None
         tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.BIG_ENDIAN
         mock_register.return_value = (tag, True)
 
         result = validate_rfid_value("abcd1234")
 
-        mock_register.assert_called_once_with("ABCD1234", kind=None)
+        mock_register.assert_called_once_with(
+            "ABCD1234", kind=None, endianness=RFID.BIG_ENDIAN
+        )
         tag.save.assert_called_once_with(update_fields=["last_seen_on"])
         self.assertIs(tag.last_seen_on, fake_now)
         mock_notify.assert_called_once_with("RFID 1 OK", "ABCD1234 B")
         self.assertTrue(result["created"])
         self.assertEqual(result["rfid"], "ABCD1234")
+        self.assertEqual(result["endianness"], RFID.BIG_ENDIAN)
 
     @patch("ocpp.rfid.reader.timezone.now")
     @patch("ocpp.rfid.reader.notify_async")
@@ -367,11 +371,14 @@ class ValidateRfidValueTests(SimpleTestCase):
         tag.released = True
         tag.reference = None
         tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.BIG_ENDIAN
         mock_register.return_value = (tag, False)
 
         result = validate_rfid_value("abcd", kind=RFID.NTAG215)
 
-        mock_register.assert_called_once_with("ABCD", kind=RFID.NTAG215)
+        mock_register.assert_called_once_with(
+            "ABCD", kind=RFID.NTAG215, endianness=RFID.BIG_ENDIAN
+        )
         tag.save.assert_called_once_with(update_fields=["kind", "last_seen_on"])
         self.assertIs(tag.last_seen_on, fake_now)
         self.assertEqual(tag.kind, RFID.NTAG215)
@@ -379,6 +386,36 @@ class ValidateRfidValueTests(SimpleTestCase):
         self.assertFalse(result["allowed"])
         self.assertFalse(result["created"])
         self.assertEqual(result["kind"], RFID.NTAG215)
+        self.assertEqual(result["endianness"], RFID.BIG_ENDIAN)
+
+    @patch("ocpp.rfid.reader.timezone.now")
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.RFID.register_scan")
+    def test_registers_little_endian_value(
+        self, mock_register, mock_notify, mock_now
+    ):
+        fake_now = object()
+        mock_now.return_value = fake_now
+        tag = MagicMock()
+        tag.pk = 7
+        tag.label_id = 7
+        tag.allowed = True
+        tag.color = "B"
+        tag.released = False
+        tag.reference = None
+        tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.LITTLE_ENDIAN
+        mock_register.return_value = (tag, True)
+
+        result = validate_rfid_value("A1B2C3D4", endianness=RFID.LITTLE_ENDIAN)
+
+        mock_register.assert_called_once_with(
+            "D4C3B2A1", kind=None, endianness=RFID.LITTLE_ENDIAN
+        )
+        tag.save.assert_called_once_with(update_fields=["last_seen_on"])
+        self.assertEqual(result["rfid"], "D4C3B2A1")
+        self.assertEqual(result["endianness"], RFID.LITTLE_ENDIAN)
+        mock_notify.assert_called_once()
 
     def test_rejects_invalid_value(self):
         result = validate_rfid_value("invalid!")
@@ -412,6 +449,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         tag.released = False
         tag.reference = None
         tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.BIG_ENDIAN
         mock_register.return_value = (tag, False)
         mock_run.return_value = types.SimpleNamespace(
             returncode=0, stdout="ok\n", stderr=""
@@ -427,6 +465,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         env = run_kwargs.get("env", {})
         self.assertEqual(env.get("RFID_VALUE"), "ABCD1234")
         self.assertEqual(env.get("RFID_LABEL_ID"), "1")
+        self.assertEqual(env.get("RFID_ENDIANNESS"), RFID.BIG_ENDIAN)
         mock_popen.assert_not_called()
         mock_notify.assert_called_once_with("RFID 1 OK", "ABCD1234 B")
         tag.save.assert_called_once_with(update_fields=["last_seen_on"])
@@ -437,6 +476,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         self.assertEqual(output.get("stderr"), "")
         self.assertEqual(output.get("returncode"), 0)
         self.assertEqual(output.get("error"), "")
+        self.assertEqual(result["endianness"], RFID.BIG_ENDIAN)
 
     @patch("ocpp.rfid.reader.timezone.now")
     @patch("ocpp.rfid.reader.notify_async")
@@ -457,6 +497,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         tag.released = False
         tag.reference = None
         tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.BIG_ENDIAN
         mock_register.return_value = (tag, False)
         mock_run.return_value = types.SimpleNamespace(
             returncode=1, stdout="", stderr="failure"
@@ -476,6 +517,77 @@ class ValidateRfidValueTests(SimpleTestCase):
         self.assertEqual(output.get("stderr"), "failure")
         self.assertEqual(output.get("error"), "")
         mock_popen.assert_not_called()
+        self.assertEqual(result["endianness"], RFID.BIG_ENDIAN)
+
+    @patch("ocpp.rfid.reader.timezone.now")
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.subprocess.Popen")
+    @patch("ocpp.rfid.reader.subprocess.run")
+    @patch("ocpp.rfid.reader.RFID.register_scan")
+    def test_external_command_strips_trailing_percent_tokens(
+        self, mock_register, mock_run, mock_popen, mock_notify, mock_now
+    ):
+        mock_now.return_value = timezone.now()
+        tag = MagicMock()
+        tag.pk = 3
+        tag.label_id = 3
+        tag.allowed = True
+        tag.external_command = "echo weird"
+        tag.color = "Y"
+        tag.released = False
+        tag.reference = None
+        tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.BIG_ENDIAN
+        mock_register.return_value = (tag, False)
+        mock_run.return_value = types.SimpleNamespace(
+            returncode=0,
+            stdout="first %\nsecond 50%\r\nthird % %\n",
+            stderr="oops %\n",
+        )
+
+        result = validate_rfid_value("abc3")
+
+        output = result.get("command_output")
+        self.assertIsNotNone(output)
+        self.assertEqual(
+            output.get("stdout"), "first\nsecond 50%\r\nthird\n"
+        )
+        self.assertEqual(output.get("stderr"), "oops\n")
+        self.assertEqual(output.get("returncode"), 0)
+        self.assertEqual(output.get("error"), "")
+        mock_popen.assert_not_called()
+
+    @patch("ocpp.rfid.reader.timezone.now")
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.subprocess.Popen")
+    @patch("ocpp.rfid.reader.subprocess.run")
+    @patch("ocpp.rfid.reader.RFID.register_scan")
+    def test_external_command_error_strips_trailing_percent_tokens(
+        self, mock_register, mock_run, mock_popen, mock_notify, mock_now
+    ):
+        mock_now.return_value = timezone.now()
+        tag = MagicMock()
+        tag.pk = 4
+        tag.label_id = 4
+        tag.allowed = True
+        tag.external_command = "echo boom"
+        tag.color = "R"
+        tag.released = False
+        tag.reference = None
+        tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.BIG_ENDIAN
+        mock_register.return_value = (tag, False)
+        mock_run.side_effect = RuntimeError("bad % %")
+
+        result = validate_rfid_value("abcd")
+
+        output = result.get("command_output")
+        self.assertIsInstance(output, dict)
+        self.assertEqual(output.get("stdout"), "")
+        self.assertEqual(output.get("stderr"), "")
+        self.assertEqual(output.get("error"), "bad")
+        self.assertFalse(result["allowed"])
+        mock_popen.assert_not_called()
 
     @patch("ocpp.rfid.reader.timezone.now")
     @patch("ocpp.rfid.reader.notify_async")
@@ -497,6 +609,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         tag.released = False
         tag.reference = None
         tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.BIG_ENDIAN
         mock_register.return_value = (tag, False)
         result = validate_rfid_value("abcdef")
 
@@ -507,10 +620,12 @@ class ValidateRfidValueTests(SimpleTestCase):
         env = kwargs.get("env", {})
         self.assertEqual(env.get("RFID_VALUE"), "ABCDEF")
         self.assertEqual(env.get("RFID_LABEL_ID"), "3")
+        self.assertEqual(env.get("RFID_ENDIANNESS"), RFID.BIG_ENDIAN)
         self.assertIs(kwargs.get("stdout"), subprocess.DEVNULL)
         self.assertIs(kwargs.get("stderr"), subprocess.DEVNULL)
         self.assertTrue(result["allowed"])
         mock_notify.assert_called_once_with("RFID 3 OK", "ABCDEF B")
+        self.assertEqual(result["endianness"], RFID.BIG_ENDIAN)
 
 
 class CardTypeDetectionTests(TestCase):

ocpp/tests.py

@@ -1931,6 +1931,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(
@@ -2129,6 +2150,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 +2202,48 @@ 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_admin_log_view_displays_entries(self):
         charger = Charger.objects.create(charger_id="LOG2")
         log_id = store.identity_key(charger.charger_id, charger.connector_id)
@@ -2860,6 +2949,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 +3079,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()
@@ -4442,6 +4624,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"

ocpp/views.py

@@ -370,10 +370,6 @@ def _aggregate_dashboard_state(charger: Charger) -> tuple[str, str] | None:
     )
     statuses: list[str] = []
     for sibling in siblings:
-        status_value = (sibling.last_status or "").strip()
-        if status_value:
-            statuses.append(status_value.casefold())
-            continue
         tx_obj = store.get_transaction(sibling.charger_id, sibling.connector_id)
         if not tx_obj:
             tx_obj = (
@@ -381,9 +377,22 @@ def _aggregate_dashboard_state(charger: Charger) -> tuple[str, str] | None:
                 .order_by("-start_time")
                 .first()
             )
-        if _has_active_session(tx_obj):
+        has_session = _has_active_session(tx_obj)
+        status_value = (sibling.last_status or "").strip()
+        normalized_status = status_value.casefold() if status_value else ""
+        error_code_lower = (sibling.last_error_code or "").strip().lower()
+        if has_session:
             statuses.append("charging")
             continue
+        if (
+            normalized_status in {"charging", "finishing"}
+            and error_code_lower in ERROR_OK_VALUES
+        ):
+            statuses.append("available")
+            continue
+        if normalized_status:
+            statuses.append(normalized_status)
+            continue
         if store.is_connected(sibling.charger_id, sibling.connector_id):
             statuses.append("available")
 
@@ -424,6 +433,15 @@ def _charger_state(charger: Charger, tx_obj: Transaction | list | None):
             # while a session is active. Override the badge so the user can see
             # the charger is actually busy.
             label, color = STATUS_BADGE_MAP.get("charging", (_("Charging"), "#198754"))
+        elif (
+            not has_session
+            and key in {"charging", "finishing"}
+            and error_code_lower in ERROR_OK_VALUES
+        ):
+            # Some chargers continue reporting "Charging" after a session ends.
+            # When no active transaction exists, surface the state as available
+            # so the UI reflects the actual behaviour at the site.
+            label, color = STATUS_BADGE_MAP.get("available", (_("Available"), "#0d6efd"))
         elif error_code and error_code_lower not in ERROR_OK_VALUES:
             label = _("%(status)s (%(error)s)") % {
                 "status": label,
@@ -1191,17 +1209,38 @@ def charger_log_page(request, cid, connector=None):
             charger_id=cid
         )
         target_id = cid
-    log = store.get_logs(target_id, log_type=log_type)
+    limit_options = [
+        {"value": "10", "label": "10"},
+        {"value": "20", "label": "20"},
+        {"value": "40", "label": "40"},
+        {"value": "100", "label": "100"},
+        {"value": "all", "label": gettext("All")},
+    ]
+    allowed_values = [item["value"] for item in limit_options]
+    limit_choice = request.GET.get("limit", "20")
+    if limit_choice not in allowed_values:
+        limit_choice = "20"
+
+    log_entries = list(store.get_logs(target_id, log_type=log_type) or [])
+    if limit_choice != "all":
+        try:
+            limit_value = int(limit_choice)
+        except (TypeError, ValueError):
+            limit_value = 20
+            limit_choice = "20"
+        log_entries = log_entries[-limit_value:]
     return render(
         request,
         "ocpp/charger_logs.html",
         {
             "charger": charger,
-            "log": log,
+            "log": log_entries,
             "log_type": log_type,
             "connector_slug": connector_slug,
             "connector_links": connector_links,
             "status_url": status_url,
+            "log_limit_options": limit_options,
+            "log_limit_index": allowed_values.index(limit_choice),
         },
     )