arthexis 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

ocpp/views.py

@@ -1,17 +1,26 @@
 import asyncio
 import json
 from datetime import datetime, timedelta, timezone as dt_timezone
+from types import SimpleNamespace
 
-from django.http import JsonResponse, HttpResponse
+from django.http import JsonResponse, Http404
+from django.http.request import split_domain_port
 from django.views.decorators.csrf import csrf_exempt
 from django.shortcuts import render, get_object_or_404
 from django.core.paginator import Paginator
 from django.contrib.auth.decorators import login_required
-from django.utils.translation import gettext_lazy as _
+from django.contrib.auth.views import redirect_to_login
+from django.utils.translation import gettext_lazy as _, gettext, ngettext
+from django.urls import NoReverseMatch, reverse
+from django.conf import settings
+from django.utils import translation
 
 from utils.api import api_login_required
 
+from nodes.models import Node
+
 from pages.utils import landing
+from core.liveupdate import live_update
 
 from . import store
 from .models import Transaction, Charger
@@ -23,25 +32,216 @@ from .evcs import (
 )
 
 
-def _charger_state(charger: Charger, tx_obj: Transaction | None):
+def _normalize_connector_slug(slug: str | None) -> tuple[int | None, str]:
+    """Return connector value and normalized slug or raise 404."""
+
+    try:
+        value = Charger.connector_value_from_slug(slug)
+    except ValueError as exc:  # pragma: no cover - defensive guard
+        raise Http404("Invalid connector") from exc
+    return value, Charger.connector_slug_from_value(value)
+
+
+def _reverse_connector_url(name: str, serial: str, connector_slug: str) -> str:
+    """Return URL name for connector-aware routes."""
+
+    target = f"{name}-connector"
+    if connector_slug == Charger.AGGREGATE_CONNECTOR_SLUG:
+        try:
+            return reverse(target, args=[serial, connector_slug])
+        except NoReverseMatch:
+            return reverse(name, args=[serial])
+    return reverse(target, args=[serial, connector_slug])
+
+
+def _get_charger(serial: str, connector_slug: str | None) -> tuple[Charger, str]:
+    """Return charger for the requested identity, creating if necessary."""
+
+    connector_value, normalized_slug = _normalize_connector_slug(connector_slug)
+    if connector_value is None:
+        charger, _ = Charger.objects.get_or_create(
+            charger_id=serial,
+            connector_id=None,
+        )
+    else:
+        charger, _ = Charger.objects.get_or_create(
+            charger_id=serial,
+            connector_id=connector_value,
+        )
+    return charger, normalized_slug
+
+
+def _connector_set(charger: Charger) -> list[Charger]:
+    """Return chargers sharing the same serial ordered for navigation."""
+
+    siblings = list(Charger.objects.filter(charger_id=charger.charger_id))
+    siblings.sort(key=lambda c: (c.connector_id is not None, c.connector_id or 0))
+    return siblings
+
+
+def _connector_overview(charger: Charger) -> list[dict]:
+    """Return connector metadata used for navigation and summaries."""
+
+    overview: list[dict] = []
+    for sibling in _connector_set(charger):
+        tx_obj = store.get_transaction(sibling.charger_id, sibling.connector_id)
+        state, color = _charger_state(sibling, tx_obj)
+        overview.append(
+            {
+                "charger": sibling,
+                "slug": sibling.connector_slug,
+                "label": sibling.connector_label,
+                "url": _reverse_connector_url(
+                    "charger-page", sibling.charger_id, sibling.connector_slug
+                ),
+                "status": state,
+                "color": color,
+                "last_status": sibling.last_status,
+                "last_error_code": sibling.last_error_code,
+                "last_status_timestamp": sibling.last_status_timestamp,
+                "last_status_vendor_info": sibling.last_status_vendor_info,
+                "tx": tx_obj,
+                "connected": store.is_connected(
+                    sibling.charger_id, sibling.connector_id
+                ),
+            }
+        )
+    return overview
+
+
+def _live_sessions(charger: Charger) -> list[tuple[Charger, Transaction]]:
+    """Return active sessions grouped by connector for the charger."""
+
+    siblings = _connector_set(charger)
+    ordered = [c for c in siblings if c.connector_id is not None] + [
+        c for c in siblings if c.connector_id is None
+    ]
+    sessions: list[tuple[Charger, Transaction]] = []
+    seen: set[int] = set()
+    for sibling in ordered:
+        tx_obj = store.get_transaction(sibling.charger_id, sibling.connector_id)
+        if not tx_obj:
+            continue
+        if tx_obj.pk and tx_obj.pk in seen:
+            continue
+        if tx_obj.pk:
+            seen.add(tx_obj.pk)
+        sessions.append((sibling, tx_obj))
+    return sessions
+
+
+def _landing_page_translations() -> dict[str, dict[str, str]]:
+    """Return static translations used by the charger public landing page."""
+
+    catalog: dict[str, dict[str, str]] = {}
+    for code in ("en", "es"):
+        with translation.override(code):
+            catalog[code] = {
+                "serial_number_label": gettext("Serial Number"),
+                "connector_label": gettext("Connector"),
+                "advanced_view_label": gettext("Advanced View"),
+                "require_rfid_label": gettext("Require RFID Authorization"),
+                "charging_label": gettext("Charging"),
+                "energy_label": gettext("Energy"),
+                "started_label": gettext("Started"),
+                "instruction_text": gettext(
+                    "Plug in your vehicle and slide your RFID card over the reader to begin charging."
+                ),
+                "connectors_heading": gettext("Connectors"),
+                "no_active_transaction": gettext("No active transaction"),
+                "connectors_active_singular": ngettext(
+                    "%(count)s connector active",
+                    "%(count)s connectors active",
+                    1,
+                ),
+                "connectors_active_plural": ngettext(
+                    "%(count)s connector active",
+                    "%(count)s connectors active",
+                    2,
+                ),
+                "status_reported_label": gettext("Reported status"),
+                "status_error_label": gettext("Error code"),
+                "status_updated_label": gettext("Last status update"),
+                "status_vendor_label": gettext("Vendor"),
+                "status_info_label": gettext("Info"),
+            }
+    return catalog
+
+
+STATUS_BADGE_MAP: dict[str, tuple[str, str]] = {
+    "available": (_("Available"), "#0d6efd"),
+    "preparing": (_("Preparing"), "#0d6efd"),
+    "charging": (_("Charging"), "#198754"),
+    "suspendedevse": (_("Suspended (EVSE)"), "#fd7e14"),
+    "suspendedev": (_("Suspended (EV)"), "#fd7e14"),
+    "finishing": (_("Finishing"), "#20c997"),
+    "faulted": (_("Faulted"), "#dc3545"),
+    "unavailable": (_("Unavailable"), "#6c757d"),
+    "reserved": (_("Reserved"), "#6f42c1"),
+    "occupied": (_("Occupied"), "#0dcaf0"),
+    "outofservice": (_("Out of Service"), "#6c757d"),
+}
+
+_ERROR_OK_VALUES = {"", "noerror", "no_error"}
+
+
+def _charger_state(charger: Charger, tx_obj: Transaction | list | None):
     """Return human readable state and color for a charger."""
