arthexis 0.1.15__py3-none-any.whl → 0.1.17__py3-none-any.whl

ocpp/tasks.py

@@ -1,11 +1,17 @@
 import logging
-from datetime import timedelta
+from datetime import date, datetime, time, timedelta
+from pathlib import Path
 
 from celery import shared_task
+from django.conf import settings
+from django.contrib.auth import get_user_model
 from django.utils import timezone
 from django.db.models import Q
 
-from .models import MeterValue
+from core import mailer
+from nodes.models import Node
+
+from .models import MeterValue, Transaction
 
 logger = logging.getLogger(__name__)
 
@@ -29,3 +35,151 @@ def purge_meter_values() -> int:
 
 # Backwards compatibility alias
 purge_meter_readings = purge_meter_values
+
+
+def _resolve_report_window() -> tuple[datetime, datetime, date]:
+    """Return the start/end datetimes for today's reporting window."""
+
+    current_tz = timezone.get_current_timezone()
+    today = timezone.localdate()
+    start = timezone.make_aware(datetime.combine(today, time.min), current_tz)
+    end = start + timedelta(days=1)
+    return start, end, today
+
+
+def _session_report_recipients() -> list[str]:
+    """Return the list of recipients for the daily session report."""
+
+    User = get_user_model()
+    recipients = list(
+        User.objects.filter(is_superuser=True)
+        .exclude(email="")
+        .values_list("email", flat=True)
+    )
+    if recipients:
+        return recipients
+
+    fallback = getattr(settings, "DEFAULT_FROM_EMAIL", "").strip()
+    return [fallback] if fallback else []
+
+
+def _format_duration(delta: timedelta | None) -> str:
+    """Return a compact string for ``delta`` or ``"in progress"``."""
+
+    if delta is None:
+        return "in progress"
+    total_seconds = int(delta.total_seconds())
+    hours, remainder = divmod(total_seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    parts: list[str] = []
+    if hours:
+        parts.append(f"{hours}h")
+    if minutes:
+        parts.append(f"{minutes}m")
+    if seconds or not parts:
+        parts.append(f"{seconds}s")
+    return " ".join(parts)
+
+
+def _format_charger(transaction: Transaction) -> str:
+    """Return a human friendly label for ``transaction``'s charger."""
+
+    charger = transaction.charger
+    if charger is None:
+        return "Unknown charger"
+    for attr in ("display_name", "name", "charger_id"):
+        value = getattr(charger, attr, "")
+        if value:
+            return str(value)
+    return str(charger)
+
+
+@shared_task
+def send_daily_session_report() -> int:
+    """Send a summary of today's OCPP sessions when email is available."""
+
+    if not mailer.can_send_email():
+        logger.info("Skipping OCPP session report: email not configured")
+        return 0
+
+    celery_lock = Path(settings.BASE_DIR) / "locks" / "celery.lck"
+    if not celery_lock.exists():
+        logger.info("Skipping OCPP session report: celery feature disabled")
+        return 0
+
+    recipients = _session_report_recipients()
+    if not recipients:
+        logger.info("Skipping OCPP session report: no recipients found")
+        return 0
+
+    start, end, today = _resolve_report_window()
+    transactions = list(
+        Transaction.objects.filter(start_time__gte=start, start_time__lt=end)
+        .select_related("charger", "account")
+        .order_by("start_time")
+    )
+    if not transactions:
+        logger.info("No OCPP sessions recorded on %s", today.isoformat())
+        return 0
+
+    total_energy = sum(transaction.kw for transaction in transactions)
+    lines = [
+        f"OCPP session report for {today.isoformat()}",
+        "",
+        f"Total sessions: {len(transactions)}",
+        f"Total energy: {total_energy:.2f} kWh",
+        "",
+    ]
+
+    for index, transaction in enumerate(transactions, start=1):
+        start_local = timezone.localtime(transaction.start_time)
+        stop_local = (
+            timezone.localtime(transaction.stop_time)
+            if transaction.stop_time
+            else None
+        )
+        duration = _format_duration(
+            stop_local - start_local if stop_local else None
+        )
+        account = transaction.account.name if transaction.account else "N/A"
+        connector = (
+            f"Connector {transaction.connector_id}" if transaction.connector_id else None
+        )
+        lines.append(f"{index}. {_format_charger(transaction)}")
+        lines.append(f"   Account: {account}")
+        if transaction.rfid:
+            lines.append(f"   RFID: {transaction.rfid}")
+        if connector:
+            lines.append(f"   {connector}")
+        lines.append(
+            "   Start: "
+            f"{start_local.strftime('%H:%M:%S %Z')}"
+        )
+        if stop_local:
+            lines.append(
+                "   Stop: "
+                f"{stop_local.strftime('%H:%M:%S %Z')} ({duration})"
+            )
+        else:
+            lines.append("   Stop: in progress")
+        lines.append(f"   Energy: {transaction.kw:.2f} kWh")
+        lines.append("")
+
+    subject = f"OCPP session report for {today.isoformat()}"
+    body = "\n".join(lines).strip()
+
+    node = Node.get_local()
+    if node is not None:
+        node.send_mail(subject, body, recipients)
+    else:
+        mailer.send(
+            subject,
+            body,
+            recipients,
+            getattr(settings, "DEFAULT_FROM_EMAIL", None),
+        )
+
+    logger.info(
+        "Sent OCPP session report for %s to %s", today.isoformat(), ", ".join(recipients)
+    )
+    return len(transactions)

ocpp/test_rfid.py

@@ -1,6 +1,7 @@
 import io
 import json
 import os
+import subprocess
 import sys
 import types
 from datetime import datetime, timezone as dt_timezone
@@ -130,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")
@@ -341,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")
@@ -366,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)
@@ -378,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!")
@@ -394,10 +432,11 @@ class ValidateRfidValueTests(SimpleTestCase):
 
     @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_success(
-        self, mock_register, mock_run, mock_notify, mock_now
+        self, mock_register, mock_run, mock_popen, mock_notify, mock_now
     ):
         fake_now = object()
         mock_now.return_value = fake_now
