arthexis 0.1.11__py3-none-any.whl → 0.1.12__py3-none-any.whl

ocpp/transactions_io.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from datetime import datetime
 from typing import Iterable
 
+from django.core.exceptions import ValidationError
 from django.utils import timezone
 from django.utils.dateparse import parse_datetime
 
@@ -107,23 +108,36 @@ def import_transactions(data: dict) -> int:
     """
     charger_map: dict[str, Charger] = {}
     for item in data.get("chargers", []):
+        try:
+            serial = Charger.validate_serial(item.get("charger_id"))
+        except ValidationError:
+            continue
         connector_value = item.get("connector_id", None)
         if connector_value in ("", None):
             connector_value = None
         elif isinstance(connector_value, str):
             connector_value = int(connector_value)
         charger, _ = Charger.objects.get_or_create(
-            charger_id=item["charger_id"],
+            charger_id=serial,
             defaults={
                 "connector_id": connector_value,
                 "require_rfid": item.get("require_rfid", False),
             },
         )
-        charger_map[item["charger_id"]] = charger
+        charger_map[serial] = charger
 
     imported = 0
     for tx in data.get("transactions", []):
-        charger = charger_map.get(tx.get("charger"))
+        serial = Charger.normalize_serial(tx.get("charger"))
+        if not serial or Charger.is_placeholder_serial(serial):
+            continue
+        charger = charger_map.get(serial)
+        if charger is None:
+            try:
+                charger, _ = Charger.objects.get_or_create(charger_id=serial)
+            except ValidationError:
+                continue
+            charger_map[serial] = charger
         transaction = Transaction.objects.create(
             charger=charger,
             account_id=tx.get("account"),

ocpp/views.py

@@ -1,5 +1,5 @@
-import asyncio
 import json
+import uuid
 from datetime import datetime, timedelta, timezone as dt_timezone
 from types import SimpleNamespace
 
@@ -13,7 +13,10 @@ 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 django.utils import translation, timezone
+from django.core.exceptions import ValidationError
+
+from asgiref.sync import async_to_sync
 
 from utils.api import api_login_required
 
@@ -23,7 +26,7 @@ from pages.utils import landing
 from core.liveupdate import live_update
 
 from . import store
-from .models import Transaction, Charger
+from .models import Transaction, Charger, DataTransferMessage
 from .evcs import (
     _start_simulator,
     _stop_simulator,
@@ -57,6 +60,10 @@ def _reverse_connector_url(name: str, serial: str, connector_slug: str) -> str:
 def _get_charger(serial: str, connector_slug: str | None) -> tuple[Charger, str]:
     """Return charger for the requested identity, creating if necessary."""
 
+    try:
+        serial = Charger.validate_serial(serial)
+    except ValidationError as exc:
+        raise Http404("Charger not found") from exc
     connector_value, normalized_slug = _normalize_connector_slug(connector_slug)
     if connector_value is None:
         charger, _ = Charger.objects.get_or_create(
@@ -79,11 +86,26 @@ def _connector_set(charger: Charger) -> list[Charger]:
     return siblings
 
 
-def _connector_overview(charger: Charger) -> list[dict]:
+def _visible_chargers(user):
+    """Return chargers visible to ``user`` on public dashboards."""
+
+    return Charger.visible_for_user(user).prefetch_related("owner_users", "owner_groups")
+
+
+def _ensure_charger_access(user, charger: Charger):
+    """Raise 404 when the user cannot view the charger."""
+
+    if not charger.is_visible_to(user):
+        raise Http404("Charger not found")
+
+
+def _connector_overview(charger: Charger, user=None) -> list[dict]:
     """Return connector metadata used for navigation and summaries."""
 
     overview: list[dict] = []
     for sibling in _connector_set(charger):
+        if user is not None and not sibling.is_visible_to(user):
+            continue
         tx_obj = store.get_transaction(sibling.charger_id, sibling.connector_id)
         state, color = _charger_state(sibling, tx_obj)
         overview.append(
@@ -232,7 +254,7 @@ def _diagnostics_payload(charger: Charger) -> dict[str, str | None]:
 def charger_list(request):
     """Return a JSON list of known chargers and state."""
     data = []
-    for charger in Charger.objects.filter(public_display=True):
+    for charger in _visible_chargers(request.user):
         cid = charger.charger_id
         sessions: list[tuple[Charger, Transaction]] = []
         tx_obj = store.get_transaction(cid, charger.connector_id)
@@ -324,6 +346,7 @@ def charger_list(request):
 @api_login_required
 def charger_detail(request, cid, connector=None):
     charger, connector_slug = _get_charger(cid, connector)
+    _ensure_charger_access(request.user, charger)
 
     sessions: list[tuple[Charger, Transaction]] = []
     tx_obj = store.get_transaction(cid, charger.connector_id)
@@ -413,7 +436,7 @@ def charger_detail(request, cid, connector=None):
     return JsonResponse(payload)
 
 
-@landing("OCPP CSMS Dashboard")
+@landing("CPMS Online Dashboard")
 @live_update()
 def dashboard(request):
     """Landing page listing all known chargers and their status."""
@@ -425,7 +448,7 @@ def dashboard(request):
             request.get_full_path(), login_url=reverse("pages:login")
         )
     chargers = []
-    for charger in Charger.objects.filter(public_display=True):
+    for charger in _visible_chargers(request.user):
         tx_obj = store.get_transaction(charger.charger_id, charger.connector_id)
         if not tx_obj:
             tx_obj = (
@@ -447,7 +470,7 @@ def dashboard(request):
     return render(request, "ocpp/dashboard.html", context)
 
 
-@login_required
+@login_required(login_url="pages:login")
 @landing("Charge Point Simulator")
 @live_update()
 def cp_simulator(request):
@@ -551,7 +574,8 @@ def cp_simulator(request):
 def charger_page(request, cid, connector=None):
     """Public landing page for a charger displaying usage guidance or progress."""
     charger, connector_slug = _get_charger(cid, connector)
-    overview = _connector_overview(charger)
+    _ensure_charger_access(request.user, charger)
+    overview = _connector_overview(charger, request.user)
     sessions = _live_sessions(charger)
     tx = None
     active_connector_count = 0
@@ -618,6 +642,7 @@ def charger_page(request, cid, connector=None):
 @login_required
 def charger_status(request, cid, connector=None):
     charger, connector_slug = _get_charger(cid, connector)
+    _ensure_charger_access(request.user, charger)
     session_id = request.GET.get("session")
     sessions = _live_sessions(charger)
     live_tx = None
@@ -721,7 +746,7 @@ def charger_status(request, cid, connector=None):
                         "connector_id": connector_id,
                     }
                 )
-    overview = _connector_overview(charger)
+    overview = _connector_overview(charger, request.user)
     connector_links = [
         {
             "slug": item["slug"],
@@ -797,6 +822,7 @@ def charger_status(request, cid, connector=None):
 @login_required
 def charger_session_search(request, cid, connector=None):
     charger, connector_slug = _get_charger(cid, connector)
+    _ensure_charger_access(request.user, charger)
     date_str = request.GET.get("date")
     transactions = None
     if date_str:
@@ -814,7 +840,7 @@ def charger_session_search(request, cid, connector=None):
             transactions = qs.order_by("-start_time")
         except ValueError:
             transactions = []
-    overview = _connector_overview(charger)
+    overview = _connector_overview(charger, request.user)
     connector_links = [
         {
             "slug": item["slug"],
@@ -848,8 +874,9 @@ def charger_log_page(request, cid, connector=None):
     status_url = None
     if log_type == "charger":
         charger, connector_slug = _get_charger(cid, connector)
+        _ensure_charger_access(request.user, charger)
         log_key = store.identity_key(cid, charger.connector_id)
-        overview = _connector_overview(charger)
+        overview = _connector_overview(charger, request.user)
         connector_links = [
             {
                 "slug": item["slug"],
@@ -885,6 +912,30 @@ def charger_log_page(request, cid, connector=None):
 @api_login_required
 def dispatch_action(request, cid, connector=None):
     connector_value, _ = _normalize_connector_slug(connector)
+    log_key = store.identity_key(cid, connector_value)
+    if connector_value is None:
+        charger_obj = (
+            Charger.objects.filter(charger_id=cid, connector_id__isnull=True)
+            .order_by("pk")
+            .first()
+        )
+    else:
+        charger_obj = (
+            Charger.objects.filter(charger_id=cid, connector_id=connector_value)
+            .order_by("pk")
+            .first()
+        )
+    if charger_obj is None:
+        if connector_value is None:
+            charger_obj, _ = Charger.objects.get_or_create(
+                charger_id=cid, connector_id=None
+            )
+        else:
+            charger_obj, _ = Charger.objects.get_or_create(
+                charger_id=cid, connector_id=connector_value
+            )
+
+    _ensure_charger_access(request.user, charger_obj)
     ws = store.get_connection(cid, connector_value)
     if ws is None:
         return JsonResponse({"detail": "no connection"}, status=404)
@@ -897,15 +948,27 @@ def dispatch_action(request, cid, connector=None):
         tx_obj = store.get_transaction(cid, connector_value)
         if not tx_obj:
             return JsonResponse({"detail": "no transaction"}, status=404)
+        message_id = uuid.uuid4().hex
         msg = json.dumps(
             [
                 2,
-                str(datetime.utcnow().timestamp()),
+                message_id,
                 "RemoteStopTransaction",
                 {"transactionId": tx_obj.pk},
             ]
         )
-        asyncio.get_event_loop().create_task(ws.send(msg))
+        async_to_sync(ws.send)(msg)
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "RemoteStopTransaction",
+                "charger_id": cid,
+                "connector_id": connector_value,
+                "log_key": log_key,
+                "transaction_id": tx_obj.pk,
+                "requested_at": timezone.now(),
+            },
+        )
     elif action == "remote_start":
         id_tag = data.get("idTag")
         if not isinstance(id_tag, str) or not id_tag.strip():
@@ -924,20 +987,163 @@ def dispatch_action(request, cid, connector=None):
                 payload["connectorId"] = connector_id
         if "chargingProfile" in data and data["chargingProfile"] is not None:
             payload["chargingProfile"] = data["chargingProfile"]
+        message_id = uuid.uuid4().hex
         msg = json.dumps(
             [
                 2,
-                str(datetime.utcnow().timestamp()),
+                message_id,
                 "RemoteStartTransaction",
                 payload,
             ]
         )
-        asyncio.get_event_loop().create_task(ws.send(msg))
+        async_to_sync(ws.send)(msg)
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "RemoteStartTransaction",
+                "charger_id": cid,
+                "connector_id": connector_value,
+                "log_key": log_key,
+                "id_tag": id_tag,
+                "requested_at": timezone.now(),
+            },
+        )
+    elif action == "change_availability":
+        availability_type = data.get("type")
+        if availability_type not in {"Operative", "Inoperative"}:
+            return JsonResponse({"detail": "invalid availability type"}, status=400)
+        connector_payload = connector_value if connector_value is not None else 0
+        if "connectorId" in data:
+            candidate = data.get("connectorId")
+            if candidate not in (None, ""):
+                try:
+                    connector_payload = int(candidate)
+                except (TypeError, ValueError):
+                    connector_payload = candidate
+        message_id = uuid.uuid4().hex
+        payload = {"connectorId": connector_payload, "type": availability_type}
+        msg = json.dumps([2, message_id, "ChangeAvailability", payload])
+        async_to_sync(ws.send)(msg)
+        requested_at = timezone.now()
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "ChangeAvailability",
+                "charger_id": cid,
+                "connector_id": connector_value,
+                "availability_type": availability_type,
+                "requested_at": requested_at,
+            },
+        )
+        if charger_obj:
+            updates = {
+                "availability_requested_state": availability_type,
+                "availability_requested_at": requested_at,
+                "availability_request_status": "",
+                "availability_request_status_at": None,
+                "availability_request_details": "",
+            }
+            Charger.objects.filter(pk=charger_obj.pk).update(**updates)
+            for field, value in updates.items():
+                setattr(charger_obj, field, value)
+    elif action == "data_transfer":
+        vendor_id = data.get("vendorId")
+        if not isinstance(vendor_id, str) or not vendor_id.strip():
+            return JsonResponse({"detail": "vendorId required"}, status=400)
+        vendor_id = vendor_id.strip()
+        payload: dict[str, object] = {"vendorId": vendor_id}
+        message_identifier = ""
+        if "messageId" in data and data["messageId"] is not None:
+            message_candidate = data["messageId"]
+            if not isinstance(message_candidate, str):
+                return JsonResponse({"detail": "messageId must be a string"}, status=400)
+            message_identifier = message_candidate.strip()
+            if message_identifier:
+                payload["messageId"] = message_identifier
+        if "data" in data:
+            payload["data"] = data["data"]
+        message_id = uuid.uuid4().hex
+        msg = json.dumps([2, message_id, "DataTransfer", payload])
+        record = DataTransferMessage.objects.create(
+            charger=charger_obj,
+            connector_id=connector_value,
+            direction=DataTransferMessage.DIRECTION_CSMS_TO_CP,
+            ocpp_message_id=message_id,
+            vendor_id=vendor_id,
+            message_id=message_identifier,
+            payload=payload,
+            status="Pending",
+        )
+        async_to_sync(ws.send)(msg)
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "DataTransfer",
+                "charger_id": cid,
+                "connector_id": connector_value,
+                "message_pk": record.pk,
+                "log_key": log_key,
+            },
+        )
     elif action == "reset":
-        msg = json.dumps(
-            [2, str(datetime.utcnow().timestamp()), "Reset", {"type": "Soft"}]
+        message_id = uuid.uuid4().hex
+        msg = json.dumps([2, message_id, "Reset", {"type": "Soft"}])
+        async_to_sync(ws.send)(msg)
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "Reset",
+                "charger_id": cid,
+                "connector_id": connector_value,
+                "log_key": log_key,
+                "requested_at": timezone.now(),
+            },
+        )
+    elif action == "trigger_message":
+        trigger_target = data.get("target") or data.get("triggerTarget")
+        if not isinstance(trigger_target, str) or not trigger_target.strip():
+            return JsonResponse({"detail": "target required"}, status=400)
+        trigger_target = trigger_target.strip()
+        allowed_targets = {
+            "BootNotification",
+            "DiagnosticsStatusNotification",
+            "FirmwareStatusNotification",
+            "Heartbeat",
+            "MeterValues",
+            "StatusNotification",
+        }
+        if trigger_target not in allowed_targets:
+            return JsonResponse({"detail": "invalid target"}, status=400)
+        payload: dict[str, object] = {"requestedMessage": trigger_target}
+        trigger_connector = None
+        connector_field = data.get("connectorId")
+        if connector_field in (None, ""):
+            connector_field = data.get("connector")
+        if connector_field in (None, "") and connector_value is not None:
+            connector_field = connector_value
+        if connector_field not in (None, ""):
+            try:
+                trigger_connector = int(connector_field)
+            except (TypeError, ValueError):
+                return JsonResponse({"detail": "connectorId must be an integer"}, status=400)
+            if trigger_connector <= 0:
+                return JsonResponse({"detail": "connectorId must be positive"}, status=400)
+            payload["connectorId"] = trigger_connector
+        message_id = uuid.uuid4().hex
+        msg = json.dumps([2, message_id, "TriggerMessage", payload])
+        async_to_sync(ws.send)(msg)
+        store.register_pending_call(
+            message_id,
+            {
+                "action": "TriggerMessage",
+                "charger_id": cid,
+                "connector_id": connector_value,
+                "log_key": log_key,
+                "trigger_target": trigger_target,
+                "trigger_connector": trigger_connector,
+                "requested_at": timezone.now(),
+            },
         )
-        asyncio.get_event_loop().create_task(ws.send(msg))
     else:
         return JsonResponse({"detail": "unknown action"}, status=400)
     log_key = store.identity_key(cid, connector_value)

pages/admin.py

@@ -1,3 +1,5 @@
+import logging
+
 from django.contrib import admin, messages
 from django.contrib.sites.admin import SiteAdmin as DjangoSiteAdmin
 from django.contrib.sites.models import Site
@@ -12,10 +14,11 @@ from django.http import JsonResponse
 from django.utils import timezone
 from django.db.models import Count
 from django.db.models.functions import TruncDate
-from datetime import timedelta
+from datetime import datetime, time, timedelta
 import ipaddress
 from django.apps import apps as django_apps
 from django.conf import settings
+from django.utils.translation import gettext_lazy as _, ngettext
 
 from nodes.models import Node
 from nodes.utils import capture_screenshot, save_screenshot
@@ -29,11 +32,15 @@ from .models import (
     Favorite,
     ViewHistory,
     UserManual,
+    UserStory,
 )
 from django.contrib.contenttypes.models import ContentType
 from core.user_data import EntityModelAdmin
 
 
+logger = logging.getLogger(__name__)
+
+
 def get_local_app_choices():
     choices = []
     for app_label in getattr(settings, "LOCAL_APPS", []):
@@ -255,8 +262,20 @@ class ViewHistoryAdmin(EntityModelAdmin):
     def _build_chart_data(self, days: int = 30, max_pages: int = 8) -> dict:
         end_date = timezone.localdate()
         start_date = end_date - timedelta(days=days - 1)
+
+        start_at = datetime.combine(start_date, time.min)
+        end_at = datetime.combine(end_date + timedelta(days=1), time.min)
+
+        if settings.USE_TZ:
+            current_tz = timezone.get_current_timezone()
+            start_at = timezone.make_aware(start_at, current_tz)
+            end_at = timezone.make_aware(end_at, current_tz)
+            trunc_expression = TruncDate("visited_at", tzinfo=current_tz)
+        else:
+            trunc_expression = TruncDate("visited_at")
+
         queryset = ViewHistory.objects.filter(
-            visited_at__date__range=(start_date, end_date)
+            visited_at__gte=start_at, visited_at__lt=end_at
         )
 
         meta = {
@@ -282,7 +301,7 @@ class ViewHistoryAdmin(EntityModelAdmin):
 
         aggregates = (
             queryset.filter(path__in=paths)
-            .annotate(day=TruncDate("visited_at"))
+            .annotate(day=trunc_expression)
             .values("day", "path")
             .order_by("day")
             .annotate(total=Count("id"))
@@ -326,6 +345,119 @@ class ViewHistoryAdmin(EntityModelAdmin):
         return {"labels": labels, "datasets": datasets, "meta": meta}
 
 
+@admin.register(UserStory)
+class UserStoryAdmin(EntityModelAdmin):
+    date_hierarchy = "submitted_at"
+    actions = ["create_github_issues"]
+    list_display = (
+        "name",
+        "rating",
+        "path",
+        "submitted_at",
+        "github_issue_display",
+        "take_screenshot",
+        "owner",
+    )
+    list_filter = ("rating", "submitted_at", "take_screenshot")
+    search_fields = ("name", "comments", "path", "github_issue_url")
+    readonly_fields = (
+        "name",
+        "rating",
+        "comments",
+        "take_screenshot",
+        "path",
+        "user",
+        "owner",
+        "submitted_at",
+        "github_issue_number",
+        "github_issue_url",
+    )
+    ordering = ("-submitted_at",)
+    fields = (
+        "name",
+        "rating",
+        "comments",
+        "take_screenshot",
+        "path",
+        "user",
+        "owner",
+        "submitted_at",
+        "github_issue_number",
+        "github_issue_url",
+    )
+
+    @admin.display(description=_("GitHub issue"), ordering="github_issue_number")
+    def github_issue_display(self, obj):
+        if obj.github_issue_url:
+            label = (
+                f"#{obj.github_issue_number}"
+                if obj.github_issue_number is not None
+                else obj.github_issue_url
+            )
+            return format_html(
+                '<a href="{}" target="_blank" rel="noopener noreferrer">{}</a>',
+                obj.github_issue_url,
+                label,
+            )
+        if obj.github_issue_number is not None:
+            return f"#{obj.github_issue_number}"
+        return _("Not created")
+
+    @admin.action(description=_("Create GitHub issues"))
+    def create_github_issues(self, request, queryset):
+        created = 0
+        skipped = 0
+
+        for story in queryset:
+            if story.github_issue_url:
+                skipped += 1
+                continue
+
+            try:
+                issue_url = story.create_github_issue()
+            except Exception as exc:  # pragma: no cover - network/runtime errors
+                logger.exception("Failed to create GitHub issue for UserStory %s", story.pk)
+                self.message_user(
+                    request,
+                    _("Unable to create a GitHub issue for %(story)s: %(error)s")
+                    % {"story": story, "error": exc},
+                    messages.ERROR,
+                )
+                continue
+
+            if issue_url:
+                created += 1
+            else:
+                skipped += 1
+
+        if created:
+            self.message_user(
+                request,
+                ngettext(
+                    "Created %(count)d GitHub issue.",
+                    "Created %(count)d GitHub issues.",
+                    created,
+                )
+                % {"count": created},
+                messages.SUCCESS,
+            )
+
+        if skipped:
+            self.message_user(
+                request,
+                ngettext(
+                    "Skipped %(count)d feedback item (issue already exists or was throttled).",
+                    "Skipped %(count)d feedback items (issues already exist or were throttled).",
+                    skipped,
+                )
+                % {"count": skipped},
+                messages.INFO,
+            )
+
+    def has_add_permission(self, request):
+        return False
+
+
 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()

pages/context_processors.py

@@ -9,11 +9,22 @@ from core.reference_utils import filter_visible_references
 from .models import Module
 
 _favicon_path = Path(settings.BASE_DIR) / "pages" / "fixtures" / "data" / "favicon.txt"
+_control_favicon_path = (
+    Path(settings.BASE_DIR) / "pages" / "fixtures" / "data" / "favicon_control.txt"
+)
+
 try:
     _DEFAULT_FAVICON = f"data:image/png;base64,{_favicon_path.read_text().strip()}"
 except OSError:
     _DEFAULT_FAVICON = ""
 
+try:
+    _CONTROL_FAVICON = (
+        f"data:image/png;base64,{_control_favicon_path.read_text().strip()}"
+    )
+except OSError:
+    _CONTROL_FAVICON = _DEFAULT_FAVICON
+
 
 def nav_links(request):
     """Provide navigation links for the current site."""
@@ -84,7 +95,10 @@ def nav_links(request):
             except Exception:
                 pass
         if not favicon_url:
-            favicon_url = _DEFAULT_FAVICON
+            if node and getattr(node.role, "name", "") == "Control":
+                favicon_url = _CONTROL_FAVICON
+            else:
+                favicon_url = _DEFAULT_FAVICON
 
     header_refs_qs = (
         Reference.objects.filter(show_in_header=True)

pages/defaults.py

@@ -8,7 +8,6 @@ DEFAULT_APPLICATION_DESCRIPTIONS: Dict[str, str] = {
     "core": "Support for Business Processes and monetization.",
     "ocpp": "Compatibility with Standards and Good Practices.",
     "nodes": "System and Node-level operations,",
-    "pages": "Scheduling, Periodicity and Event Signaling,",
+    "pages": "User QA, Continuity Design and Chaos Testing.",
     "teams": "Identity, Entitlements and Access Controls.",
-    "man": "User QA, Continuity Design and Chaos Testing.",
 }