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

ocpp/views.py

@@ -9,6 +9,7 @@ from django.views.decorators.csrf import csrf_exempt
 from django.shortcuts import render, get_object_or_404
 from django.core.paginator import Paginator
 from django.contrib.auth.decorators import login_required
+from django.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
@@ -16,6 +17,8 @@ from django.utils import translation
 
 from utils.api import api_login_required
 
+from nodes.models import Node
+
 from pages.utils import landing
 from core.liveupdate import live_update
 
@@ -229,7 +232,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.all():
+    for charger in Charger.objects.filter(public_display=True):
         cid = charger.charger_id
         sessions: list[tuple[Charger, Transaction]] = []
         tx_obj = store.get_transaction(cid, charger.connector_id)
@@ -279,42 +282,42 @@ def charger_list(request):
             charger,
             tx_obj if charger.connector_id is not None else (sessions if sessions else None),
         )
-        data.append(
-            {
-                "charger_id": cid,
-                "name": charger.name,
-                "connector_id": charger.connector_id,
-                "connector_slug": charger.connector_slug,
-                "connector_label": charger.connector_label,
-                "require_rfid": charger.require_rfid,
-                "transaction": tx_data,
-                "activeTransactions": active_transactions,
-                "lastHeartbeat": (
-                    charger.last_heartbeat.isoformat()
-                    if charger.last_heartbeat
-                    else None
-                ),
-                "lastMeterValues": charger.last_meter_values,
-                "firmwareStatus": charger.firmware_status,
-                "firmwareStatusInfo": charger.firmware_status_info,
-                "firmwareTimestamp": (
-                    charger.firmware_timestamp.isoformat()
-                    if charger.firmware_timestamp
-                    else None
-                ),
-                "connected": store.is_connected(cid, charger.connector_id),
-                "lastStatus": charger.last_status or None,
-                "lastErrorCode": charger.last_error_code or None,
-                "lastStatusTimestamp": (
-                    charger.last_status_timestamp.isoformat()
-                    if charger.last_status_timestamp
-                    else None
-                ),
-                "lastStatusVendorInfo": charger.last_status_vendor_info,
-                "status": state,
-                "statusColor": color,
-            }
-        )
+        entry = {
+            "charger_id": cid,
+            "name": charger.name,
+            "connector_id": charger.connector_id,
+            "connector_slug": charger.connector_slug,
+            "connector_label": charger.connector_label,
+            "require_rfid": charger.require_rfid,
+            "transaction": tx_data,
+            "activeTransactions": active_transactions,
+            "lastHeartbeat": (
+                charger.last_heartbeat.isoformat()
+                if charger.last_heartbeat
+                else None
+            ),
+            "lastMeterValues": charger.last_meter_values,
+            "firmwareStatus": charger.firmware_status,
+            "firmwareStatusInfo": charger.firmware_status_info,
+            "firmwareTimestamp": (
+                charger.firmware_timestamp.isoformat()
+                if charger.firmware_timestamp
+                else None
+            ),
+            "connected": store.is_connected(cid, charger.connector_id),
+            "lastStatus": charger.last_status or None,
+            "lastErrorCode": charger.last_error_code or None,
+            "lastStatusTimestamp": (
+                charger.last_status_timestamp.isoformat()
+                if charger.last_status_timestamp
+                else None
+            ),
+            "lastStatusVendorInfo": charger.last_status_vendor_info,
+            "status": state,
+            "statusColor": color,
+        }
+        entry.update(_diagnostics_payload(charger))
+        data.append(entry)
     return JsonResponse({"chargers": data})
 
 
@@ -375,48 +378,54 @@ def charger_detail(request, cid, connector=None):
         charger,
         tx_obj if charger.connector_id is not None else (sessions if sessions else None),
     )
