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

ocpp/tests.py

@@ -2335,6 +2335,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(
@@ -4795,6 +4825,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)

ocpp/views.py

@@ -1,6 +1,7 @@
 import json
 import uuid
 from datetime import datetime, timedelta, timezone as dt_timezone
+from datetime import datetime, time, timedelta
 from types import SimpleNamespace
 
 from django.http import Http404, HttpResponse, JsonResponse
@@ -752,8 +753,48 @@ def dashboard(request):
             request.get_full_path(), login_url=reverse("pages:login")
         )
     is_watchtower = role_name in {"Watchtower", "Constellation"}
-    chargers = []
-    for charger in _visible_chargers(request.user):
+    visible_chargers = (
+        _visible_chargers(request.user)
+        .select_related("location")
+        .order_by("charger_id", "connector_id")
+    )
+    stats_cache: dict[int, dict[str, float]] = {}
+
+    def _charger_display_name(charger: Charger) -> str:
+        if charger.display_name:
+            return charger.display_name
+        if charger.location:
+            return charger.location.name
+        return charger.charger_id
+
+    today = timezone.localdate()
+    tz = timezone.get_current_timezone()
+    day_start = datetime.combine(today, time.min)
+    if timezone.is_naive(day_start):
+        day_start = timezone.make_aware(day_start, tz)
+    day_end = day_start + timedelta(days=1)
+
+    def _charger_stats(charger: Charger) -> dict[str, float]:
+        cache_key = charger.pk or id(charger)
+        if cache_key not in stats_cache:
+            stats_cache[cache_key] = {
+                "total_kw": charger.total_kw,
+                "today_kw": charger.total_kw_for_range(day_start, day_end),
+            }
+        return stats_cache[cache_key]
+
+    def _status_url(charger: Charger) -> str:
+        return _reverse_connector_url(
+            "charger-status",
+            charger.charger_id,
+            charger.connector_slug,
+        )
+
+    chargers: list[dict[str, object]] = []
+    charger_groups: list[dict[str, object]] = []
+    group_lookup: dict[str, dict[str, object]] = {}
+
+    for charger in visible_chargers:
         tx_obj = store.get_transaction(charger.charger_id, charger.connector_id)
         if not tx_obj:
             tx_obj = (
@@ -761,13 +802,54 @@ def dashboard(request):
                 .order_by("-start_time")
                 .first()
             )
+        has_session = _has_active_session(tx_obj)
         state, color = _charger_state(charger, tx_obj)
-        chargers.append({"charger": charger, "state": state, "color": color})
+        if (
+            charger.connector_id is not None
+            and not has_session
+            and (charger.last_status or "").strip().casefold() == "charging"
+        ):
+            state, color = STATUS_BADGE_MAP["charging"]
+        entry = {
+            "charger": charger,
+            "state": state,
+            "color": color,
+            "display_name": _charger_display_name(charger),
+            "stats": _charger_stats(charger),
+            "status_url": _status_url(charger),
+        }
+        chargers.append(entry)
+        if charger.connector_id is None:
+            group = {"parent": entry, "children": []}
+            charger_groups.append(group)
+            group_lookup[charger.charger_id] = group
+        else:
+            group = group_lookup.get(charger.charger_id)
+            if group is None:
+                group = {"parent": None, "children": []}
+                charger_groups.append(group)
+                group_lookup[charger.charger_id] = group
+            group["children"].append(entry)
+
+    for group in charger_groups:
+        parent_entry = group.get("parent")
+        if not parent_entry or not group["children"]:
+            continue
+        connector_statuses = [
+            (child["charger"].last_status or "").strip().casefold()
+            for child in group["children"]
+            if child["charger"].connector_id is not None
+        ]
+        if connector_statuses and all(status == "charging" for status in connector_statuses):
+            label, badge_color = STATUS_BADGE_MAP["charging"]
+            parent_entry["state"] = label
+            parent_entry["color"] = badge_color
     scheme = "wss" if request.is_secure() else "ws"
     host = request.get_host()
     ws_url = f"{scheme}://{host}/ocpp/<CHARGE_POINT_ID>/"
     context = {
         "chargers": chargers,
+        "charger_groups": charger_groups,
         "show_demo_notice": is_watchtower,
         "demo_ws_url": ws_url,
         "ws_rate_limit": store.MAX_CONNECTIONS_PER_IP,

pages/context_processors.py

@@ -2,7 +2,6 @@ from utils.sites import get_site
 from django.urls import Resolver404, resolve
 from django.conf import settings
 from pathlib import Path
-from types import SimpleNamespace
 from nodes.models import Node
 from core.models import Reference
 from core.reference_utils import filter_visible_references
@@ -49,7 +48,6 @@ def nav_links(request):
         modules = []
 
     valid_modules = []
-    datasette_enabled = False
     current_module = None
     user = getattr(request, "user", None)
     user_is_authenticated = getattr(user, "is_authenticated", False)
@@ -117,15 +115,6 @@ def nav_links(request):
                 ):
                     current_module = module
 
