arthexis 0.1.20__py3-none-any.whl → 0.1.22__py3-none-any.whl

ocpp/tasks.py

@@ -1,7 +1,10 @@
+import json
 import logging
+import uuid
 from datetime import date, datetime, time, timedelta
 from pathlib import Path
 
+from asgiref.sync import async_to_sync
 from celery import shared_task
 from django.conf import settings
 from django.contrib.auth import get_user_model
@@ -11,11 +14,106 @@ from django.db.models import Q
 from core import mailer
 from nodes.models import Node
 
-from .models import MeterValue, Transaction
+from . import store
+from .models import Charger, MeterValue, Transaction
 
 logger = logging.getLogger(__name__)
 
 
+@shared_task
+def check_charge_point_configuration(charger_pk: int) -> bool:
+    """Request the latest configuration from a connected charge point."""
+
+    try:
+        charger = Charger.objects.get(pk=charger_pk)
+    except Charger.DoesNotExist:
+        logger.warning(
+            "Unable to request configuration for missing charger %s",
+            charger_pk,
+        )
+        return False
+
+    connector_value = charger.connector_id
+    if connector_value is not None:
+        logger.debug(
+            "Skipping charger %s: connector %s is not eligible for automatic configuration checks",
+            charger.charger_id,
+            connector_value,
+        )
+        return False
+
+    ws = store.get_connection(charger.charger_id, connector_value)
+    if ws is None:
+        logger.info(
+            "Charge point %s is not connected; configuration request skipped",
+            charger.charger_id,
+        )
+        return False
+
+    message_id = uuid.uuid4().hex
+    payload: dict[str, object] = {}
+    msg = json.dumps([2, message_id, "GetConfiguration", payload])
+
+    try:
+        async_to_sync(ws.send)(msg)
+    except Exception as exc:  # pragma: no cover - network error
+        logger.warning(
+            "Failed to send GetConfiguration to %s (%s)",
+            charger.charger_id,
+            exc,
+        )
+        return False
+
+    log_key = store.identity_key(charger.charger_id, connector_value)
+    store.add_log(log_key, f"< {msg}", log_type="charger")
+    store.register_pending_call(
+        message_id,
+        {
+            "action": "GetConfiguration",
+            "charger_id": charger.charger_id,
+            "connector_id": connector_value,
+            "log_key": log_key,
+            "requested_at": timezone.now(),
+        },
+    )
+    store.schedule_call_timeout(
+        message_id,
+        timeout=5.0,
+        action="GetConfiguration",
+        log_key=log_key,
+        message=(
+            "GetConfiguration timed out: charger did not respond"
+            " (operation may not be supported)"
+        ),
+    )
+    logger.info(
+        "Requested configuration from charge point %s",
+        charger.charger_id,
+    )
+    return True
+
+
+@shared_task
+def schedule_daily_charge_point_configuration_checks() -> int:
+    """Dispatch configuration requests for eligible charge points."""
+
+    charger_ids = list(
+        Charger.objects.filter(connector_id__isnull=True).values_list("pk", flat=True)
+    )
+    if not charger_ids:
+        logger.debug("No eligible charge points available for configuration check")
+        return 0
+
+    scheduled = 0
+    for charger_pk in charger_ids:
+        check_charge_point_configuration.delay(charger_pk)
+        scheduled += 1
+    logger.info(
+        "Scheduled configuration checks for %s charge point(s)", scheduled
+    )
+    return scheduled
+
+
 @shared_task
 def purge_meter_values() -> int:
     """Delete meter values older than 7 days.

ocpp/tests.py

@@ -55,6 +55,7 @@ from django.contrib.sites.models import Site
 from django.core.exceptions import ValidationError
 from pages.models import Application, Module
 from nodes.models import Node, NodeRole
+from django.contrib.admin.sites import AdminSite
 
 from config.asgi import application
 
@@ -67,8 +68,9 @@ from .models import (
     Location,
     DataTransferMessage,
 )
+from .admin import ChargerConfigurationAdmin
 from .consumers import CSMSConsumer
-from .views import dispatch_action, _transaction_rfid_details
+from .views import dispatch_action, _transaction_rfid_details, _usage_timeline
 from .status_display import STATUS_BADGE_MAP
 from core.models import EnergyAccount, EnergyCredit, Reference, RFID, SecurityGroup
 from . import store
@@ -81,7 +83,12 @@ from .simulator import SimulatorConfig, ChargePointSimulator
 from .evcs import simulate, SimulatorState, _simulators
 import re
 from datetime import datetime, timedelta, timezone as dt_timezone
-from .tasks import purge_meter_readings, send_daily_session_report
+from .tasks import (
+    purge_meter_readings,
+    send_daily_session_report,
+    check_charge_point_configuration,
+    schedule_daily_charge_point_configuration_checks,
+)
 from django.db import close_old_connections
 from django.db.utils import OperationalError
 from urllib.parse import unquote, urlparse
@@ -757,6 +764,7 @@ class CSMSConsumerTests(TransactionTestCase):
         )()
         self.assertIsNotNone(configuration)
         self.assertEqual(configuration.charger_identifier, "CFGRES")
+        self.assertIsNotNone(configuration.evcs_snapshot_at)
         self.assertEqual(
             configuration.configuration_keys,
             [
@@ -2335,6 +2343,36 @@ class ChargerAdminTests(TestCase):
         resp = self.client.get(url)
         self.assertContains(resp, "AdminLoc")
 
+    def test_admin_changelist_displays_quick_stats(self):
+        charger = Charger.objects.create(charger_id="STATMAIN", display_name="Main EVCS")
+        connector = Charger.objects.create(
+            charger_id="STATMAIN", connector_id=1, display_name="Connector 1"
+        )
+        start = timezone.now() - timedelta(minutes=30)
+        Transaction.objects.create(
+            charger=connector,
+            start_time=start,
+            stop_time=start + timedelta(minutes=10),
+            meter_start=1000,
+            meter_stop=6000,
+        )
+
+        url = reverse("admin:ocpp_charger_changelist")
+        resp = self.client.get(url)
+
+        self.assertContains(resp, "Total kW")
+        self.assertContains(resp, "Today kW")
+        self.assertContains(resp, "5.00")
+
+    def test_admin_changelist_does_not_indent_connectors(self):
+        Charger.objects.create(charger_id="INDENTMAIN")
+        Charger.objects.create(charger_id="INDENTMAIN", connector_id=1)
+
+        url = reverse("admin:ocpp_charger_changelist")
+        resp = self.client.get(url)
+
+        self.assertNotContains(resp, 'class="charger-connector-entry"')
+
     def test_last_fields_are_read_only(self):
         now = timezone.now()
         charger = Charger.objects.create(
@@ -2584,6 +2622,81 @@ class ChargerAdminTests(TestCase):
             store.clear_log(pending_key, log_type="charger")
 
 
+class ChargerConfigurationAdminUnitTests(TestCase):
+    def setUp(self):
+        self.admin = ChargerConfigurationAdmin(ChargerConfiguration, AdminSite())
+        self.request_factory = RequestFactory()
+
+    def test_origin_display_returns_evcs_when_snapshot_present(self):
+        configuration = ChargerConfiguration.objects.create(
+            charger_identifier="CFG-EVCS",
+            evcs_snapshot_at=timezone.now(),
+        )
+        self.assertEqual(self.admin.origin_display(configuration), "EVCS")
+
+    def test_origin_display_returns_local_without_snapshot(self):
+        configuration = ChargerConfiguration.objects.create(
+            charger_identifier="CFG-LOCAL",
+        )
+        self.assertEqual(self.admin.origin_display(configuration), "Local")
+
+    def test_save_model_resets_snapshot_timestamp(self):
+        configuration = ChargerConfiguration.objects.create(
+            charger_identifier="CFG-SAVE",
+            evcs_snapshot_at=timezone.now(),
+        )
+        request = self.request_factory.post("/admin/ocpp/chargerconfiguration/")
+        self.admin.save_model(request, configuration, form=None, change=True)
+        configuration.refresh_from_db()
+        self.assertIsNone(configuration.evcs_snapshot_at)
+
+
+class ConfigurationTaskTests(TestCase):
+    def tearDown(self):
+        store.pending_calls.clear()
+
+    def test_check_charge_point_configuration_dispatches_request(self):
+        charger = Charger.objects.create(charger_id="TASKCFG")
+        ws = DummyWebSocket()
+        log_key = store.identity_key(charger.charger_id, charger.connector_id)
+        pending_key = store.pending_key(charger.charger_id)
+        store.clear_log(log_key, log_type="charger")
+        store.clear_log(pending_key, log_type="charger")
+        store.set_connection(charger.charger_id, charger.connector_id, ws)
+        try:
+            result = check_charge_point_configuration.run(charger.pk)
+            self.assertTrue(result)
+            self.assertEqual(len(ws.sent), 1)
+            frame = json.loads(ws.sent[0])
+            self.assertEqual(frame[0], 2)
+            self.assertEqual(frame[2], "GetConfiguration")
+            self.assertIn(frame[1], store.pending_calls)
+        finally:
+            store.pop_connection(charger.charger_id, charger.connector_id)
+            store.pending_calls.clear()
+            store.clear_log(log_key, log_type="charger")
+            store.clear_log(pending_key, log_type="charger")
+
+    def test_check_charge_point_configuration_without_connection(self):
+        charger = Charger.objects.create(charger_id="TASKNOCONN")
+        result = check_charge_point_configuration.run(charger.pk)
+        self.assertFalse(result)
+
+    def test_schedule_daily_checks_only_includes_root_chargers(self):
+        eligible = Charger.objects.create(charger_id="TASKROOT")
+        Charger.objects.create(charger_id="TASKCONN", connector_id=1)
+        with patch("ocpp.tasks.check_charge_point_configuration.delay") as mock_delay:
+            scheduled = schedule_daily_charge_point_configuration_checks.run()
+        self.assertEqual(scheduled, 1)
+        mock_delay.assert_called_once_with(eligible.pk)
+
+    def test_schedule_daily_checks_returns_zero_without_chargers(self):
+        with patch("ocpp.tasks.check_charge_point_configuration.delay") as mock_delay:
+            scheduled = schedule_daily_charge_point_configuration_checks.run()
+        self.assertEqual(scheduled, 0)
+        mock_delay.assert_not_called()
+
+
 class LocationAdminTests(TestCase):
     def setUp(self):
         self.client = Client()
@@ -2857,6 +2970,28 @@ class SimulatorAdminTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    def test_auto_registered_charger_location_name_sanitized(self):
+        async def exercise():
+            communicator = WebsocketCommunicator(
+                application, "/?cid=ACME%20Charger%20%231"
+            )
+            connected, _ = await communicator.connect()
+            self.assertTrue(connected)
+
+            await communicator.disconnect()
+
+            def fetch_location_name() -> str:
+                charger = (
+                    Charger.objects.select_related("location")
+                    .get(charger_id="ACME Charger #1")
+                )
+                return charger.location.name
+
+            location_name = await database_sync_to_async(fetch_location_name)()
+            self.assertEqual(location_name, "ACME_Charger_1")
+
+        async_to_sync(exercise)()
+
     async def test_query_string_cid_supported(self):
         communicator = WebsocketCommunicator(application, "/?cid=QSERIAL")
         connected, _ = await communicator.connect()
@@ -3294,6 +3429,10 @@ class ChargerLocationTests(TestCase):
         second = Charger.objects.create(charger_id="SHARE", connector_id=2)
         self.assertEqual(second.location, first.location)
 
+    def test_location_name_sanitized_when_auto_created(self):
+        charger = Charger.objects.create(charger_id="Name With spaces!#1")
+        self.assertEqual(charger.location.name, "Name_With_spaces_1")
+
 
 class MeterReadingTests(TransactionTestCase):
     async def test_meter_values_saved_as_readings(self):
@@ -4398,6 +4537,122 @@ class ChargerStatusViewTests(TestCase):
         self.assertAlmostEqual(resp.context["tx"].kw, 0.02)
         store.transactions.pop(key, None)
 
+    def test_usage_timeline_rendered_when_chart_unavailable(self):
+        original_logs = store.logs["charger"]
+        store.logs["charger"] = {}
+        self.addCleanup(lambda: store.logs.__setitem__("charger", original_logs))
+        fixed_now = timezone.now().replace(microsecond=0)
+        charger = Charger.objects.create(charger_id="TL1", connector_id=1)
+        log_key = store.identity_key(charger.charger_id, charger.connector_id)
+
+        def build_entry(delta, status):
+            timestamp = fixed_now - delta
+            payload = {
+                "connectorId": 1,
+                "status": status,
+                "timestamp": timestamp.isoformat(),
+            }
+            prefix = (timestamp.strftime("%Y-%m-%d %H:%M:%S.%f"))[:-3]
+            return f"{prefix} StatusNotification processed: {json.dumps(payload, sort_keys=True)}"
+
+        store.logs["charger"][log_key] = [
+            build_entry(timedelta(days=2), "Available"),
+            build_entry(timedelta(days=1), "Charging"),
+            build_entry(timedelta(hours=12), "Available"),
+        ]
+
+        data, _window = _usage_timeline(charger, [], now=fixed_now)
+        self.assertEqual(len(data), 1)
+        statuses = {segment["status"] for segment in data[0]["segments"]}
+        self.assertIn("charging", statuses)
+        self.assertIn("available", statuses)
+
+        with patch("ocpp.views.timezone.now", return_value=fixed_now):
+            resp = self.client.get(
+                reverse(
+                    "charger-status-connector",
+                    args=[charger.charger_id, charger.connector_slug],
+                )
+            )
+
+        self.assertContains(resp, "Usage (last 7 days)")
+        self.assertContains(resp, "usage-timeline-segment usage-charging")
+
+    def test_usage_timeline_includes_multiple_connectors(self):
+        original_logs = store.logs["charger"]
+        store.logs["charger"] = {}
+        self.addCleanup(lambda: store.logs.__setitem__("charger", original_logs))
+        fixed_now = timezone.now().replace(microsecond=0)
+        aggregate = Charger.objects.create(charger_id="TLAGG")
+        connector_one = Charger.objects.create(charger_id="TLAGG", connector_id=1)
+        connector_two = Charger.objects.create(charger_id="TLAGG", connector_id=2)
+
+        def build_entry(connector_id, delta, status):
+            timestamp = fixed_now - delta
+            payload = {
+                "connectorId": connector_id,
+                "status": status,
+                "timestamp": timestamp.isoformat(),
+            }
+            prefix = (timestamp.strftime("%Y-%m-%d %H:%M:%S.%f"))[:-3]
+            key = store.identity_key(aggregate.charger_id, connector_id)
+            store.logs["charger"].setdefault(key, []).append(
+                f"{prefix} StatusNotification processed: {json.dumps(payload, sort_keys=True)}"
+            )
+
+        build_entry(1, timedelta(days=3), "Available")
+        build_entry(2, timedelta(days=2), "Charging")
+
+        overview = [{"charger": connector_one}, {"charger": connector_two}]
+        data, _window = _usage_timeline(aggregate, overview, now=fixed_now)
+        self.assertEqual(len(data), 2)
+        self.assertTrue(all(entry["segments"] for entry in data))
+
+        with patch("ocpp.views.timezone.now", return_value=fixed_now):
+            resp = self.client.get(reverse("charger-status", args=[aggregate.charger_id]))
+
+        self.assertContains(resp, "Usage (last 7 days)")
+        self.assertContains(resp, connector_one.connector_label)
+        self.assertContains(resp, connector_two.connector_label)
+
+    def test_usage_timeline_merges_repeated_status_entries(self):
+        original_logs = store.logs["charger"]
+        store.logs["charger"] = {}
+        self.addCleanup(lambda: store.logs.__setitem__("charger", original_logs))
+        fixed_now = timezone.now().replace(microsecond=0)
+        charger = Charger.objects.create(
+            charger_id="TLDEDUP",
+            connector_id=1,
+            last_status="Available",
+        )
+
+        def build_entry(delta, status):
+            timestamp = fixed_now - delta
+            payload = {
+                "connectorId": 1,
+                "status": status,
+                "timestamp": timestamp.isoformat(),
+            }
+            prefix = (timestamp.strftime("%Y-%m-%d %H:%M:%S.%f"))[:-3]
+            return f"{prefix} StatusNotification processed: {json.dumps(payload, sort_keys=True)}"
+
+        log_key = store.identity_key(charger.charger_id, charger.connector_id)
+        store.logs["charger"][log_key] = [
+            build_entry(timedelta(days=6, hours=12), "Available"),
+            build_entry(timedelta(days=5), "Available"),
+            build_entry(timedelta(days=3, hours=6), "Charging"),
+            build_entry(timedelta(days=2), "Charging"),
+            build_entry(timedelta(days=1), "Available"),
+        ]
+
+        data, window = _usage_timeline(charger, [], now=fixed_now)
+        self.assertIsNotNone(window)
+        self.assertEqual(len(data), 1)
+        segments = data[0]["segments"]
+        self.assertGreaterEqual(len(segments), 1)
+        statuses = [segment["status"] for segment in segments]
+        self.assertEqual(statuses, ["available", "charging", "available"])
+
     def test_diagnostics_status_displayed(self):
         reported_at = timezone.now().replace(microsecond=0)
         charger = Charger.objects.create(
@@ -4795,6 +5050,59 @@ class LiveUpdateViewTests(TestCase):
         )
         self.assertEqual(aggregate_entry["state"], available_label)
 
+    def test_dashboard_groups_connectors_under_parent(self):
+        aggregate = Charger.objects.create(charger_id="GROUPED")
+        first = Charger.objects.create(
+            charger_id=aggregate.charger_id, connector_id=1
+        )
+        second = Charger.objects.create(
+            charger_id=aggregate.charger_id, connector_id=2
+        )
+
+        resp = self.client.get(reverse("ocpp-dashboard"))
+        self.assertEqual(resp.status_code, 200)
+        groups = resp.context["charger_groups"]
+        target = next(
+            group
+            for group in groups
+            if group.get("parent")
+            and group["parent"]["charger"].pk == aggregate.pk
+        )
+        child_ids = [item["charger"].pk for item in target["children"]]
+        self.assertEqual(child_ids, [first.pk, second.pk])
+
+    def test_dashboard_includes_energy_totals(self):
+        aggregate = Charger.objects.create(charger_id="KWSTATS")
+        now = timezone.now()
+        Transaction.objects.create(
+            charger=aggregate,
+            start_time=now - timedelta(hours=1),
+            stop_time=now,
+            meter_start=0,
+            meter_stop=3000,
+        )
+        past_start = now - timedelta(days=2)
+        Transaction.objects.create(
+            charger=aggregate,
+            start_time=past_start,
+            stop_time=past_start + timedelta(hours=1),
+            meter_start=0,
+            meter_stop=1000,
+        )
+
+        resp = self.client.get(reverse("ocpp-dashboard"))
+        self.assertEqual(resp.status_code, 200)
+        groups = resp.context["charger_groups"]
+        target = next(
+            group
+            for group in groups
+            if group.get("parent")
+            and group["parent"]["charger"].pk == aggregate.pk
+        )
+        stats = target["parent"]["stats"]
+        self.assertAlmostEqual(stats["total_kw"], 4.0, places=2)
+        self.assertAlmostEqual(stats["today_kw"], 3.0, places=2)
+
     def test_cp_simulator_includes_interval(self):
         resp = self.client.get(reverse("cp-simulator"))
         self.assertEqual(resp.context["request"].live_update_interval, 5)