-    return JsonResponse(
-        {
-            "charger_id": cid,
-            "connector_id": charger.connector_id,
-            "connector_slug": connector_slug,
-            "name": charger.name,
-            "require_rfid": charger.require_rfid,
-            "transaction": tx_data,
-            "activeTransactions": active_transactions,
-            "lastHeartbeat": (
-                charger.last_heartbeat.isoformat() if charger.last_heartbeat else None
-            ),
-            "lastMeterValues": charger.last_meter_values,
-            "firmwareStatus": charger.firmware_status,
-            "firmwareStatusInfo": charger.firmware_status_info,
-            "firmwareTimestamp": (
-                charger.firmware_timestamp.isoformat()
-                if charger.firmware_timestamp
-                else None
-            ),
-            "log": log,
-            "lastStatus": charger.last_status or None,
-            "lastErrorCode": charger.last_error_code or None,
-            "lastStatusTimestamp": (
-                charger.last_status_timestamp.isoformat()
-                if charger.last_status_timestamp
-                else None
-            ),
-            "lastStatusVendorInfo": charger.last_status_vendor_info,
-            "status": state,
-            "statusColor": color,
-        }
-    )
+    payload = {
+        "charger_id": cid,
+        "connector_id": charger.connector_id,
+        "connector_slug": connector_slug,
+        "name": charger.name,
+        "require_rfid": charger.require_rfid,
+        "transaction": tx_data,
+        "activeTransactions": active_transactions,
+        "lastHeartbeat": (
+            charger.last_heartbeat.isoformat() if charger.last_heartbeat else None
+        ),
+        "lastMeterValues": charger.last_meter_values,
+        "firmwareStatus": charger.firmware_status,
+        "firmwareStatusInfo": charger.firmware_status_info,
+        "firmwareTimestamp": (
+            charger.firmware_timestamp.isoformat()
+            if charger.firmware_timestamp
+            else None
+        ),
+        "log": log,
+        "lastStatus": charger.last_status or None,
+        "lastErrorCode": charger.last_error_code or None,
+        "lastStatusTimestamp": (
+            charger.last_status_timestamp.isoformat()
+            if charger.last_status_timestamp
+            else None
+        ),
+        "lastStatusVendorInfo": charger.last_status_vendor_info,
+        "status": state,
+        "statusColor": color,
+    }
+    payload.update(_diagnostics_payload(charger))
+    return JsonResponse(payload)
 
 
-@login_required
-@landing("Dashboard")
+@landing("OCPP CSMS Dashboard")
 @live_update()
 def dashboard(request):
     """Landing page listing all known chargers and their status."""
+    node = Node.get_local()
+    role = node.role if node else None
+    is_constellation = bool(role and role.name == "Constellation")
+    if not request.user.is_authenticated and not is_constellation:
+        return redirect_to_login(
+            request.get_full_path(), login_url=reverse("pages:login")
+        )
     chargers = []
-    for charger in Charger.objects.all():
+    for charger in Charger.objects.filter(public_display=True):
         tx_obj = store.get_transaction(charger.charger_id, charger.connector_id)
         if not tx_obj:
             tx_obj = (
@@ -426,11 +435,20 @@ def dashboard(request):
             )
         state, color = _charger_state(charger, tx_obj)
         chargers.append({"charger": charger, "state": state, "color": color})
-    return render(request, "ocpp/dashboard.html", {"chargers": chargers})
+    scheme = "wss" if request.is_secure() else "ws"
+    host = request.get_host()
+    ws_url = f"{scheme}://{host}/ocpp/<CHARGE_POINT_ID>/"
+    context = {
+        "chargers": chargers,
+        "show_demo_notice": is_constellation,
+        "demo_ws_url": ws_url,
+        "ws_rate_limit": store.MAX_CONNECTIONS_PER_IP,
+    }
+    return render(request, "ocpp/dashboard.html", context)
 
 
 @login_required
-@landing("CP Simulator")
+@landing("Charge Point Simulator")
 @live_update()
 def cp_simulator(request):
     """Public landing page to control the OCPP charge point simulator."""
@@ -446,13 +464,21 @@ def cp_simulator(request):
     default_vins = ["WP0ZZZ00000000000", "WAUZZZ00000000000"]
 
     message = ""
+    dashboard_link: str | None = None
     if request.method == "POST":
         cp_idx = int(request.POST.get("cp") or 1)
         action = request.POST.get("action")
         if action == "start":
