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

ocpp/views.py

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

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)

pages/forms.py

@@ -171,15 +171,35 @@ class UserStoryForm(forms.ModelForm):
             "comments": forms.Textarea(attrs={"rows": 4, "maxlength": 400}),
         }
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, user=None, **kwargs):
+        self.user = user
         super().__init__(*args, **kwargs)
-        self.fields["name"].required = False
-        self.fields["name"].widget.attrs.update(
-            {
-                "maxlength": 40,
-                "placeholder": _("Name, email or pseudonym"),
-            }
-        )
+
+        if user is not None and user.is_authenticated:
+            name_field = self.fields["name"]
+            name_field.required = False
+            name_field.label = _("Username")
+            name_field.initial = (user.get_username() or "")[:40]
+            name_field.widget.attrs.update(
+                {
+                    "maxlength": 40,
+                    "readonly": "readonly",
+                }
+            )
+        else:
+            self.fields["name"] = forms.EmailField(
+                label=_("Email address"),
+                max_length=40,
+                required=True,
+                widget=forms.EmailInput(
+                    attrs={
+                        "maxlength": 40,
+                        "placeholder": _("name@example.com"),
+                        "autocomplete": "email",
+                        "inputmode": "email",
+                    }
+                ),
+            )
         self.fields["take_screenshot"].initial = True
         self.fields["rating"].widget = forms.RadioSelect(
             choices=[(i, str(i)) for i in range(1, 6)]
@@ -194,5 +214,8 @@ class UserStoryForm(forms.ModelForm):
         return comments
 
     def clean_name(self):
+        if self.user is not None and self.user.is_authenticated:
+            return (self.user.get_username() or "")[:40]
+
         name = (self.cleaned_data.get("name") or "").strip()
         return name[:40]