@@ -410,10 +449,12 @@ 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=""
         )
+        mock_popen.return_value = object()
 
         result = validate_rfid_value("abcd1234")
 
@@ -424,6 +465,8 @@ 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"])
         self.assertTrue(result["allowed"])
@@ -433,13 +476,15 @@ 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")
+    @patch("ocpp.rfid.reader.subprocess.Popen")
     @patch("ocpp.rfid.reader.subprocess.run")
     @patch("ocpp.rfid.reader.RFID.register_scan")
     def test_external_command_failure_blocks_tag(
-        self, mock_register, mock_run, mock_notify, mock_now
+        self, mock_register, mock_run, mock_popen, mock_notify, mock_now
     ):
         fake_now = object()
         mock_now.return_value = fake_now
@@ -452,10 +497,12 @@ 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"
         )
+        mock_popen.return_value = object()
 
         result = validate_rfid_value("ffff")
 
@@ -469,6 +516,46 @@ class ValidateRfidValueTests(SimpleTestCase):
         self.assertEqual(output.get("stdout"), "")
         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_post_command_runs_after_success(
+        self, mock_register, mock_run, mock_popen, mock_notify, mock_now
+    ):
+        fake_now = object()
+        mock_now.return_value = fake_now
+        tag = MagicMock()
+        tag.pk = 3
+        tag.label_id = 3
+        tag.allowed = True
+        tag.external_command = ""
+        tag.post_auth_command = "echo done"
+        tag.color = "B"
+        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")
+
+        mock_run.assert_not_called()
+        mock_popen.assert_called_once()
+        args, kwargs = mock_popen.call_args
+        self.assertEqual(args[0], "echo done")
+        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

@@ -40,6 +40,7 @@ from django.test import (
     TestCase,
     override_settings,
 )
+from django.conf import settings
 from unittest import skip
 from contextlib import suppress
 from types import SimpleNamespace
@@ -79,7 +80,7 @@ from .simulator import SimulatorConfig, ChargePointSimulator
 from .evcs import simulate, SimulatorState, _simulators
 import re
 from datetime import datetime, timedelta, timezone as dt_timezone
-from .tasks import purge_meter_readings
+from .tasks import purge_meter_readings, send_daily_session_report
 from django.db import close_old_connections
 from django.db.utils import OperationalError
 from urllib.parse import unquote, urlparse