-    datasette_lock = Path(settings.BASE_DIR) / "locks" / "datasette.lck"
-    if datasette_lock.exists():
-        datasette_enabled = True
-        datasette_module = SimpleNamespace(
-            menu_label="Data",
-            path="/data/",
-            enabled_landings=[SimpleNamespace(path="/data/", label="Datasette")],
-        )
-        valid_modules.append(datasette_module)
 
     valid_modules.sort(key=lambda m: m.menu_label.lower())
 
@@ -159,5 +148,4 @@ def nav_links(request):
         "nav_modules": valid_modules,
         "favicon_url": favicon_url,
         "header_references": header_references,
-        "datasette_enabled": datasette_enabled,
     }

pages/tests.py

@@ -3221,47 +3221,6 @@ class AdminModelGraphViewTests(TestCase):
         self.assertEqual(kwargs.get("format"), "pdf")
 
 
-class DatasetteTests(TestCase):
-    def setUp(self):
-        self.client = Client()
-        User = get_user_model()
-        self.user = User.objects.create_user(username="ds", password="pwd")
-        Site.objects.update_or_create(id=1, defaults={"name": "Terminal"})
-
-    def test_datasette_auth_endpoint(self):
-        resp = self.client.get(reverse("pages:datasette-auth"))
-        self.assertEqual(resp.status_code, 401)
-        self.client.force_login(self.user)
-        resp = self.client.get(reverse("pages:datasette-auth"))
-        self.assertEqual(resp.status_code, 200)
-
-    def test_navbar_includes_datasette_when_enabled(self):
-        lock_dir = Path(settings.BASE_DIR) / "locks"
-        lock_dir.mkdir(exist_ok=True)
-        lock_file = lock_dir / "datasette.lck"
-        try:
-            lock_file.touch()
-            resp = self.client.get(reverse("pages:index"))
-            self.assertContains(resp, 'href="/data/"')
-        finally:
-            lock_file.unlink(missing_ok=True)
-
-    def test_admin_home_includes_datasette_button_when_enabled(self):
-        lock_dir = Path(settings.BASE_DIR) / "locks"
-        lock_dir.mkdir(exist_ok=True)
-        lock_file = lock_dir / "datasette.lck"
-        try:
-            lock_file.touch()
-            self.user.is_staff = True
-            self.user.is_superuser = True
-            self.user.save()
-            self.client.force_login(self.user)
-            resp = self.client.get(reverse("admin:index"))
-            self.assertContains(resp, 'href="/data/"')
-            self.assertContains(resp, ">Datasette<")
-        finally:
-            lock_file.unlink(missing_ok=True)
-
 
 class UserStorySubmissionTests(TestCase):
     def setUp(self):

pages/urls.py

@@ -21,7 +21,6 @@ urlpatterns = [
         views.invitation_login,
         name="invitation-login",
     ),
-    path("datasette-auth/", views.datasette_auth, name="datasette-auth"),
     path("man/", views.manual_list, name="manual-list"),
     path("man/<slug:slug>/", views.manual_detail, name="manual-detail"),
     path("man/<slug:slug>/pdf/", views.manual_pdf, name="manual-pdf"),

