arthexis 0.1.9__py3-none-any.whl → 0.1.10__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."""
@@ -450,9 +468,16 @@ def cp_simulator(request):
         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],

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"
@@ -47,6 +49,11 @@ def nav_links(request):
                 continue
             landings.append(landing)
         if landings:
+            app_name = getattr(module.application, "name", "").lower()
+            if app_name == "awg":
+                module.menu = "Calculate"
+            elif app_name == "man":
+                module.menu = "Manuals"
             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/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