@@ -1930,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(
@@ -2128,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")
@@ -2154,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)
@@ -2981,6 +3071,46 @@ class SimulatorAdminTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    async def test_heartbeat_refreshes_aggregate_after_connector_status(self):
+        store.ip_connections.clear()
+        store.connections.clear()
+        await database_sync_to_async(Charger.objects.create)(charger_id="HBAGG")
+        communicator = WebsocketCommunicator(application, "/HBAGG/")
+        connect_result = await communicator.connect()
+        self.assertTrue(connect_result[0], connect_result)
+
+        status_payload = {
+            "connectorId": 2,
+            "status": "Faulted",
+            "errorCode": "ReaderFailure",
+        }
+        await communicator.send_json_to(
+            [2, "1", "StatusNotification", status_payload]
+        )
+        await communicator.receive_json_from()
+
+        aggregate = await database_sync_to_async(Charger.objects.get)(
+            charger_id="HBAGG", connector_id=None
+        )
+        connector = await database_sync_to_async(Charger.objects.get)(
+            charger_id="HBAGG", connector_id=2
+        )
+        previous_heartbeat = aggregate.last_heartbeat
+
+        await communicator.send_json_to([2, "2", "Heartbeat", {}])
+        await communicator.receive_json_from()
+
+        await database_sync_to_async(aggregate.refresh_from_db)()
+        await database_sync_to_async(connector.refresh_from_db)()
+
+        self.assertIsNotNone(aggregate.last_heartbeat)
+        if previous_heartbeat:
+            self.assertNotEqual(aggregate.last_heartbeat, previous_heartbeat)
+        if connector.last_heartbeat:
+            self.assertNotEqual(aggregate.last_heartbeat, connector.last_heartbeat)
+
+        await communicator.disconnect()
+
 
 class ChargerLocationTests(TestCase):
     def test_lat_lon_fields_saved(self):
@@ -3676,6 +3806,75 @@ class PurgeMeterReadingsTaskTests(TestCase):
         self.assertTrue(MeterReading.objects.filter(pk=reading.pk).exists())
 
 
+class DailySessionReportTaskTests(TestCase):
+    def setUp(self):
+        super().setUp()
+        self.locks_dir = Path(settings.BASE_DIR) / "locks"
+        self.locks_dir.mkdir(parents=True, exist_ok=True)
+        self.celery_lock = self.locks_dir / "celery.lck"
+        self.celery_lock.write_text("")
+        self.addCleanup(self._cleanup_lock)
+
+    def _cleanup_lock(self):
+        try:
+            self.celery_lock.unlink()
+        except FileNotFoundError:
+            pass
+
+    def test_report_sends_email_when_sessions_exist(self):
+        User = get_user_model()
+        User.objects.create_superuser(
+            username="report-admin",
+            email="report-admin@example.com",
+            password="pw",
+        )
+        charger = Charger.objects.create(charger_id="RPT1", display_name="Pod 1")
+        start = timezone.now().replace(hour=10, minute=0, second=0, microsecond=0)
+        Transaction.objects.create(
+            charger=charger,
+            start_time=start,
+            stop_time=start + timedelta(hours=1),
+            meter_start=0,
+            meter_stop=2500,
+            connector_id=2,
+            rfid="AA11",
+        )
+
+        with patch("core.mailer.can_send_email", return_value=True), patch(
+            "core.mailer.send"
+        ) as mock_send:
+            count = send_daily_session_report()
+
+        self.assertEqual(count, 1)
+        self.assertTrue(mock_send.called)
+        args, _kwargs = mock_send.call_args
+        self.assertIn("OCPP session report", args[0])
+        self.assertIn("Pod 1", args[1])
+        self.assertIn("report-admin@example.com", args[2])
+        self.assertGreaterEqual(len(args[2]), 1)
+
+    def test_report_skips_when_no_sessions(self):
+        with patch("core.mailer.can_send_email", return_value=True), patch(
+            "core.mailer.send"
+        ) as mock_send:
+            count = send_daily_session_report()
+
+        self.assertEqual(count, 0)
+        mock_send.assert_not_called()
+
+    def test_report_skips_without_celery_feature(self):
+        if self.celery_lock.exists():
+            self.celery_lock.unlink()
+
+        with patch("core.mailer.can_send_email", return_value=True), patch(
+            "core.mailer.send"
+        ) as mock_send:
+            count = send_daily_session_report()
+
+        self.assertEqual(count, 0)
+        mock_send.assert_not_called()
+
+
 class TransactionKwTests(TestCase):
     def test_kw_sums_meter_readings(self):
         charger = Charger.objects.create(charger_id="SUM1")
@@ -4332,6 +4531,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"