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

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,
             [
@@ -2614,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()
@@ -2887,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()
@@ -3324,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):
@@ -4428,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(

ocpp/views.py

@@ -1,13 +1,13 @@
 import json
 import uuid
-from datetime import datetime, timedelta, timezone as dt_timezone
-from datetime import datetime, time, timedelta
+from datetime import datetime, time, timedelta, timezone as dt_timezone
 from types import SimpleNamespace
 
 from django.http import Http404, HttpResponse, JsonResponse
 from django.http.request import split_domain_port
 from django.views.decorators.csrf import csrf_exempt
 from django.shortcuts import get_object_or_404, render, resolve_url
+from django.template.loader import render_to_string
 from django.core.paginator import Paginator
 from django.contrib.auth.decorators import login_required
 from django.contrib.auth.views import redirect_to_login
@@ -15,7 +15,7 @@ from django.utils.translation import gettext_lazy as _, gettext, ngettext
 from django.utils.text import slugify
 from django.urls import NoReverseMatch, reverse
 from django.conf import settings
-from django.utils import translation, timezone
+from django.utils import translation, timezone, formats
 from django.core.exceptions import ValidationError
 
 from asgiref.sync import async_to_sync
@@ -27,6 +27,8 @@ from nodes.models import Node
 from pages.utils import landing
 from core.liveupdate import live_update
 
+from django.utils.dateparse import parse_datetime
+
 from . import store
 from .models import Transaction, Charger, DataTransferMessage, RFID
 from .evcs import (
@@ -337,6 +339,272 @@ def _connector_overview(
     return overview
 
 
+def _normalize_timeline_status(value: str | None) -> str | None:
+    """Normalize raw charger status strings into timeline buckets."""
+
+    normalized = (value or "").strip().lower()
+    if not normalized:
+        return None
+    charging_states = {
+        "charging",
+        "finishing",
+        "suspendedev",
+        "suspendedevse",
+        "occupied",
+    }
+    available_states = {"available", "preparing", "reserved"}
+    offline_states = {"faulted", "unavailable", "outofservice"}
+    if normalized in charging_states:
+        return "charging"
+    if normalized in offline_states:
+        return "offline"
+    if normalized in available_states:
+        return "available"
+    # Treat other states as available for the initial implementation.
+    return "available"
+
+
+def _timeline_labels() -> dict[str, str]:
+    """Return translated labels for timeline statuses."""
+
+    return {
+        "offline": gettext("Offline"),
+        "available": gettext("Available"),
+        "charging": gettext("Charging"),
+    }
+
+
+def _format_segment_range(start: datetime, end: datetime) -> tuple[str, str]:
+    """Return localized display values for a timeline range."""
+
+    start_display = formats.date_format(
+        timezone.localtime(start), "SHORT_DATETIME_FORMAT"
+    )
+    end_display = formats.date_format(timezone.localtime(end), "SHORT_DATETIME_FORMAT")
+    return start_display, end_display
+
+
+def _collect_status_events(
+    charger: Charger,
+    connector: Charger,
+    window_start: datetime,
+    window_end: datetime,
+) -> tuple[list[tuple[datetime, str]], tuple[datetime, str] | None]:
+    """Parse log entries into ordered status events for the connector."""
+
+    connector_id = connector.connector_id
+    serial = connector.charger_id
+    keys = [store.identity_key(serial, connector_id)]
+    if connector_id is not None:
+        keys.append(store.identity_key(serial, None))
+        keys.append(store.pending_key(serial))
+
+    seen_entries: set[str] = set()
+    events: list[tuple[datetime, str]] = []
+    latest_before_window: tuple[datetime, str] | None = None
+
+    for key in keys:
+        for entry in store.get_logs(key, log_type="charger"):
+            if entry in seen_entries:
+                continue
+            seen_entries.add(entry)
+            if len(entry) < 24:
+                continue
+            timestamp_raw = entry[:23]
+            message = entry[24:].strip()
+            try:
+                log_timestamp = datetime.strptime(
+                    timestamp_raw, "%Y-%m-%d %H:%M:%S.%f"
+                ).replace(tzinfo=dt_timezone.utc)
+            except ValueError:
+                continue
+
+            event_time = log_timestamp
+            status_bucket: str | None = None
+
+            if message.startswith("StatusNotification processed:"):
+                payload_text = message.split(":", 1)[1].strip()
+                try:
+                    payload = json.loads(payload_text)
+                except json.JSONDecodeError:
+                    continue
+                target_id = payload.get("connectorId")
+                if connector_id is not None:
+                    try:
+                        normalized_target = int(target_id)
+                    except (TypeError, ValueError):
+                        normalized_target = None
+                    if normalized_target not in {connector_id, None}:
+                        continue
+                raw_status = payload.get("status")
+                status_bucket = _normalize_timeline_status(
+                    raw_status if isinstance(raw_status, str) else None
+                )
+                payload_timestamp = payload.get("timestamp")
+                if isinstance(payload_timestamp, str):
+                    parsed = parse_datetime(payload_timestamp)
+                    if parsed is not None:
+                        if timezone.is_naive(parsed):
+                            parsed = timezone.make_aware(parsed, timezone=dt_timezone.utc)
+                        event_time = parsed
+            elif message.startswith("Connected"):
+                status_bucket = "available"
+            elif message.startswith("Closed"):
+                status_bucket = "offline"
+
+            if not status_bucket:
+                continue
+
+            if event_time < window_start:
+                if (
+                    latest_before_window is None
+                    or event_time > latest_before_window[0]
+                ):
+                    latest_before_window = (event_time, status_bucket)
+                continue
+            if event_time > window_end:
+                continue
+            events.append((event_time, status_bucket))
+
+    events.sort(key=lambda item: item[0])
+
+    deduped_events: list[tuple[datetime, str]] = []
+    for event_time, state in events:
+        if deduped_events and deduped_events[-1][1] == state:
+            continue
+        deduped_events.append((event_time, state))
+
+    return deduped_events, latest_before_window
+
+
+def _usage_timeline(
+    charger: Charger,
+    connector_overview: list[dict],
+    *,
+    now: datetime | None = None,
+) -> tuple[list[dict], tuple[str, str] | None]:
+    """Build usage timeline data for inactive chargers."""
+
+    if now is None:
+        now = timezone.now()
+    window_end = now
+    window_start = now - timedelta(days=7)
+
+    if charger.connector_id is not None:
+        connectors = [charger]
+    else:
+        connectors = [
+            item["charger"]
+            for item in connector_overview
+            if item.get("charger") and item["charger"].connector_id is not None
+        ]
+        if not connectors:
+            connectors = [
+                sibling
+                for sibling in _connector_set(charger)
+                if sibling.connector_id is not None
+            ]
+
+    seen_ids: set[int] = set()
+    labels = _timeline_labels()
+    timeline_entries: list[dict] = []
+    window_display: tuple[str, str] | None = None
+
+    if window_start < window_end:
+        window_display = _format_segment_range(window_start, window_end)
+
+    for connector in connectors:
+        if connector.connector_id is None:
+            continue
+        if connector.connector_id in seen_ids:
+            continue
+        seen_ids.add(connector.connector_id)
+
+        events, prior_event = _collect_status_events(
+            charger, connector, window_start, window_end
+        )
+        fallback_state = _normalize_timeline_status(connector.last_status)
+        if fallback_state is None:
+            fallback_state = (
+                "available"
+                if store.is_connected(connector.charger_id, connector.connector_id)
+                else "offline"
+            )
+        current_state = fallback_state
+        if prior_event is not None:
+            current_state = prior_event[1]
+        segments: list[dict] = []
+        previous_time = window_start
+        total_seconds = (window_end - window_start).total_seconds()
+
+        for event_time, state in events:
+            if event_time <= window_start:
+                current_state = state
+                continue
+            if event_time > window_end:
+                break
+            if state == current_state:
+                continue
+            segment_start = max(previous_time, window_start)
+            segment_end = min(event_time, window_end)
+            if segment_end > segment_start:
+                duration = (segment_end - segment_start).total_seconds()
+                start_display, end_display = _format_segment_range(
+                    segment_start, segment_end
+                )
+                segments.append(
+                    {
+                        "status": current_state,
+                        "label": labels.get(current_state, current_state.title()),
+                        "start_display": start_display,
+                        "end_display": end_display,
+                        "duration": max(duration, 1.0),
+                    }
+                )
+            current_state = state
+            previous_time = max(event_time, window_start)
+
+        if previous_time < window_end:
+            segment_start = max(previous_time, window_start)
+            segment_end = window_end
+            if segment_end > segment_start:
+                duration = (segment_end - segment_start).total_seconds()
+                start_display, end_display = _format_segment_range(
+                    segment_start, segment_end
+                )
+                segments.append(
+                    {
+                        "status": current_state,
+                        "label": labels.get(current_state, current_state.title()),
+                        "start_display": start_display,
+                        "end_display": end_display,
+                        "duration": max(duration, 1.0),
+                    }
+                )
+
+        if not segments and total_seconds > 0:
+            start_display, end_display = _format_segment_range(window_start, window_end)
+            segments.append(
+                {
+                    "status": current_state,
+                    "label": labels.get(current_state, current_state.title()),
+                    "start_display": start_display,
+                    "end_display": end_display,
+                    "duration": max(total_seconds, 1.0),
+                }
+            )
+
+        if segments:
+            timeline_entries.append(
+                {
+                    "label": connector.connector_label,
+                    "segments": segments,
+                }
+            )
+
+    return timeline_entries, window_display
+
+
 def _live_sessions(charger: Charger) -> list[tuple[Charger, Transaction]]:
     """Return active sessions grouped by connector for the charger."""
 
@@ -854,6 +1122,11 @@ def dashboard(request):
         "demo_ws_url": ws_url,
         "ws_rate_limit": store.MAX_CONNECTIONS_PER_IP,
     }
+    if request.headers.get("x-requested-with") == "XMLHttpRequest" or request.GET.get("partial") == "table":
+        html = render_to_string(
+            "ocpp/includes/dashboard_table_rows.html", context, request=request
+        )
+        return JsonResponse({"html": html})
     return render(request, "ocpp/dashboard.html", context)
 
 
@@ -1214,6 +1487,9 @@ def charger_status(request, cid, connector=None):
     connector_overview = [
         item for item in overview if item["charger"].connector_id is not None
     ]
+    usage_timeline, usage_timeline_window = _usage_timeline(
+        charger, connector_overview
+    )
     search_url = _reverse_connector_url("charger-session-search", cid, connector_slug)
     configuration_url = None
     if request.user.is_staff:
@@ -1280,6 +1556,8 @@ def charger_status(request, cid, connector=None):
             "pagination_query": pagination_query,
             "session_query": session_query,
             "chart_should_animate": chart_should_animate,
+            "usage_timeline": usage_timeline,
+            "usage_timeline_window": usage_timeline_window,
         },
     )