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

ocpp/views.py

@@ -1,12 +1,13 @@
 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
@@ -14,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
@@ -26,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 (
@@ -336,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."""
 
@@ -752,8 +1021,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,17 +1070,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,
+        "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)
 
 
@@ -1132,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:
@@ -1198,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,
         },
     )
 

pages/admin.py

@@ -595,7 +595,23 @@ class ViewHistoryAdmin(EntityModelAdmin):
         )
 
     def traffic_data_view(self, request):
-        return JsonResponse(self._build_chart_data())
+        return JsonResponse(
+            self._build_chart_data(days=self._resolve_requested_days(request))
+        )
+
+    def _resolve_requested_days(self, request, default: int = 30) -> int:
+        raw_value = request.GET.get("days")
+        if raw_value in (None, ""):
+            return default
+
+        try:
+            days = int(raw_value)
+        except (TypeError, ValueError):
+            return default
+
+        minimum = 1
+        maximum = 90
+        return max(minimum, min(days, maximum))
 
     def _build_chart_data(self, days: int = 30, max_pages: int = 8) -> dict:
         end_date = timezone.localdate()
@@ -689,11 +705,13 @@ class UserStoryAdmin(EntityModelAdmin):
     actions = ["create_github_issues"]
     list_display = (
         "name",
+        "language_code",
         "rating",
         "path",
         "status",
         "submitted_at",
         "github_issue_display",
+        "screenshot_display",
         "take_screenshot",
         "owner",
         "assign_to",
@@ -703,6 +721,7 @@ class UserStoryAdmin(EntityModelAdmin):
         "name",
         "comments",
         "path",
+        "language_code",
         "referer",
         "github_issue_url",
         "ip_address",
@@ -715,6 +734,7 @@ class UserStoryAdmin(EntityModelAdmin):
         "path",
         "user",
         "owner",
+        "language_code",
         "referer",
         "user_agent",
         "ip_address",
@@ -722,6 +742,7 @@ class UserStoryAdmin(EntityModelAdmin):
         "submitted_at",
         "github_issue_number",
         "github_issue_url",
+        "screenshot_display",
     )
     ordering = ("-submitted_at",)
     fields = (
@@ -729,7 +750,9 @@ class UserStoryAdmin(EntityModelAdmin):
         "rating",
         "comments",
         "take_screenshot",
+        "screenshot_display",
         "path",
+        "language_code",
         "user",
         "owner",
         "status",
@@ -758,6 +781,21 @@ class UserStoryAdmin(EntityModelAdmin):
             )
         if obj.github_issue_number is not None:
             return f"#{obj.github_issue_number}"
+        return ""
+
+    @admin.display(description=_("Screenshot"), ordering="screenshot")
+    def screenshot_display(self, obj):
+        if not obj.screenshot_id:
+            return ""
+        try:
+            url = reverse("admin:nodes_contentsample_change", args=[obj.screenshot_id])
+        except NoReverseMatch:
+            return obj.screenshot.path
+        return format_html(
+            '<a href="{}" target="_blank" rel="noopener noreferrer">{}</a>',
+            url,
+            _("View screenshot"),
+        )
         return _("Not created")
 
     @admin.action(description=_("Create GitHub issues"))
@@ -842,34 +880,93 @@ def favorite_toggle(request, ct_id):
     ct = get_object_or_404(ContentType, pk=ct_id)
     fav = Favorite.objects.filter(user=request.user, content_type=ct).first()
     next_url = request.GET.get("next")
-    if fav:
-        return redirect(next_url or "admin:favorite_list")
     if request.method == "POST":
+        if fav and request.POST.get("remove"):
+            fav.delete()
+            return redirect(next_url or "admin:index")
         label = request.POST.get("custom_label", "").strip()
         user_data = request.POST.get("user_data") == "on"
-        Favorite.objects.create(
-            user=request.user,
-            content_type=ct,
-            custom_label=label,
-            user_data=user_data,
-        )
+        priority_raw = request.POST.get("priority", "").strip()
+        if fav:
+            default_priority = fav.priority
+        else:
+            default_priority = 0
+        if priority_raw:
+            try:
+                priority = int(priority_raw)
+            except (TypeError, ValueError):
+                priority = default_priority
+        else:
+            priority = default_priority
+
+        if fav:
+            update_fields = []
+            if fav.custom_label != label:
+                fav.custom_label = label
+                update_fields.append("custom_label")
+            if fav.user_data != user_data:
+                fav.user_data = user_data
+                update_fields.append("user_data")
+            if fav.priority != priority:
+                fav.priority = priority
+                update_fields.append("priority")
+            if update_fields:
+                fav.save(update_fields=update_fields)
+        else:
+            Favorite.objects.create(
+                user=request.user,
+                content_type=ct,
+                custom_label=label,
+                user_data=user_data,
+                priority=priority,
+            )
         return redirect(next_url or "admin:index")
     return render(
         request,
         "admin/favorite_confirm.html",
-        {"content_type": ct, "next": next_url},
+        {
+            "content_type": ct,
+            "favorite": fav,
+            "next": next_url,
+            "initial_label": fav.custom_label if fav else "",
+            "initial_priority": fav.priority if fav else 0,
+            "is_checked": fav.user_data if fav else True,
+        },
     )
 
 
 def favorite_list(request):
-    favorites = Favorite.objects.filter(user=request.user).select_related(
-        "content_type"
+    favorites = (
+        Favorite.objects.filter(user=request.user)
+        .select_related("content_type")
+        .order_by("priority", "pk")
     )
     if request.method == "POST":
-        selected = request.POST.getlist("user_data")
+        selected = set(request.POST.getlist("user_data"))
         for fav in favorites:
-            fav.user_data = str(fav.pk) in selected
-            fav.save(update_fields=["user_data"])
+            update_fields = []
+            user_selected = str(fav.pk) in selected
+            if fav.user_data != user_selected:
+                fav.user_data = user_selected
+                update_fields.append("user_data")
+
+            priority_raw = request.POST.get(f"priority_{fav.pk}", "").strip()
+            if priority_raw:
+                try:
+                    priority = int(priority_raw)
+                except (TypeError, ValueError):
+                    priority = fav.priority
+                else:
+                    if fav.priority != priority:
+                        fav.priority = priority
+                        update_fields.append("priority")
+            else:
+                if fav.priority != 0:
+                    fav.priority = 0
+                    update_fields.append("priority")
+
+            if update_fields:
+                fav.save(update_fields=update_fields)
         return redirect("admin:favorite_list")
     return render(request, "admin/favorite_list.html", {"favorites": favorites})
 

pages/apps.py

@@ -1,13 +1,45 @@
+import logging
+
 from django.apps import AppConfig
+from django.db import DatabaseError
+from django.db.backends.signals import connection_created
+
+
+logger = logging.getLogger(__name__)
 
 
 class PagesConfig(AppConfig):
     default_auto_field = "django.db.models.BigAutoField"
     name = "pages"
     verbose_name = "7. Experience"
+    _view_history_purged = False
 
     def ready(self):  # pragma: no cover - import for side effects
         from . import checks  # noqa: F401
         from . import site_config
 
         site_config.ready()
+        connection_created.connect(
+            self._handle_connection_created,
+            dispatch_uid="pages_view_history_connection_created",
+            weak=False,
+        )
+
+    def _handle_connection_created(self, sender, connection, **kwargs):
+        if self._view_history_purged:
+            return
+        self._view_history_purged = True
+        self._purge_view_history()
+
+    def _purge_view_history(self, days: int = 15) -> None:
+        """Remove stale :class:`pages.models.ViewHistory` entries."""
+
+        from .models import ViewHistory
+
+        try:
+            deleted = ViewHistory.purge_older_than(days=days)
+        except DatabaseError:
+            logger.debug("Skipping view history purge; database unavailable", exc_info=True)
+        else:
+            if deleted:
+                logger.info("Purged %s view history entries older than %s days", deleted, days)