pages/views.py

@@ -710,11 +710,6 @@ def release_checklist(request):
     return response
 
 
-@csrf_exempt
-def datasette_auth(request):
-    if request.user.is_authenticated:
-        return HttpResponse("OK")
-    return HttpResponse(status=401)
 
 
 class CustomLoginView(LoginView):

core/workgroup_urls.py

@@ -1,17 +0,0 @@
-"""URL routes for assistant profile endpoints."""
-
-from django.urls import path
-
-from . import workgroup_views as views
-
-app_name = "workgroup"
-
-urlpatterns = [
-    path(
-        "assistant-profiles/<int:user_id>/",
-        views.issue_key,
-        name="assistantprofile-issue",
-    ),
-    path("assistant/test/", views.assistant_test, name="assistant-test"),
-    path("chat/", views.chat, name="chat"),
-]

core/workgroup_views.py

@@ -1,94 +0,0 @@
-"""REST endpoints for AssistantProfile issuance and authentication."""
-
-from __future__ import annotations
-
-from functools import wraps
-
-from django.apps import apps
-from django.contrib.auth import get_user_model
-from django.forms.models import model_to_dict
-from django.http import HttpResponse, JsonResponse
-from django.views.decorators.csrf import csrf_exempt
-from django.views.decorators.http import require_GET, require_POST
-
-from .models import AssistantProfile, hash_key
-
-
-@csrf_exempt
-@require_POST
-def issue_key(request, user_id: int) -> JsonResponse:
-    """Issue a new ``user_key`` for ``user_id``.
-
-    The response reveals the plain key once. Store only the hash server-side.
-    """
-
-    user = get_user_model().objects.get(pk=user_id)
-    profile, key = AssistantProfile.issue_key(user)
-    return JsonResponse({"user_id": user_id, "user_key": key})
-
-
-def authenticate(view_func):
-    """View decorator that validates the ``Authorization`` header."""
-
-    @wraps(view_func)
-    def wrapper(request, *args, **kwargs):
-        header = request.META.get("HTTP_AUTHORIZATION", "")
-        if not header.startswith("Bearer "):
-            return HttpResponse(status=401)
-
-        key_hash = hash_key(header.split(" ", 1)[1])
-        try:
-            profile = AssistantProfile.objects.get(
-                user_key_hash=key_hash, is_active=True
-            )
-        except AssistantProfile.DoesNotExist:
-            return HttpResponse(status=401)
-
-        profile.touch()
-        request.assistant_profile = profile
-        request.chat_profile = profile
-        return view_func(request, *args, **kwargs)
-
-    return wrapper
-
-
-@require_GET
-@authenticate
-def assistant_test(request):
-    """Return a simple greeting to confirm authentication."""
-
-    profile = getattr(request, "assistant_profile", None)
-    user_id = profile.user_id if profile else None
-    return JsonResponse({"message": f"Hello from user {user_id}"})
-
-
-@require_GET
-@authenticate
-def chat(request):
-    """Return serialized data from any model.
-
-    Clients must provide ``model`` as ``app_label.ModelName`` and may include a
-    ``pk`` to fetch a specific record. When ``pk`` is omitted, the view returns
-    up to 100 records.
-    """
-
-    model_label = request.GET.get("model")
-    if not model_label:
-        return JsonResponse({"error": "model parameter required"}, status=400)
-    try:
-        model = apps.get_model(model_label)
-    except LookupError:
-        return JsonResponse({"error": "unknown model"}, status=400)
-
-    qs = model.objects.all()
-    pk = request.GET.get("pk")
-    if pk is not None:
-        try:
-            obj = qs.get(pk=pk)
-        except model.DoesNotExist:
-            return JsonResponse({"error": "object not found"}, status=404)
-        data = model_to_dict(obj)
-    else:
-        data = [model_to_dict(o) for o in qs[:100]]
-
-    return JsonResponse({"data": data})