+
+    status_value = (charger.last_status or "").strip()
+    if status_value:
+        key = status_value.lower()
+        label, color = STATUS_BADGE_MAP.get(key, (status_value, "#0d6efd"))
+        error_code = (charger.last_error_code or "").strip()
+        if error_code and error_code.lower() not in _ERROR_OK_VALUES:
+            label = _("%(status)s (%(error)s)") % {
+                "status": label,
+                "error": error_code,
+            }
+            color = "#dc3545"
+        return label, color
+
     cid = charger.charger_id
-    connected = cid in store.connections
-    if connected and tx_obj:
-        return "Charging", "green"
+    connected = store.is_connected(cid, charger.connector_id)
+    has_session = bool(tx_obj)
+    if connected and has_session:
+        return _("Charging"), "green"
     if connected:
-        return "Available", "blue"
-    return "Offline", "grey"
+        return _("Available"), "blue"
+    return _("Offline"), "grey"
 
 
+def _diagnostics_payload(charger: Charger) -> dict[str, str | None]:
+    """Return diagnostics metadata for API responses."""
+
+    timestamp = (
+        charger.diagnostics_timestamp.isoformat()
+        if charger.diagnostics_timestamp
+        else None
+    )
+    status = charger.diagnostics_status or None
+    location = charger.diagnostics_location or None
+    return {
+        "diagnosticsStatus": status,
+        "diagnosticsTimestamp": timestamp,
+        "diagnosticsLocation": location,
+    }
+
 
 @api_login_required
 def charger_list(request):
     """Return a JSON list of known chargers and state."""
     data = []
-    for charger in Charger.objects.all():
+    for charger in Charger.objects.filter(public_display=True):
         cid = charger.charger_id