+            ws_port_value = request.POST.get("ws_port")
+            if ws_port_value is None:
+                ws_port = int(default_ws_port) if default_ws_port else None
+            elif ws_port_value.strip():
+                ws_port = int(ws_port_value)
+            else:
+                ws_port = None
             sim_params = dict(
                 host=request.POST.get("host") or default_host,
-                ws_port=int(request.POST.get("ws_port") or default_ws_port),
+                ws_port=ws_port,
                 cp_path=request.POST.get("cp_path") or default_cp_paths[cp_idx - 1],
                 serial_number=request.POST.get("serial_number")
                 or default_serial_numbers[cp_idx - 1],
@@ -475,6 +501,12 @@ def cp_simulator(request):
                 started, status, log_file = _start_simulator(sim_params, cp=cp_idx)
                 if started:
                     message = f"CP{cp_idx} started: {status}. Logs: {log_file}"
+                    try:
+                        dashboard_link = reverse(
+                            "charger-status", args=[sim_params["cp_path"]]
+                        )
+                    except NoReverseMatch:  # pragma: no cover - defensive
+                        dashboard_link = None
                 else:
                     message = f"CP{cp_idx} {status}. Logs: {log_file}"
             except Exception as exc:  # pragma: no cover - unexpected
@@ -501,6 +533,7 @@ def cp_simulator(request):
 
     context = {
         "message": message,
+        "dashboard_link": dashboard_link,
         "states": state_list,
         "default_host": default_host,
         "default_ws_port": default_ws_port,

pages/admin.py

@@ -28,6 +28,7 @@ from .models import (
     Landing,
     Favorite,
     ViewHistory,
+    UserManual,
 )
 from django.contrib.contenttypes.models import ContentType
 from core.user_data import EntityModelAdmin
@@ -153,7 +154,7 @@ class ApplicationModuleInline(admin.TabularInline):
 @admin.register(Application)
 class ApplicationAdmin(EntityModelAdmin):
     form = ApplicationForm
-    list_display = ("name", "app_verbose_name", "installed")
+    list_display = ("name", "app_verbose_name", "description", "installed")
     readonly_fields = ("installed",)
     inlines = [ApplicationModuleInline]
 
@@ -180,6 +181,13 @@ class ModuleAdmin(EntityModelAdmin):
     inlines = [LandingInline]
 
 
+@admin.register(UserManual)
+class UserManualAdmin(EntityModelAdmin):
+    list_display = ("title", "slug", "languages", "is_seed_data", "is_user_data")
+    search_fields = ("title", "slug", "description")
+    list_filter = ("is_seed_data", "is_user_data")
+
+
 @admin.register(ViewHistory)
 class ViewHistoryAdmin(EntityModelAdmin):
     date_hierarchy = "visited_at"

pages/context_processors.py

@@ -4,6 +4,8 @@ from django.conf import settings
 from pathlib import Path
 from types import SimpleNamespace
 from nodes.models import Node
+from core.models import Reference
+from core.reference_utils import filter_visible_references
 from .models import Module
 
 _favicon_path = Path(settings.BASE_DIR) / "pages" / "fixtures" / "data" / "favicon.txt"
@@ -37,16 +39,21 @@ def nav_links(request):
             except Resolver404:
                 continue
             view_func = match.func
-            requires_login = getattr(view_func, "login_required", False) or hasattr(
-                view_func, "login_url"
-            )
+            requires_login = bool(getattr(view_func, "login_required", False))
+            if not requires_login and hasattr(view_func, "login_url"):
+                requires_login = True
             staff_only = getattr(view_func, "staff_required", False)
             if requires_login and not request.user.is_authenticated:
-                continue
+                setattr(landing, "requires_login", True)
             if staff_only and not request.user.is_staff:
                 continue
             landings.append(landing)
         if landings:
+            app_name = getattr(module.application, "name", "").lower()
+            if app_name == "awg":
+                module.menu = "Calculate"
+            elif module.path.rstrip("/").lower() == "/man":
+                module.menu = "Manual"
             module.enabled_landings = landings
             valid_modules.append(module)
             if request.path.startswith(module.path):
@@ -79,7 +86,20 @@ def nav_links(request):
         if not favicon_url:
             favicon_url = _DEFAULT_FAVICON
 
+    header_refs_qs = (
+        Reference.objects.filter(show_in_header=True)
+        .exclude(value="")
+        .prefetch_related("roles", "features", "sites")
+    )
+    header_references = filter_visible_references(
+        header_refs_qs,
+        request=request,
+        site=site,
+        node=node,
+    )
+
     return {
         "nav_modules": valid_modules,
         "favicon_url": favicon_url,
+        "header_references": header_references,
     }

pages/defaults.py

@@ -0,0 +1,14 @@
+"""Default configuration for the pages application."""
+from __future__ import annotations
+
+from typing import Dict
+
+DEFAULT_APPLICATION_DESCRIPTIONS: Dict[str, str] = {
+    "awg": "Power, Energy and Cost calculations.",
+    "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,",
+    "teams": "Identity, Entitlements and Access Controls.",
+    "man": "User QA, Continuity Design and Chaos Testing.",
+}

pages/forms.py

@@ -0,0 +1,131 @@
+"""Forms for the pages app."""
+
+from __future__ import annotations
+
+from django import forms
+from django.contrib.auth import authenticate
+from django.contrib.auth.forms import AuthenticationForm
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
+from django.views.decorators.debug import sensitive_variables
+
+
+class AuthenticatorLoginForm(AuthenticationForm):
+    """Authentication form that supports password or authenticator codes."""
+
+    otp_token = forms.CharField(
+        label=_("Authenticator code"),
+        required=False,
+        widget=forms.TextInput(
+            attrs={
+                "autocomplete": "one-time-code",
+                "inputmode": "numeric",
+                "pattern": "[0-9]*",
+            }
+        ),
+    )
+    auth_method = forms.CharField(required=False, widget=forms.HiddenInput(), initial="password")
+
+    error_messages = {
+        **AuthenticationForm.error_messages,
+        "invalid_token": _("The authenticator code is invalid or has expired."),
+        "token_required": _("Enter the code from your authenticator app."),
+        "password_required": _("Enter your password."),
+    }
+
+    def __init__(self, request=None, *args, **kwargs):
+        super().__init__(request=request, *args, **kwargs)
+        self.fields["password"].required = False
+        self.fields["otp_token"].strip = True
+        self.fields["auth_method"].initial = "password"
+        self.verified_device = None
+
+    def get_invalid_token_error(self) -> ValidationError:
+        return ValidationError(self.error_messages["invalid_token"], code="invalid_token")
+
+    def get_token_required_error(self) -> ValidationError:
+        return ValidationError(self.error_messages["token_required"], code="token_required")
+
+    def get_password_required_error(self) -> ValidationError:
+        return ValidationError(self.error_messages["password_required"], code="password_required")
+
+    @sensitive_variables()
+    def clean(self):
+        username = self.cleaned_data.get("username")
+        method = (self.cleaned_data.get("auth_method") or "password").lower()
+        if method not in {"password", "otp"}:
+            method = "password"
+        self.cleaned_data["auth_method"] = method
+
+        if username is not None:
+            if method == "otp":
+                token = (self.cleaned_data.get("otp_token") or "").strip().replace(" ", "")
+                if not token:
+                    raise self.get_token_required_error()
+                self.user_cache = authenticate(
+                    self.request,
+                    username=username,
+                    otp_token=token,
+                )
+                if self.user_cache is None:
+                    raise self.get_invalid_token_error()
+                self.cleaned_data["otp_token"] = token
+                self.verified_device = getattr(self.user_cache, "otp_device", None)
+            else:
+                password = self.cleaned_data.get("password")
+                if not password:
+                    raise self.get_password_required_error()
+                self.user_cache = authenticate(
+                    self.request, username=username, password=password
+                )
+                if self.user_cache is None:
+                    raise self.get_invalid_login_error()
+            self.confirm_login_allowed(self.user_cache)
+
+        return self.cleaned_data
+
+    def get_verified_device(self):
+        return self.verified_device
+
+
+class AuthenticatorEnrollmentForm(forms.Form):
+    """Form used to confirm a pending authenticator enrollment."""
+
+    token = forms.CharField(
+        label=_("Authenticator code"),
+        min_length=6,
+        max_length=8,
+        widget=forms.TextInput(
+            attrs={
+                "autocomplete": "one-time-code",
+                "inputmode": "numeric",
+                "pattern": "[0-9]*",
+            }
+        ),
+    )
+
+    error_messages = {
+        "invalid_token": _("The provided code is invalid or has expired."),
+        "missing_device": _("Generate a new authenticator secret before confirming it."),
+    }
+
+    def __init__(self, *args, device=None, **kwargs):
+        self.device = device
+        super().__init__(*args, **kwargs)
+
+    def clean_token(self):
+        token = (self.cleaned_data.get("token") or "").strip().replace(" ", "")
+        if not token:
+            raise forms.ValidationError(self.error_messages["invalid_token"], code="invalid_token")
+        if self.device is None:
+            raise forms.ValidationError(self.error_messages["missing_device"], code="missing_device")
+        try:
+            verified = self.device.verify_token(token)
+        except Exception:
+            verified = False
+        if not verified:
+            raise forms.ValidationError(self.error_messages["invalid_token"], code="invalid_token")
+        return token
+
+    def get_verified_device(self):
+        return self.device

pages/models.py

@@ -111,6 +111,7 @@ class Module(Entity):
                 return
         patterns = getattr(urlconf, "urlpatterns", [])
         created = False
+        normalized_module = self.path.strip("/")
 
         def _walk(patterns, prefix=""):
             nonlocal created
@@ -118,17 +119,34 @@ class Module(Entity):
                 if isinstance(pattern, URLPattern):
                     callback = pattern.callback
                     if getattr(callback, "landing", False):
-                        Landing.objects.get_or_create(
-                            module=self,
-                            path=f"{self.path}{prefix}{str(pattern.pattern)}",
-                            defaults={
-                                "label": getattr(
-                                    callback,
-                                    "landing_label",
-                                    callback.__name__.replace("_", " ").title(),
-                                )
-                            },
-                        )
+                        pattern_path = str(pattern.pattern)
+                        relative = f"{prefix}{pattern_path}"
+                        if normalized_module and relative.startswith(normalized_module):
+                            full_path = f"/{relative}"
+                            Landing.objects.update_or_create(
+                                module=self,
+                                path=full_path,
+                                defaults={
+                                    "label": getattr(
+                                        callback,
+                                        "landing_label",
+                                        callback.__name__.replace("_", " ").title(),
+                                    )
+                                },
+                            )
+                        else:
+                            full_path = f"{self.path}{relative}"
+                            Landing.objects.get_or_create(
+                                module=self,
+                                path=full_path,
+                                defaults={
+                                    "label": getattr(
+                                        callback,
+                                        "landing_label",
+                                        callback.__name__.replace("_", " ").title(),
+                                    )
+                                },
+                            )
                         created = True
                 else:
                     _walk(
@@ -192,6 +210,7 @@ class Landing(Entity):
         return f"{self.label} ({self.path})"
 
     def save(self, *args, **kwargs):
+        existing = None
         if not self.pk:
             existing = (
                 type(self).objects.filter(module=self.module, path=self.path).first()
@@ -200,10 +219,30 @@ class Landing(Entity):
             self.pk = existing.pk
         super().save(*args, **kwargs)
 
-    def natural_key(self):  # pragma: no cover - simple representation
-        return (self.module.node_role.name, self.module.path, self.path)
 
-    natural_key.dependencies = ["nodes.NodeRole", "pages.Module"]
+class UserManual(Entity):
+    slug = models.SlugField(unique=True)
+    title = models.CharField(max_length=200)
+    description = models.CharField(max_length=200)
+    languages = models.CharField(
+        max_length=100,
+        blank=True,
+        default="",
+        help_text="Comma-separated 2-letter language codes",
+    )
+    content_html = models.TextField()
+    content_pdf = models.TextField(help_text="Base64 encoded PDF")
+
+    class Meta:
+        db_table = "man_usermanual"
+        verbose_name = "User Manual"
+        verbose_name_plural = "User Manuals"
+
+    def __str__(self):  # pragma: no cover - simple representation
+        return self.title
+
+    def natural_key(self):  # pragma: no cover - simple representation
+        return (self.slug,)
 
 
 class ViewHistory(Entity):