arthexis 0.1.16__py3-none-any.whl → 0.1.26__py3-none-any.whl

ocpp/views.py

@@ -1,19 +1,21 @@
 import json
 import uuid
-from datetime import datetime, timedelta, timezone as dt_timezone
+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
 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
@@ -25,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 (
@@ -43,6 +47,7 @@ CALL_ACTION_LABELS = {
     "DataTransfer": _("Data transfer"),
     "Reset": _("Reset"),
     "TriggerMessage": _("Trigger message"),
+    "ReserveNow": _("Reserve connector"),
 }
 
 CALL_EXPECTED_STATUSES: dict[str, set[str]] = {
@@ -52,6 +57,7 @@ CALL_EXPECTED_STATUSES: dict[str, set[str]] = {
     "DataTransfer": {"Accepted"},
     "Reset": {"Accepted"},
     "TriggerMessage": {"Accepted"},
+    "ReserveNow": {"Accepted"},
 }
 
 
@@ -223,24 +229,75 @@ def _transaction_rfid_details(
     if not tx_obj:
         return None
     rfid_value = getattr(tx_obj, "rfid", None)
-    if not rfid_value:
-        return None
-    normalized = str(rfid_value).strip()
-    if not normalized:
+    normalized = str(rfid_value or "").strip().upper()
+    cache_key = normalized
+    if normalized:
+        if cache is not None and cache_key in cache:
+            return cache[cache_key]
+        tag = (
+            RFID.matching_queryset(normalized)
+            .only("pk", "label_id", "custom_label")
+            .first()
+        )
+        rfid_url = None
+        label_value = None
+        canonical_value = normalized
+        if tag:
+            try:
+                rfid_url = reverse("admin:core_rfid_change", args=[tag.pk])
+            except NoReverseMatch:  # pragma: no cover - admin may be disabled
+                rfid_url = None
+            custom_label = (tag.custom_label or "").strip()
+            if custom_label:
+                label_value = custom_label
+            elif tag.label_id is not None:
+                label_value = str(tag.label_id)
+            canonical_value = tag.rfid or canonical_value
+        display_value = label_value or canonical_value
+        details = {
+            "value": display_value,
+            "url": rfid_url,
+            "uid": canonical_value,
+            "type": "rfid",
+            "display_label": gettext("RFID"),
+        }
+        if label_value:
+            details["label"] = label_value
+        if cache is not None:
+            cache[cache_key] = details
+        return details
+
+    identifier_value = getattr(tx_obj, "vehicle_identifier", None)
+    normalized_identifier = str(identifier_value or "").strip()
+    if not normalized_identifier:
+        vid_value = getattr(tx_obj, "vid", None)
+        vin_value = getattr(tx_obj, "vin", None)
+        normalized_identifier = str(vid_value or vin_value or "").strip()
+    if not normalized_identifier:
         return None
-    normalized = normalized.upper()
-    if cache is not None and normalized in cache:
-        return cache[normalized]
-    tag = RFID.objects.filter(rfid=normalized).only("pk").first()
-    rfid_url = None
-    if tag:
-        try:
-            rfid_url = reverse("admin:core_rfid_change", args=[tag.pk])
-        except NoReverseMatch:  # pragma: no cover - admin may be disabled
-            rfid_url = None
-    details = {"value": normalized, "url": rfid_url}
+    source = getattr(tx_obj, "vehicle_identifier_source", "") or "vid"
+    if source not in {"vid", "vin"}:
+        vid_raw = getattr(tx_obj, "vid", None)
+        vin_raw = getattr(tx_obj, "vin", None)
+        if str(vid_raw or "").strip():
+            source = "vid"
+        elif str(vin_raw or "").strip():
+            source = "vin"
+        else:
+            source = "vid"
+    cache_key = f"{source}:{normalized_identifier}"
+    if cache is not None and cache_key in cache:
+        return cache[cache_key]
+    label = gettext("VID") if source == "vid" else gettext("VIN")
+    details = {
+        "value": normalized_identifier,
+        "url": None,
+        "uid": None,
+        "type": source,
+        "display_label": label,
+    }
     if cache is not None:
-        cache[normalized] = details
+        cache[cache_key] = details
     return details
 
 
@@ -284,6 +341,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."""
 
@@ -309,9 +632,14 @@ 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] = {
+    seen_codes: set[str] = set()
+    for code, _name in settings.LANGUAGES:
+        normalized = str(code).strip()
+        if not normalized or normalized in seen_codes:
+            continue
+        seen_codes.add(normalized)
+        with translation.override(normalized):
+            catalog[normalized] = {
                 "serial_number_label": gettext("Serial Number"),
                 "connector_label": gettext("Connector"),
                 "advanced_view_label": gettext("Advanced View"),
@@ -370,10 +698,6 @@ def _aggregate_dashboard_state(charger: Charger) -> tuple[str, str] | None:
     )
     statuses: list[str] = []
     for sibling in siblings:
-        status_value = (sibling.last_status or "").strip()
-        if status_value:
-            statuses.append(status_value.casefold())
-            continue
         tx_obj = store.get_transaction(sibling.charger_id, sibling.connector_id)
         if not tx_obj:
             tx_obj = (
@@ -381,9 +705,22 @@ def _aggregate_dashboard_state(charger: Charger) -> tuple[str, str] | None:
                 .order_by("-start_time")
                 .first()
             )
-        if _has_active_session(tx_obj):
+        has_session = _has_active_session(tx_obj)
+        status_value = (sibling.last_status or "").strip()
+        normalized_status = status_value.casefold() if status_value else ""
+        error_code_lower = (sibling.last_error_code or "").strip().lower()
+        if has_session:
             statuses.append("charging")
             continue
+        if (
+            normalized_status in {"charging", "finishing"}
+            and error_code_lower in ERROR_OK_VALUES
+        ):
+            statuses.append("available")
+            continue
+        if normalized_status:
+            statuses.append(normalized_status)
+            continue
         if store.is_connected(sibling.charger_id, sibling.connector_id):
             statuses.append("available")
 
@@ -424,6 +761,15 @@ def _charger_state(charger: Charger, tx_obj: Transaction | list | None):
             # while a session is active. Override the badge so the user can see
             # the charger is actually busy.
             label, color = STATUS_BADGE_MAP.get("charging", (_("Charging"), "#198754"))
+        elif (
+            not has_session
+            and key in {"charging", "finishing"}
+            and error_code_lower in ERROR_OK_VALUES
+        ):
+            # Some chargers continue reporting "Charging" after a session ends.
+            # When no active transaction exists, surface the state as available
+            # so the UI reflects the actual behaviour at the site.
+            label, color = STATUS_BADGE_MAP.get("available", (_("Available"), "#0d6efd"))
         elif error_code and error_code_lower not in ERROR_OK_VALUES:
             label = _("%(status)s (%(error)s)") % {
                 "status": label,
@@ -485,8 +831,12 @@ def charger_list(request):
                 "meterStart": tx_obj.meter_start,
                 "startTime": tx_obj.start_time.isoformat(),
             }
-            if tx_obj.vin:
-                tx_data["vin"] = tx_obj.vin
+            identifier = str(getattr(tx_obj, "vehicle_identifier", "") or "").strip()
+            if identifier:
+                tx_data["vid"] = identifier
+            legacy_vin = str(getattr(tx_obj, "vin", "") or "").strip()
+            if legacy_vin:
+                tx_data["vin"] = legacy_vin
             if tx_obj.meter_stop is not None:
                 tx_data["meterStop"] = tx_obj.meter_stop
             if tx_obj.stop_time is not None:
@@ -501,8 +851,12 @@ def charger_list(request):
                 "meterStart": session_tx.meter_start,
                 "startTime": session_tx.start_time.isoformat(),
             }
-            if session_tx.vin:
-                active_payload["vin"] = session_tx.vin
+            identifier = str(getattr(session_tx, "vehicle_identifier", "") or "").strip()
+            if identifier:
+                active_payload["vid"] = identifier
+            legacy_vin = str(getattr(session_tx, "vin", "") or "").strip()
+            if legacy_vin:
+                active_payload["vin"] = legacy_vin
             if session_tx.meter_stop is not None:
                 active_payload["meterStop"] = session_tx.meter_stop
             if session_tx.stop_time is not None:
@@ -582,8 +936,12 @@ def charger_detail(request, cid, connector=None):
             "meterStart": tx_obj.meter_start,
             "startTime": tx_obj.start_time.isoformat(),
         }
-        if tx_obj.vin:
-            tx_data["vin"] = tx_obj.vin
+        identifier = str(getattr(tx_obj, "vehicle_identifier", "") or "").strip()
+        if identifier:
+            tx_data["vid"] = identifier
+        legacy_vin = str(getattr(tx_obj, "vin", "") or "").strip()
+        if legacy_vin:
+            tx_data["vin"] = legacy_vin
         if tx_obj.meter_stop is not None:
             tx_data["meterStop"] = tx_obj.meter_stop
         if tx_obj.stop_time is not None:
@@ -599,8 +957,12 @@ def charger_detail(request, cid, connector=None):
             "meterStart": session_tx.meter_start,
             "startTime": session_tx.start_time.isoformat(),
         }
-        if session_tx.vin:
-            payload["vin"] = session_tx.vin
+        identifier = str(getattr(session_tx, "vehicle_identifier", "") or "").strip()
+        if identifier:
+            payload["vid"] = identifier
+        legacy_vin = str(getattr(session_tx, "vin", "") or "").strip()
+        if legacy_vin:
+            payload["vin"] = legacy_vin
         if session_tx.meter_stop is not None:
             payload["meterStop"] = session_tx.meter_stop
         if session_tx.stop_time is not None:
@@ -655,14 +1017,54 @@ def dashboard(request):
     node = Node.get_local()
     role = node.role if node else None
     role_name = role.name if role else ""
-    allow_anonymous_roles = {"Constellation", "Satellite"}
+    allow_anonymous_roles = {"Watchtower", "Constellation", "Satellite"}
     if not request.user.is_authenticated and role_name not in allow_anonymous_roles:
         return redirect_to_login(
             request.get_full_path(), login_url=reverse("pages:login")
         )
-    is_constellation = role_name == "Constellation"
-    chargers = []
-    for charger in _visible_chargers(request.user):
+    is_watchtower = role_name in {"Watchtower", "Constellation"}
+    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 = (
@@ -670,17 +1072,63 @@ 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,
-        "show_demo_notice": is_constellation,
+        "charger_groups": charger_groups,
+        "show_demo_notice": is_watchtower,
         "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)
 
 
@@ -824,11 +1272,30 @@ def charger_page(request, cid, connector=None):
     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()
+    available_languages = [
+        str(code).strip()
+        for code, _ in settings.LANGUAGES
+        if str(code).strip()
+    ]
+    supported_languages = set(available_languages)
+    charger_language = (charger.language or "es").strip()
+    if charger_language not in supported_languages:
+        fallback = "es" if "es" in supported_languages else ""
+        if not fallback and available_languages:
+            fallback = available_languages[0]
+        charger_language = fallback
+    if (
+        charger_language
+        and (
+            not language_cookie
+            or language_cookie not in supported_languages
+            or language_cookie != charger_language
+        )
+    ):
+        translation.activate(charger_language)
+    current_language = translation.get_language()
+    request.LANGUAGE_CODE = current_language
+    preferred_language = charger_language or current_language
     connector_links = [
         {
             "slug": item["slug"],
@@ -856,6 +1323,7 @@ def charger_page(request, cid, connector=None):
             "active_connector_count": active_connector_count,
             "status_url": status_url,
             "landing_translations": _landing_page_translations(),
+            "preferred_language": preferred_language,
             "state": state,
             "color": color,
         },
@@ -1005,7 +1473,10 @@ def charger_status(request, cid, connector=None):
                         "connector_id": connector_id,
                     }
                 )
-    overview = _connector_overview(charger, request.user)
+    rfid_cache: dict[str, dict[str, str | None]] = {}
+    overview = _connector_overview(
+        charger, request.user, rfid_cache=rfid_cache
+    )
     connector_links = [
         {
             "slug": item["slug"],
@@ -1018,6 +1489,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:
@@ -1046,12 +1520,15 @@ def charger_status(request, cid, connector=None):
     action_url = _reverse_connector_url("charger-action", cid, connector_slug)
     chart_should_animate = bool(has_active_session and not past_session)
 
+    tx_rfid_details = _transaction_rfid_details(tx_obj, cache=rfid_cache)
+
     return render(
         request,
         "ocpp/charger_status.html",
         {
             "charger": charger,
             "tx": tx_obj,
+            "tx_rfid_details": tx_rfid_details,
             "state": state,
             "color": color,
             "transactions": transactions,
@@ -1081,6 +1558,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,
         },
     )
 
@@ -1132,6 +1611,15 @@ def charger_session_search(request, cid, connector=None):
             transactions = qs.order_by("-start_time")
         except ValueError:
             transactions = []
+    if transactions is not None:
+        transactions = list(transactions)
+        rfid_cache: dict[str, dict[str, str | None]] = {}
+        for tx in transactions:
+            details = _transaction_rfid_details(tx, cache=rfid_cache)
+            label_value = None
+            if details:
+                label_value = str(details.get("label") or "").strip() or None
+            tx.rfid_label = label_value
     overview = _connector_overview(charger, request.user)
     connector_links = [
         {
@@ -1191,17 +1679,67 @@ def charger_log_page(request, cid, connector=None):
             charger_id=cid
         )
         target_id = cid
-    log = store.get_logs(target_id, log_type=log_type)
+
+    slug_source = slugify(target_id) or slugify(cid) or "log"
+    filename_parts = [log_type, slug_source]
+    download_filename = f"{'-'.join(part for part in filename_parts if part)}.log"
+    limit_options = [
+        {"value": "20", "label": "20"},
+        {"value": "40", "label": "40"},
+        {"value": "100", "label": "100"},
+        {"value": "all", "label": gettext("All")},
+    ]
+    allowed_values = [item["value"] for item in limit_options]
+    limit_choice = request.GET.get("limit", "20")
+    if limit_choice not in allowed_values:
+        limit_choice = "20"
+    limit_index = allowed_values.index(limit_choice)
+
+    log_entries_all = list(store.get_logs(target_id, log_type=log_type) or [])
+    download_requested = request.GET.get("download") == "1"
+    if download_requested:
+        download_content = "\n".join(log_entries_all)
+        if download_content and not download_content.endswith("\n"):
+            download_content = f"{download_content}\n"
+        response = HttpResponse(download_content, content_type="text/plain; charset=utf-8")
+        response["Content-Disposition"] = f'attachment; filename="{download_filename}"'
+        return response
+
+    log_entries = log_entries_all
+    if limit_choice != "all":
+        try:
+            limit_value = int(limit_choice)
+        except (TypeError, ValueError):
+            limit_value = 20
+            limit_choice = "20"
+            limit_index = allowed_values.index(limit_choice)
+        log_entries = log_entries[-limit_value:]
+
+    download_params = request.GET.copy()
+    download_params["download"] = "1"
+    download_params.pop("limit", None)
+    download_query = download_params.urlencode()
+    log_download_url = f"{request.path}?{download_query}" if download_query else request.path
+
+    limit_label = limit_options[limit_index]["label"]
+    log_content = "\n".join(log_entries)
     return render(
         request,
         "ocpp/charger_logs.html",
         {
             "charger": charger,
-            "log": log,
+            "log": log_entries,
+            "log_content": log_content,
             "log_type": log_type,
             "connector_slug": connector_slug,
             "connector_links": connector_links,
             "status_url": status_url,
+            "log_limit_options": limit_options,
+            "log_limit_index": limit_index,
+            "log_limit_choice": limit_choice,
+            "log_limit_label": limit_label,
+            "log_download_url": log_download_url,
+            "log_filename": download_filename,
         },
     )
 
@@ -1209,7 +1747,7 @@ def charger_log_page(request, cid, connector=None):
 @csrf_exempt
 @api_login_required
 def dispatch_action(request, cid, connector=None):
-    connector_value, _ = _normalize_connector_slug(connector)
+    connector_value, _normalized_slug = _normalize_connector_slug(connector)
     log_key = store.identity_key(cid, connector_value)
     if connector_value is None:
         charger_obj = (
@@ -1225,11 +1763,11 @@ def dispatch_action(request, cid, connector=None):
         )
     if charger_obj is None:
         if connector_value is None:
-            charger_obj, _ = Charger.objects.get_or_create(
+            charger_obj, _created = Charger.objects.get_or_create(
                 charger_id=cid, connector_id=None
             )
         else:
-            charger_obj, _ = Charger.objects.get_or_create(
+            charger_obj, _created = Charger.objects.get_or_create(
                 charger_id=cid, connector_id=connector_value
             )
 
@@ -1400,6 +1938,13 @@ def dispatch_action(request, cid, connector=None):
             },
         )
     elif action == "reset":
+        tx_obj = store.get_transaction(cid, connector_value)
+        if tx_obj is not None:
+            detail = _(
+                "Reset is blocked while a charging session is active. "
+                "Stop the session first."
+            )
+            return JsonResponse({"detail": detail}, status=409)
         message_id = uuid.uuid4().hex
         ocpp_action = "Reset"
         expected_statuses = CALL_EXPECTED_STATUSES.get(ocpp_action)