-        tx_obj = store.transactions.get(cid)
+        sessions: list[tuple[Charger, Transaction]] = []
+        tx_obj = store.get_transaction(cid, charger.connector_id)
+        if charger.connector_id is None:
+            sessions = _live_sessions(charger)
+            if sessions:
+                tx_obj = sessions[0][1]
+        elif tx_obj:
+            sessions = [(charger, tx_obj)]
         if not tx_obj:
             tx_obj = (
                 Transaction.objects.filter(charger__charger_id=cid)
@@ -61,27 +261,78 @@ def charger_list(request):
                 tx_data["meterStop"] = tx_obj.meter_stop
             if tx_obj.stop_time is not None:
                 tx_data["stopTime"] = tx_obj.stop_time.isoformat()
-        data.append(
-            {
-                "charger_id": cid,
-                "name": charger.name,
-                "require_rfid": charger.require_rfid,
-                "transaction": tx_data,
-                "lastHeartbeat": charger.last_heartbeat.isoformat() if charger.last_heartbeat else None,
-                "lastMeterValues": charger.last_meter_values,
-                "connected": cid in store.connections,
+        active_transactions = []
+        for session_charger, session_tx in sessions:
+            active_payload = {
+                "charger_id": session_charger.charger_id,
+                "connector_id": session_charger.connector_id,
+                "connector_slug": session_charger.connector_slug,
+                "transactionId": session_tx.pk,
+                "meterStart": session_tx.meter_start,
+                "startTime": session_tx.start_time.isoformat(),
             }
+            if session_tx.vin:
+                active_payload["vin"] = session_tx.vin
+            if session_tx.meter_stop is not None:
+                active_payload["meterStop"] = session_tx.meter_stop
+            if session_tx.stop_time is not None:
+                active_payload["stopTime"] = session_tx.stop_time.isoformat()
+            active_transactions.append(active_payload)
+        state, color = _charger_state(
+            charger,
+            tx_obj if charger.connector_id is not None else (sessions if sessions else None),
         )
+        entry = {
+            "charger_id": cid,
+            "name": charger.name,
+            "connector_id": charger.connector_id,
+            "connector_slug": charger.connector_slug,
+            "connector_label": charger.connector_label,
+            "require_rfid": charger.require_rfid,
+            "transaction": tx_data,
+            "activeTransactions": active_transactions,
+            "lastHeartbeat": (
+                charger.last_heartbeat.isoformat()
+                if charger.last_heartbeat
+                else None
+            ),
+            "lastMeterValues": charger.last_meter_values,
+            "firmwareStatus": charger.firmware_status,
+            "firmwareStatusInfo": charger.firmware_status_info,
+            "firmwareTimestamp": (
+                charger.firmware_timestamp.isoformat()
+                if charger.firmware_timestamp
+                else None
+            ),
+            "connected": store.is_connected(cid, charger.connector_id),
+            "lastStatus": charger.last_status or None,
+            "lastErrorCode": charger.last_error_code or None,
+            "lastStatusTimestamp": (
+                charger.last_status_timestamp.isoformat()
+                if charger.last_status_timestamp
+                else None
+            ),
+            "lastStatusVendorInfo": charger.last_status_vendor_info,
+            "status": state,
+            "statusColor": color,
+        }
+        entry.update(_diagnostics_payload(charger))
+        data.append(entry)
     return JsonResponse({"chargers": data})
 
 
 @api_login_required
-def charger_detail(request, cid):
-    charger = Charger.objects.filter(charger_id=cid).first()
-    if charger is None:
-        return JsonResponse({"detail": "not found"}, status=404)
-
-    tx_obj = store.transactions.get(cid)
+def charger_detail(request, cid, connector=None):
+    charger, connector_slug = _get_charger(cid, connector)
+
+    sessions: list[tuple[Charger, Transaction]] = []
+    tx_obj = store.get_transaction(cid, charger.connector_id)
+    if charger.connector_id is None:
+        sessions = _live_sessions(charger)
+        if sessions:
+            tx_obj = sessions[0][1]
+    elif tx_obj:
+        sessions = [(charger, tx_obj)]
     if not tx_obj:
         tx_obj = (
             Transaction.objects.filter(charger__charger_id=cid)
@@ -103,27 +354,79 @@ def charger_detail(request, cid):
         if tx_obj.stop_time is not None:
             tx_data["stopTime"] = tx_obj.stop_time.isoformat()
 
-    log = store.get_logs(cid, log_type="charger")
-    return JsonResponse(
-        {
-            "charger_id": cid,
-            "name": charger.name,
-            "require_rfid": charger.require_rfid,
-            "transaction": tx_data,
-            "lastHeartbeat": charger.last_heartbeat.isoformat() if charger.last_heartbeat else None,
-            "lastMeterValues": charger.last_meter_values,
-            "log": log,
+    active_transactions = []
+    for session_charger, session_tx in sessions:
+        payload = {
+            "charger_id": session_charger.charger_id,
+            "connector_id": session_charger.connector_id,
+            "connector_slug": session_charger.connector_slug,
+            "transactionId": session_tx.pk,
+            "meterStart": session_tx.meter_start,
+            "startTime": session_tx.start_time.isoformat(),
         }
+        if session_tx.vin:
+            payload["vin"] = session_tx.vin
+        if session_tx.meter_stop is not None:
+            payload["meterStop"] = session_tx.meter_stop
+        if session_tx.stop_time is not None:
+            payload["stopTime"] = session_tx.stop_time.isoformat()
+        active_transactions.append(payload)
+
+    log_key = store.identity_key(cid, charger.connector_id)
+    log = store.get_logs(log_key, log_type="charger")
+    state, color = _charger_state(
+        charger,
+        tx_obj if charger.connector_id is not None else (sessions if sessions else None),
     )
+    payload = {
+        "charger_id": cid,
+        "connector_id": charger.connector_id,
+        "connector_slug": connector_slug,
+        "name": charger.name,
+        "require_rfid": charger.require_rfid,
+        "transaction": tx_data,
+        "activeTransactions": active_transactions,
+        "lastHeartbeat": (
+            charger.last_heartbeat.isoformat() if charger.last_heartbeat else None
+        ),
+        "lastMeterValues": charger.last_meter_values,
+        "firmwareStatus": charger.firmware_status,
+        "firmwareStatusInfo": charger.firmware_status_info,
+        "firmwareTimestamp": (
+            charger.firmware_timestamp.isoformat()
+            if charger.firmware_timestamp
+            else None
+        ),
+        "log": log,
+        "lastStatus": charger.last_status or None,
+        "lastErrorCode": charger.last_error_code or None,
+        "lastStatusTimestamp": (
+            charger.last_status_timestamp.isoformat()
+            if charger.last_status_timestamp
+            else None
+        ),
+        "lastStatusVendorInfo": charger.last_status_vendor_info,
+        "status": state,
+        "statusColor": color,
+    }
+    payload.update(_diagnostics_payload(charger))
+    return JsonResponse(payload)
 
 
-@login_required
-@landing("Dashboard")
+@landing("OCPP CSMS Dashboard")
+@live_update()
 def dashboard(request):
     """Landing page listing all known chargers and their status."""
+    node = Node.get_local()
+    role = node.role if node else None
+    is_constellation = bool(role and role.name == "Constellation")
+    if not request.user.is_authenticated and not is_constellation:
+        return redirect_to_login(
+            request.get_full_path(), login_url=reverse("pages:login")
+        )
     chargers = []
-    for charger in Charger.objects.all():
-        tx_obj = store.transactions.get(charger.charger_id)
+    for charger in Charger.objects.filter(public_display=True):
+        tx_obj = store.get_transaction(charger.charger_id, charger.connector_id)
         if not tx_obj:
             tx_obj = (
                 Transaction.objects.filter(charger=charger)
@@ -132,16 +435,31 @@ def dashboard(request):
             )
         state, color = _charger_state(charger, tx_obj)
         chargers.append({"charger": charger, "state": state, "color": color})
-    return render(request, "ocpp/dashboard.html", {"chargers": chargers})
+    scheme = "wss" if request.is_secure() else "ws"
+    host = request.get_host()
+    ws_url = f"{scheme}://{host}/ocpp/<CHARGE_POINT_ID>/"
+    context = {
+        "chargers": chargers,
+        "show_demo_notice": is_constellation,
+        "demo_ws_url": ws_url,
+        "ws_rate_limit": store.MAX_CONNECTIONS_PER_IP,
+    }
+    return render(request, "ocpp/dashboard.html", context)
 
 
 @login_required
-@landing("CP Simulator")
+@landing("Charge Point Simulator")
+@live_update()
 def cp_simulator(request):
     """Public landing page to control the OCPP charge point simulator."""
-    default_host = "127.0.0.1"
-    default_ws_port = "9000"
+    host_header = request.get_host()
+    default_host, host_port = split_domain_port(host_header)
+    if not default_host:
+        default_host = "127.0.0.1"
+    default_ws_port = request.get_port() or host_port or "8000"
     default_cp_paths = ["CP1", "CP2"]
+    default_serial_numbers = default_cp_paths
+    default_connector_id = 1
     default_rfid = "FFFFFFFF"
     default_vins = ["WP0ZZZ00000000000", "WAUZZZ00000000000"]
 
@@ -150,14 +468,25 @@ def cp_simulator(request):
         cp_idx = int(request.POST.get("cp") or 1)
         action = request.POST.get("action")
         if action == "start":
+            ws_port_value = request.POST.get("ws_port")
+            if ws_port_value is None:
+                ws_port = int(default_ws_port) if default_ws_port else None
+            elif ws_port_value.strip():
+                ws_port = int(ws_port_value)
+            else:
+                ws_port = None
             sim_params = dict(
                 host=request.POST.get("host") or default_host,
-                ws_port=int(request.POST.get("ws_port") or default_ws_port),
-                cp_path=request.POST.get("cp_path")
-                or default_cp_paths[cp_idx - 1],
-                  rfid=request.POST.get("rfid") or default_rfid,
-                  vin=request.POST.get("vin") or default_vins[cp_idx - 1],
-                  duration=int(request.POST.get("duration") or 600),
+                ws_port=ws_port,
+                cp_path=request.POST.get("cp_path") or default_cp_paths[cp_idx - 1],
+                serial_number=request.POST.get("serial_number")
+                or default_serial_numbers[cp_idx - 1],
+                connector_id=int(
+                    request.POST.get("connector_id") or default_connector_id
+                ),
+                rfid=request.POST.get("rfid") or default_rfid,
+                vin=request.POST.get("vin") or default_vins[cp_idx - 1],
+                duration=int(request.POST.get("duration") or 600),
                 interval=float(request.POST.get("interval") or 5),
                 kw_min=float(request.POST.get("kw_min") or 30),
                 kw_max=float(request.POST.get("kw_max") or 60),
@@ -201,6 +530,8 @@ def cp_simulator(request):
         "default_host": default_host,
         "default_ws_port": default_ws_port,
         "default_cp_paths": default_cp_paths,
+        "default_serial_numbers": default_serial_numbers,
+        "default_connector_id": default_connector_id,
         "default_rfid": default_rfid,
         "default_vins": default_vins,
         "params_jsons": params_jsons,
@@ -209,46 +540,218 @@ def cp_simulator(request):
     return render(request, "ocpp/cp_simulator.html", context)
 
 
-def charger_page(request, cid):
+def charger_page(request, cid, connector=None):
     """Public landing page for a charger displaying usage guidance or progress."""
-    charger = get_object_or_404(Charger, charger_id=cid)
-    tx = store.transactions.get(cid)
-    return render(request, "ocpp/charger_page.html", {"charger": charger, "tx": tx})
+    charger, connector_slug = _get_charger(cid, connector)
+    overview = _connector_overview(charger)
+    sessions = _live_sessions(charger)
+    tx = None
+    active_connector_count = 0
+    if charger.connector_id is None:
+        if sessions:
+            total_kw = 0.0
+            start_times = [
+                tx_obj.start_time for _, tx_obj in sessions if tx_obj.start_time
+            ]
+            for _, tx_obj in sessions:
+                if tx_obj.kw:
+                    total_kw += tx_obj.kw
+            tx = SimpleNamespace(
+                kw=total_kw, start_time=min(start_times) if start_times else None
+            )
+            active_connector_count = len(sessions)
+    else:
+        tx = (
+            sessions[0][1]
+            if sessions
+            else store.get_transaction(cid, charger.connector_id)
+        )
+        if tx:
+            active_connector_count = 1
+    state_source = tx if charger.connector_id is not None else (sessions if sessions else None)
+    state, color = _charger_state(charger, state_source)
+    language_cookie = request.COOKIES.get(settings.LANGUAGE_COOKIE_NAME)
+    preferred_language = "es"
+    supported_languages = {code for code, _ in settings.LANGUAGES}
+    if preferred_language in supported_languages and not language_cookie:
+        translation.activate(preferred_language)
+        request.LANGUAGE_CODE = translation.get_language()
+    connector_links = [
+        {
+            "slug": item["slug"],
+            "label": item["label"],
+            "url": item["url"],
+            "active": item["slug"] == connector_slug,
+        }
+        for item in overview
+    ]
+    connector_overview = [
+        item for item in overview if item["charger"].connector_id is not None
+    ]
+    status_url = _reverse_connector_url("charger-status", cid, connector_slug)
+    return render(
+        request,
+        "ocpp/charger_page.html",
+        {
+            "charger": charger,
+            "tx": tx,
+            "connector_slug": connector_slug,
+            "connector_links": connector_links,
+            "connector_overview": connector_overview,
+            "active_connector_count": active_connector_count,
+            "status_url": status_url,
+            "landing_translations": _landing_page_translations(),
+            "state": state,
+            "color": color,
+        },
+    )
 
 
 @login_required
-def charger_status(request, cid):
-    charger = get_object_or_404(Charger, charger_id=cid)
+def charger_status(request, cid, connector=None):
+    charger, connector_slug = _get_charger(cid, connector)
     session_id = request.GET.get("session")
-    live_tx = store.transactions.get(cid)
+    sessions = _live_sessions(charger)
+    live_tx = None
+    if charger.connector_id is not None and sessions:
+        live_tx = sessions[0][1]
     tx_obj = live_tx
     past_session = False
     if session_id:
-        if not (live_tx and str(live_tx.pk) == session_id):
+        if charger.connector_id is None:
+            tx_obj = get_object_or_404(
+                Transaction, pk=session_id, charger__charger_id=cid
+            )
+            past_session = True
+        elif not (live_tx and str(live_tx.pk) == session_id):
             tx_obj = get_object_or_404(Transaction, pk=session_id, charger=charger)
             past_session = True
-    state, color = _charger_state(charger, live_tx)
-    transactions_qs = Transaction.objects.filter(charger=charger).order_by("-start_time")
+    state, color = _charger_state(
+        charger,
+        (
+            live_tx
+            if charger.connector_id is not None
+            else (sessions if sessions else None)
+        ),
+    )
+    if charger.connector_id is None:
+        transactions_qs = (
+            Transaction.objects.filter(charger__charger_id=cid)
+            .select_related("charger")
+            .order_by("-start_time")
+        )
+    else:
+        transactions_qs = Transaction.objects.filter(charger=charger).order_by(
+            "-start_time"
+        )
     paginator = Paginator(transactions_qs, 10)
     page_obj = paginator.get_page(request.GET.get("page"))
     transactions = page_obj.object_list
-    chart_data = {"labels": [], "values": []}
-    if tx_obj:
-        total = 0.0
-        readings = tx_obj.meter_readings.filter(
-            measurand__in=["", "Energy.Active.Import.Register"]
-        ).order_by("timestamp")
+    chart_data = {"labels": [], "datasets": []}
+
+    def _series_from_transaction(tx):
+        points: list[tuple[str, float]] = []
+        readings = list(
+            tx.meter_values.filter(energy__isnull=False).order_by("timestamp")
+        )
+        start_val = None
+        if tx.meter_start is not None:
+            start_val = float(tx.meter_start) / 1000.0
         for reading in readings:
             try:
-                val = float(reading.value)
+                val = float(reading.energy)
             except (TypeError, ValueError):
                 continue
-            if reading.unit == "kW":
-                total += val
-            else:
-                total += val / 1000.0
-            chart_data["labels"].append(reading.timestamp.isoformat())
-            chart_data["values"].append(total)
+            if start_val is None:
+                start_val = val
+            total = val - start_val
+            points.append((reading.timestamp.isoformat(), max(total, 0.0)))
+        return points
+
+    if tx_obj and (charger.connector_id is not None or past_session):
+        series_points = _series_from_transaction(tx_obj)
+        if series_points:
+            chart_data["labels"] = [ts for ts, _ in series_points]
+            connector_id = None
+            if tx_obj.charger and tx_obj.charger.connector_id is not None:
+                connector_id = tx_obj.charger.connector_id
+            elif charger.connector_id is not None:
+                connector_id = charger.connector_id
+            chart_data["datasets"].append(
+                {
+                    "label": str(
+                        tx_obj.charger.connector_label
+                        if tx_obj.charger and tx_obj.charger.connector_id is not None
+                        else charger.connector_label
+                    ),
+                    "values": [value for _, value in series_points],
+                    "connector_id": connector_id,
+                }
+            )
+    elif charger.connector_id is None:
+        dataset_points: list[tuple[str, list[tuple[str, float]], int]] = []
+        for sibling, sibling_tx in sessions:
+            if sibling.connector_id is None or not sibling_tx:
+                continue
+            points = _series_from_transaction(sibling_tx)
+            if not points:
+                continue
+            dataset_points.append(
+                (str(sibling.connector_label), points, sibling.connector_id)
+            )
+        if dataset_points:
+            all_labels: list[str] = sorted(
+                {ts for _, points, _ in dataset_points for ts, _ in points}
+            )
+            chart_data["labels"] = all_labels
+            for label, points, connector_id in dataset_points:
+                value_map = {ts: val for ts, val in points}
+                chart_data["datasets"].append(
+                    {
+                        "label": label,
+                        "values": [value_map.get(ts) for ts in all_labels],
+                        "connector_id": connector_id,
+                    }
+                )
+    overview = _connector_overview(charger)
+    connector_links = [
+        {
+            "slug": item["slug"],
+            "label": item["label"],
+            "url": _reverse_connector_url("charger-status", cid, item["slug"]),
+            "active": item["slug"] == connector_slug,
+        }
+        for item in overview
+    ]
+    connector_overview = [
+        item for item in overview if item["charger"].connector_id is not None
+    ]
+    search_url = _reverse_connector_url("charger-session-search", cid, connector_slug)
+    configuration_url = None
+    if request.user.is_staff:
+        try:
+            configuration_url = reverse("admin:ocpp_charger_change", args=[charger.pk])
+        except NoReverseMatch:  # pragma: no cover - admin may be disabled
+            configuration_url = None
+    is_connected = store.is_connected(cid, charger.connector_id)
+    has_active_session = bool(
+        live_tx if charger.connector_id is not None else sessions
+    )
+    can_remote_start = (
+        charger.connector_id is not None
+        and is_connected
+        and not has_active_session
+        and not past_session
+    )
+    remote_start_messages = None
+    if can_remote_start:
+        remote_start_messages = {
+            "required": str(_("RFID is required to start a session.")),
+            "sending": str(_("Sending remote start request...")),
+            "success": str(_("Remote start command queued.")),
+            "error": str(_("Unable to send remote start request.")),
+        }
+    action_url = _reverse_connector_url("charger-action", cid, connector_slug)
     return render(
         request,
         "ocpp/charger_status.html",
@@ -259,79 +762,122 @@ def charger_status(request, cid):
             "color": color,
             "transactions": transactions,
             "page_obj": page_obj,
-            "chart_data": json.dumps(chart_data),
+            "chart_data": chart_data,
             "past_session": past_session,
+            "connector_slug": connector_slug,
+            "connector_links": connector_links,
+            "connector_overview": connector_overview,
+            "search_url": search_url,
+            "configuration_url": configuration_url,
+            "page_url": _reverse_connector_url("charger-page", cid, connector_slug),
+            "is_connected": is_connected,
+            "is_idle": is_connected and not has_active_session,
+            "can_remote_start": can_remote_start,
+            "remote_start_messages": remote_start_messages,
+            "action_url": action_url,
+            "show_chart": bool(
+                chart_data["datasets"]
+                and any(
+                    any(value is not None for value in dataset["values"])
+                    for dataset in chart_data["datasets"]
+                )
+            ),
         },
     )
 
 
 @login_required
-def charger_session_search(request, cid):
-    charger = get_object_or_404(Charger, charger_id=cid)
+def charger_session_search(request, cid, connector=None):
+    charger, connector_slug = _get_charger(cid, connector)
     date_str = request.GET.get("date")
     transactions = None
     if date_str:
         try:
             date_obj = datetime.strptime(date_str, "%Y-%m-%d").date()
-            start = datetime.combine(date_obj, datetime.min.time(), tzinfo=dt_timezone.utc)
-            end = start + timedelta(days=1)
-            transactions = (
-                Transaction.objects.filter(
-                    charger=charger, start_time__gte=start, start_time__lt=end
-                ).order_by("-start_time")
+            start = datetime.combine(
+                date_obj, datetime.min.time(), tzinfo=dt_timezone.utc
             )
+            end = start + timedelta(days=1)
+            qs = Transaction.objects.filter(start_time__gte=start, start_time__lt=end)
+            if charger.connector_id is None:
+                qs = qs.filter(charger__charger_id=cid)
+            else:
+                qs = qs.filter(charger=charger)
+            transactions = qs.order_by("-start_time")
         except ValueError:
             transactions = []
+    overview = _connector_overview(charger)
+    connector_links = [
+        {
+            "slug": item["slug"],
+            "label": item["label"],
+            "url": _reverse_connector_url("charger-session-search", cid, item["slug"]),
+            "active": item["slug"] == connector_slug,
+        }
+        for item in overview
+    ]
+    status_url = _reverse_connector_url("charger-status", cid, connector_slug)
     return render(
         request,
         "ocpp/charger_session_search.html",
-        {"charger": charger, "transactions": transactions, "date": date_str},
+        {
+            "charger": charger,
+            "transactions": transactions,
+            "date": date_str,
+            "connector_slug": connector_slug,
+            "connector_links": connector_links,
+            "status_url": status_url,
+        },
     )
 
 
 @login_required
-def charger_log_page(request, cid):
+def charger_log_page(request, cid, connector=None):
     """Render a simple page with the log for the charger or simulator."""
     log_type = request.GET.get("type", "charger")
-    try:
-        charger = Charger.objects.get(charger_id=cid)
-    except Charger.DoesNotExist:
-        charger = Charger(charger_id=cid)
-    log = store.get_logs(cid, log_type=log_type)
+    connector_links = []
+    connector_slug = None
+    status_url = None
+    if log_type == "charger":
+        charger, connector_slug = _get_charger(cid, connector)
+        log_key = store.identity_key(cid, charger.connector_id)
+        overview = _connector_overview(charger)
+        connector_links = [
+            {
+                "slug": item["slug"],
+                "label": item["label"],
+                "url": _reverse_connector_url("charger-log", cid, item["slug"]),
+                "active": item["slug"] == connector_slug,
+            }
+            for item in overview
+        ]
+        target_id = log_key
+        status_url = _reverse_connector_url("charger-status", cid, connector_slug)
+    else:
+        charger = Charger.objects.filter(charger_id=cid).first() or Charger(
+            charger_id=cid
+        )
+        target_id = cid
+    log = store.get_logs(target_id, log_type=log_type)
     return render(
         request,
         "ocpp/charger_logs.html",
-        {"charger": charger, "log": log},
+        {
+            "charger": charger,
+            "log": log,
+            "log_type": log_type,
+            "connector_slug": connector_slug,
+            "connector_links": connector_links,
+            "status_url": status_url,
+        },
     )
 
 
-@login_required
-@landing("EV Efficiency")
-def efficiency_calculator(request):
-    """Simple EV efficiency calculator."""
-    form = {k: v for k, v in (request.POST or request.GET).items() if v not in (None, "")}
-    context: dict[str, object] = {"form": form}
-    if request.method == "POST":
-        try:
-            distance = float(request.POST.get("distance"))
-            energy = float(request.POST.get("energy"))
-            if distance <= 0 or energy <= 0:
-                raise ValueError
-        except (TypeError, ValueError):
-            context["error"] = _("Invalid input values")
-        else:
-            km_per_kwh = distance / energy
-            wh_per_km = (energy * 1000) / distance
-            context["result"] = {
-                "km_per_kwh": km_per_kwh,
-                "wh_per_km": wh_per_km,
-            }
-    return render(request, "ocpp/efficiency_calculator.html", context)
-
 @csrf_exempt
 @api_login_required
-def dispatch_action(request, cid):
-    ws = store.connections.get(cid)
+def dispatch_action(request, cid, connector=None):
+    connector_value, _ = _normalize_connector_slug(connector)
+    ws = store.get_connection(cid, connector_value)
     if ws is None:
         return JsonResponse({"detail": "no connection"}, status=404)
     try:
@@ -340,20 +886,52 @@ def dispatch_action(request, cid):
         data = {}
     action = data.get("action")
     if action == "remote_stop":
-        tx_obj = store.transactions.get(cid)
+        tx_obj = store.get_transaction(cid, connector_value)
         if not tx_obj:
             return JsonResponse({"detail": "no transaction"}, status=404)
-        msg = json.dumps([
-            2,
-            str(datetime.utcnow().timestamp()),
-            "RemoteStopTransaction",
-            {"transactionId": tx_obj.pk},
-        ])
+        msg = json.dumps(
+            [
+                2,
+                str(datetime.utcnow().timestamp()),
+                "RemoteStopTransaction",
+                {"transactionId": tx_obj.pk},
+            ]
+        )
+        asyncio.get_event_loop().create_task(ws.send(msg))
+    elif action == "remote_start":
+        id_tag = data.get("idTag")
+        if not isinstance(id_tag, str) or not id_tag.strip():
+            return JsonResponse({"detail": "idTag required"}, status=400)
+        id_tag = id_tag.strip()
+        payload: dict[str, object] = {"idTag": id_tag}
+        connector_id = data.get("connectorId")
+        if connector_id in ("", None):
+            connector_id = None
+        if connector_id is None and connector_value is not None:
+            connector_id = connector_value
+        if connector_id is not None:
+            try:
+                payload["connectorId"] = int(connector_id)
+            except (TypeError, ValueError):
+                payload["connectorId"] = connector_id
+        if "chargingProfile" in data and data["chargingProfile"] is not None:
+            payload["chargingProfile"] = data["chargingProfile"]
+        msg = json.dumps(
+            [
+                2,
+                str(datetime.utcnow().timestamp()),
+                "RemoteStartTransaction",
+                payload,
+            ]
+        )
         asyncio.get_event_loop().create_task(ws.send(msg))
     elif action == "reset":
-        msg = json.dumps([2, str(datetime.utcnow().timestamp()), "Reset", {"type": "Soft"}])
+        msg = json.dumps(
+            [2, str(datetime.utcnow().timestamp()), "Reset", {"type": "Soft"}]
+        )
         asyncio.get_event_loop().create_task(ws.send(msg))
     else:
         return JsonResponse({"detail": "unknown action"}, status=400)
-    store.add_log(cid, f"< {msg}", log_type="charger")
+    log_key = store.identity_key(cid, connector_value)
+    store.add_log(log_key, f"< {msg}", log_type="charger")
     return JsonResponse({"sent": msg})