arthexis 0.1.18__py3-none-any.whl → 0.1.19__py3-none-any.whl

nodes/tests.py

@@ -223,6 +223,46 @@ class NodeGetLocalTests(TestCase):
             node.refresh_from_db()
             self.assertEqual(node.role.name, "Constellation")
 
+    def test_register_current_respects_node_hostname_env(self):
+        with TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            with override_settings(BASE_DIR=base):
+                with (
+                    patch.dict(os.environ, {"NODE_HOSTNAME": "gway-002"}, clear=False),
+                    patch("nodes.models.Node.get_current_mac", return_value="00:11:22:33:44:55"),
+                    patch("nodes.models.socket.gethostname", return_value="localhost"),
+                    patch("nodes.models.socket.gethostbyname", return_value="127.0.0.1"),
+                    patch("nodes.models.revision.get_revision", return_value="rev"),
+                    patch.object(Node, "ensure_keys"),
+                    patch.object(Node, "notify_peers_of_update"),
+                ):
+                    node, created = Node.register_current()
+        self.assertTrue(created)
+        self.assertEqual(node.hostname, "gway-002")
+        self.assertEqual(node.public_endpoint, "gway-002")
+
+    def test_register_current_respects_public_endpoint_env(self):
+        with TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            with override_settings(BASE_DIR=base):
+                with (
+                    patch.dict(
+                        os.environ,
+                        {"NODE_HOSTNAME": "gway-alpha", "NODE_PUBLIC_ENDPOINT": "gway-002"},
+                        clear=False,
+                    ),
+                    patch("nodes.models.Node.get_current_mac", return_value="00:11:22:33:44:56"),
+                    patch("nodes.models.socket.gethostname", return_value="localhost"),
+                    patch("nodes.models.socket.gethostbyname", return_value="127.0.0.1"),
+                    patch("nodes.models.revision.get_revision", return_value="rev"),
+                    patch.object(Node, "ensure_keys"),
+                    patch.object(Node, "notify_peers_of_update"),
+                ):
+                    node, created = Node.register_current()
+        self.assertTrue(created)
+        self.assertEqual(node.hostname, "gway-alpha")
+        self.assertEqual(node.public_endpoint, "gway-002")
+
     def test_register_and_list_node(self):
         response = self.client.post(
             reverse("register-node"),
@@ -2315,29 +2355,6 @@ class NetMessageAdminTests(TransactionTestCase):
         self.assertEqual(form["subject"].value(), "Re: Ping")
         self.assertEqual(str(form["filter_node"].value()), str(node.pk))
 
-
-class LastNetMessageViewTests(TestCase):
-    def setUp(self):
-        self.client = Client()
-        NodeRole.objects.get_or_create(name="Terminal")
-
-    def test_returns_latest_message(self):
-        NetMessage.objects.create(subject="old", body="msg1")
-        latest = NetMessage.objects.create(subject="new", body="msg2")
-        resp = self.client.get(reverse("last-net-message"))
-        self.assertEqual(resp.status_code, 200)
-        self.assertEqual(
-            resp.json(),
-            {
-                "subject": "new",
-                "body": "msg2",
-                "admin_url": reverse(
-                    "admin:nodes_netmessage_change", args=[latest.pk]
-                ),
-            },
-        )
-
-
 class NetMessageReachTests(TestCase):
     def setUp(self):
         self.roles = {}
@@ -2597,13 +2614,6 @@ class NetMessagePropagationTests(TestCase):
         self.assertNotIn(sender_addr, targets)
         self.assertEqual(msg.propagated_to.count(), 4)
         self.assertTrue(msg.complete)
-        self.assertEqual(len(msg.confirmed_peers), mock_post.call_count)
-        self.assertTrue(
-            all(entry["status"] == "acknowledged" for entry in msg.confirmed_peers.values())
-        )
-        self.assertTrue(
-            all(entry["status_code"] == 200 for entry in msg.confirmed_peers.values())
-        )
 
     @patch("requests.post")
     @patch("core.notifications.notify", return_value=False)
@@ -2689,10 +2699,8 @@ class NetMessagePropagationTests(TestCase):
         ):
             msg.propagate()
 
-        self.assertTrue(msg.confirmed_peers)
-        self.assertTrue(
-            all(entry["status"] == "error" for entry in msg.confirmed_peers.values())
-        )
+        self.assertEqual(msg.propagated_to.count(), len(self.remotes))
+        self.assertTrue(msg.complete)
 
 
 class NetMessageSignatureTests(TestCase):

nodes/urls.py

@@ -8,7 +8,6 @@ urlpatterns = [
     path("register/", views.register_node, name="register-node"),
     path("screenshot/", views.capture, name="node-screenshot"),
     path("net-message/", views.net_message, name="net-message"),
-    path("last-message/", views.last_net_message, name="last-net-message"),
     path("rfid/export/", views.export_rfids, name="node-rfid-export"),
     path("rfid/import/", views.import_rfids, name="node-rfid-import"),
     path("<slug:endpoint>/", views.public_node_endpoint, name="node-public-endpoint"),

nodes/views.py

@@ -104,6 +104,8 @@ def _get_host_domain(request) -> str:
     domain, _ = split_domain_port(host)
     if not domain:
         return ""
+    if domain.lower() == "localhost":
+        return ""
     try:
         ipaddress.ip_address(domain)
     except ValueError:
@@ -666,18 +668,3 @@ def net_message(request):
         msg.apply_attachments(attachments)
     msg.propagate(seen=seen)
     return JsonResponse({"status": "propagated", "complete": msg.complete})
-
-
-def last_net_message(request):
-    """Return the most recent :class:`NetMessage`."""
-
-    msg = NetMessage.objects.order_by("-created").first()
-    if not msg:
-        return JsonResponse({"subject": "", "body": "", "admin_url": ""})
-    return JsonResponse(
-        {
-            "subject": msg.subject,
-            "body": msg.body,
-            "admin_url": reverse("admin:nodes_netmessage_change", args=[msg.pk]),
-        }
-    )

ocpp/admin.py

@@ -6,7 +6,7 @@ from datetime import timedelta
 import json
 
 from django.shortcuts import redirect
-from django.utils import timezone
+from django.utils import formats, timezone, translation
 from django.urls import path
 from django.http import HttpResponse, HttpResponseRedirect
 from django.template.response import TemplateResponse
@@ -163,6 +163,7 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
                     "charger_id",
                     "display_name",
                     "connector_id",
+                    "language",
                     "location",
                     "last_path",
                     "last_heartbeat",
@@ -719,7 +720,7 @@ class SimulatorAdmin(SaveBeforeChangeAction, LogViewAdminMixin, EntityModelAdmin
         "ws_port",
         "ws_url",
         "interval",
-        "kw_max",
+        "kw_max_display",
         "running",
         "log_link",
     )
@@ -759,6 +760,26 @@ class SimulatorAdmin(SaveBeforeChangeAction, LogViewAdminMixin, EntityModelAdmin
 
     log_type = "simulator"
 
+    @admin.display(description="kW Max", ordering="kw_max")
+    def kw_max_display(self, obj):
+        """Display ``kw_max`` with a dot decimal separator for Spanish locales."""
+
+        language = translation.get_language() or ""
+        if language.startswith("es"):
+            return formats.number_format(
+                obj.kw_max,
+                decimal_pos=2,
+                use_l10n=False,
+                force_grouping=False,
+            )
+
+        return formats.number_format(
+            obj.kw_max,
+            decimal_pos=2,
+            use_l10n=True,
+            force_grouping=False,
+        )
+
     def save_model(self, request, obj, form, change):
         previous_door_open = False
         if change and obj.pk:

ocpp/models.py

@@ -82,6 +82,13 @@ class Charger(Entity):
         default=True,
         help_text="Display this charger on the public status dashboard.",
     )
+    language = models.CharField(
+        _("Language"),
+        max_length=12,
+        choices=settings.LANGUAGES,
+        default="es",
+        help_text=_("Preferred language for the public landing page."),
+    )
     require_rfid = models.BooleanField(
         _("Require RFID Authorization"),
         default=False,

ocpp/store.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-from datetime import datetime
+from datetime import datetime, timezone
 import json
 from pathlib import Path
 import re
@@ -427,7 +427,7 @@ def _file_path(cid: str, log_type: str = "charger") -> Path:
 def add_log(cid: str, entry: str, log_type: str = "charger") -> None:
     """Append a timestamped log entry for the given id and log type."""
 
-    timestamp = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
+    timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
     entry = f"{timestamp} {entry}"
 
     store = logs[log_type]
@@ -454,7 +454,7 @@ def start_session_log(cid: str, tx_id: int) -> None:
 
     history[cid] = {
         "transaction": tx_id,
-        "start": datetime.utcnow(),
+        "start": datetime.now(timezone.utc),
         "messages": [],
     }
 
@@ -467,7 +467,9 @@ def add_session_message(cid: str, message: str) -> None:
         return
     sess["messages"].append(
         {
-            "timestamp": datetime.utcnow().isoformat() + "Z",
+            "timestamp": datetime.now(timezone.utc)
+            .isoformat()
+            .replace("+00:00", "Z"),
             "message": message,
         }
     )

ocpp/tests.py

@@ -1852,6 +1852,16 @@ class ChargerLandingTests(TestCase):
         status_url = reverse("charger-status-connector", args=["PAGE1", "all"])
         self.assertContains(response, status_url)
 
+    def test_charger_page_respects_language_configuration(self):
+        charger = Charger.objects.create(charger_id="PAGE-DE", language="de")
+
+        response = self.client.get(reverse("charger-page", args=["PAGE-DE"]))
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.context["LANGUAGE_CODE"], "de")
+        self.assertContains(response, 'lang="de"')
+        self.assertContains(response, 'data-preferred-language="de"')
+
     def test_status_page_renders(self):
         charger = Charger.objects.create(charger_id="PAGE2")
         resp = self.client.get(reverse("charger-status", args=["PAGE2"]))
@@ -2078,7 +2088,10 @@ class ChargerLandingTests(TestCase):
         log_id = store.identity_key("LOG1", None)
         store.add_log(log_id, "hello", log_type="charger")
         entry = store.get_logs(log_id, log_type="charger")[0]
-        self.assertRegex(entry, r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} hello$")
+        self.assertRegex(
+            entry,
+            r"^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} hello$",
+        )
         resp = self.client.get(reverse("charger-log", args=["LOG1"]) + "?type=charger")
         self.assertEqual(resp.status_code, 200)
         self.assertContains(resp, "hello")

ocpp/views.py

@@ -11,6 +11,7 @@ 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.utils.text import slugify
 from django.urls import NoReverseMatch, reverse
 from django.conf import settings
 from django.utils import translation, timezone
@@ -309,9 +310,14 @@ def _landing_page_translations() -> dict[str, dict[str, str]]:
     """Return static translations used by the charger public landing page."""
 
     catalog: dict[str, dict[str, str]] = {}
-    for code in ("en", "es"):
-        with translation.override(code):
-            catalog[code] = {
+    seen_codes: set[str] = set()
+    for code, _name in settings.LANGUAGES:
+        normalized = str(code).strip()
+        if not normalized or normalized in seen_codes:
+            continue
+        seen_codes.add(normalized)
+        with translation.override(normalized):
+            catalog[normalized] = {
                 "serial_number_label": gettext("Serial Number"),
                 "connector_label": gettext("Connector"),
                 "advanced_view_label": gettext("Advanced View"),
@@ -842,11 +848,30 @@ def charger_page(request, cid, connector=None):
     state_source = tx if charger.connector_id is not None else (sessions if sessions else None)
     state, color = _charger_state(charger, state_source)
     language_cookie = request.COOKIES.get(settings.LANGUAGE_COOKIE_NAME)
-    preferred_language = "es"
-    supported_languages = {code for code, _ in settings.LANGUAGES}
-    if preferred_language in supported_languages and not language_cookie:
-        translation.activate(preferred_language)
-        request.LANGUAGE_CODE = translation.get_language()
+    available_languages = [
+        str(code).strip()
+        for code, _ in settings.LANGUAGES
+        if str(code).strip()
+    ]
+    supported_languages = set(available_languages)
+    charger_language = (charger.language or "es").strip()
+    if charger_language not in supported_languages:
+        fallback = "es" if "es" in supported_languages else ""
+        if not fallback and available_languages:
+            fallback = available_languages[0]
+        charger_language = fallback
+    if (
+        charger_language
+        and (
+            not language_cookie
+            or language_cookie not in supported_languages
+            or language_cookie != charger_language
+        )
+    ):
+        translation.activate(charger_language)
+    current_language = translation.get_language()
+    request.LANGUAGE_CODE = current_language
+    preferred_language = charger_language or current_language
     connector_links = [
         {
             "slug": item["slug"],
@@ -874,6 +899,7 @@ def charger_page(request, cid, connector=None):
             "active_connector_count": active_connector_count,
             "status_url": status_url,
             "landing_translations": _landing_page_translations(),
+            "preferred_language": preferred_language,
             "state": state,
             "color": color,
         },
@@ -1209,8 +1235,11 @@ def charger_log_page(request, cid, connector=None):
             charger_id=cid
         )
         target_id = cid
+
+    slug_source = slugify(target_id) or slugify(cid) or "log"
+    filename_parts = [log_type, slug_source]
+    download_filename = f"{'-'.join(part for part in filename_parts if part)}.log"
     limit_options = [
-        {"value": "10", "label": "10"},
         {"value": "20", "label": "20"},
         {"value": "40", "label": "40"},
         {"value": "100", "label": "100"},
@@ -1220,15 +1249,35 @@ def charger_log_page(request, cid, connector=None):
     limit_choice = request.GET.get("limit", "20")
     if limit_choice not in allowed_values:
         limit_choice = "20"
-
-    log_entries = list(store.get_logs(target_id, log_type=log_type) or [])
+    limit_index = allowed_values.index(limit_choice)
+
+    log_entries_all = list(store.get_logs(target_id, log_type=log_type) or [])
+    download_requested = request.GET.get("download") == "1"
+    if download_requested:
+        download_content = "\n".join(log_entries_all)
+        if download_content and not download_content.endswith("\n"):
+            download_content = f"{download_content}\n"
+        response = HttpResponse(download_content, content_type="text/plain; charset=utf-8")
+        response["Content-Disposition"] = f'attachment; filename="{download_filename}"'
+        return response
+
+    log_entries = log_entries_all
     if limit_choice != "all":
         try:
             limit_value = int(limit_choice)
         except (TypeError, ValueError):
             limit_value = 20
             limit_choice = "20"
+            limit_index = allowed_values.index(limit_choice)
         log_entries = log_entries[-limit_value:]
+
+    download_params = request.GET.copy()
+    download_params["download"] = "1"
+    download_params.pop("limit", None)
+    download_query = download_params.urlencode()
+    log_download_url = f"{request.path}?{download_query}" if download_query else request.path
+
+    limit_label = limit_options[limit_index]["label"]
     return render(
         request,
         "ocpp/charger_logs.html",
@@ -1240,7 +1289,11 @@ def charger_log_page(request, cid, connector=None):
             "connector_links": connector_links,
             "status_url": status_url,
             "log_limit_options": limit_options,
-            "log_limit_index": allowed_values.index(limit_choice),
+            "log_limit_index": limit_index,
+            "log_limit_choice": limit_choice,
+            "log_limit_label": limit_label,
+            "log_download_url": log_download_url,
+            "log_filename": download_filename,
         },
     )
 

pages/admin.py

@@ -1,4 +1,5 @@
 import logging
+from collections import deque
 from pathlib import Path
 
 from django.contrib import admin, messages
@@ -8,8 +9,9 @@ from django import forms
 from django.shortcuts import redirect, render, get_object_or_404
 from django.urls import NoReverseMatch, path, reverse
 from django.utils.html import format_html
+
 from django.template.response import TemplateResponse
-from django.http import JsonResponse
+from django.http import FileResponse, JsonResponse
 from django.utils import timezone
 from django.db.models import Count
 from django.core.exceptions import FieldError
@@ -289,14 +291,19 @@ class ApplicationAdmin(EntityModelAdmin):
 class LandingInline(admin.TabularInline):
     model = Landing
     extra = 0
-    fields = ("path", "label", "enabled")
+    fields = ("path", "label", "enabled", "track_leads")
     show_change_link = True
 
 
 @admin.register(Landing)
 class LandingAdmin(EntityModelAdmin):
-    list_display = ("label", "path", "module", "enabled")
-    list_filter = ("enabled", "module__node_role", "module__application")
+    list_display = ("label", "path", "module", "enabled", "track_leads")
+    list_filter = (
+        "enabled",
+        "track_leads",
+        "module__node_role",
+        "module__application",
+    )
     search_fields = (
         "label",
         "path",
@@ -305,7 +312,7 @@ class LandingAdmin(EntityModelAdmin):
         "module__application__name",
         "module__node_role__name",
     )
-    fields = ("module", "path", "label", "enabled", "description")
+    fields = ("module", "path", "label", "enabled", "track_leads", "description")
     list_select_related = ("module", "module__application", "module__node_role")
 
 
@@ -878,6 +885,13 @@ def favorite_clear(request):
     return redirect("admin:favorite_list")
 
 
+def _read_log_tail(path: Path, limit: int) -> str:
+    """Return the last ``limit`` lines from ``path`` preserving newlines."""
+
+    with path.open("r", encoding="utf-8") as handle:
+        return "".join(deque(handle, maxlen=limit))
+
+
 def log_viewer(request):
     logs_dir = Path(settings.BASE_DIR) / "logs"
     logs_exist = logs_dir.exists() and logs_dir.is_dir()
@@ -895,16 +909,50 @@ def log_viewer(request):
     selected_log = request.GET.get("log", "")
     log_content = ""
     log_error = ""
+    limit_options = [
+        {"value": "20", "label": "20"},
+        {"value": "40", "label": "40"},
+        {"value": "100", "label": "100"},
+        {"value": "all", "label": _("All")},
+    ]
+    allowed_limits = [item["value"] for item in limit_options]
+    limit_choice = request.GET.get("limit", "20")
+    if limit_choice not in allowed_limits:
+        limit_choice = "20"
+    limit_index = allowed_limits.index(limit_choice)
+    download_requested = request.GET.get("download") == "1"
 
     if selected_log:
         if selected_log in available_logs:
             selected_path = logs_dir / selected_log
             try:
-                log_content = selected_path.read_text(encoding="utf-8")
-            except UnicodeDecodeError:
-                log_content = selected_path.read_text(
-                    encoding="utf-8", errors="replace"
-                )
+                if download_requested:
+                    return FileResponse(
+                        selected_path.open("rb"),
+                        as_attachment=True,
+                        filename=selected_log,
+                    )
+                if limit_choice == "all":
+                    try:
+                        log_content = selected_path.read_text(encoding="utf-8")
+                    except UnicodeDecodeError:
+                        log_content = selected_path.read_text(
+                            encoding="utf-8", errors="replace"
+                        )
+                else:
+                    try:
+                        limit_value = int(limit_choice)
+                    except (TypeError, ValueError):
+                        limit_value = 20
+                        limit_choice = "20"
+                        limit_index = allowed_limits.index(limit_choice)
+                    try:
+                        log_content = _read_log_tail(selected_path, limit_value)
+                    except UnicodeDecodeError:
+                        with selected_path.open(
+                            "r", encoding="utf-8", errors="replace"
+                        ) as handle:
+                            log_content = "".join(deque(handle, maxlen=limit_value))
             except OSError as exc:  # pragma: no cover - filesystem edge cases
                 logger.warning("Unable to read log file %s", selected_path, exc_info=exc)
                 log_error = _(
@@ -922,6 +970,7 @@ def log_viewer(request):
     else:
         log_notice = ""
 
+    limit_label = limit_options[limit_index]["label"]
     context = {**admin.site.each_context(request)}
     context.update(
         {
@@ -932,6 +981,10 @@ def log_viewer(request):
             "log_error": log_error,
             "log_notice": log_notice,
             "logs_directory": logs_dir,
+            "log_limit_options": limit_options,
+            "log_limit_index": limit_index,
+            "log_limit_choice": limit_choice,
+            "log_limit_label": limit_label,
         }
     )
     return TemplateResponse(request, "admin/log_viewer.html", context)

pages/context_processors.py

@@ -87,6 +87,17 @@ def nav_links(request):
                 continue
             landings.append(landing)
         if landings:
+            normalized_module_path = module.path.rstrip("/") or "/"
+            if normalized_module_path == "/read":
+                primary_landings = [
+                    landing
+                    for landing in landings
+                    if landing.path.rstrip("/") == normalized_module_path
+                ]
+                if primary_landings:
+                    landings = primary_landings
+                else:
+                    landings = [landings[0]]
             app_name = getattr(module.application, "name", "").lower()
             if app_name == "awg":
                 module.menu = "Calculate"

pages/middleware.py

@@ -126,6 +126,9 @@ class ViewHistoryMiddleware:
         if request.method.upper() != "GET":
             return
 
+        if not getattr(landing, "track_leads", False):
+            return
+
         if not landing_leads_supported():
             return
 

pages/models.py

@@ -1,3 +1,4 @@
+import base64
 import logging
 from pathlib import Path
 
@@ -212,6 +213,7 @@ class Landing(Entity):
     path = models.CharField(max_length=200)
     label = models.CharField(max_length=100)
     enabled = models.BooleanField(default=True)
+    track_leads = models.BooleanField(default=False)
     description = models.TextField(blank=True)
 
     objects = LandingManager()
@@ -435,6 +437,39 @@ class UserManual(Entity):
     def natural_key(self):  # pragma: no cover - simple representation
         return (self.slug,)
 
+    def _ensure_pdf_is_base64(self) -> None:
+        """Normalize ``content_pdf`` so stored values are base64 strings."""
+
+        value = self.content_pdf
+        if value in {None, ""}:
+            self.content_pdf = "" if value is None else value
+            return
+
+        if isinstance(value, (bytes, bytearray, memoryview)):
+            self.content_pdf = base64.b64encode(bytes(value)).decode("ascii")
+            return
+
+        reader = getattr(value, "read", None)
+        if callable(reader):
+            data = reader()
+            if hasattr(value, "seek"):
+                try:
+                    value.seek(0)
+                except Exception:  # pragma: no cover - best effort reset
+                    pass
+            self.content_pdf = base64.b64encode(data).decode("ascii")
+            return
+
+        if isinstance(value, str):
+            stripped = value.strip()
+            if stripped.startswith("data:"):
+                _, _, encoded = stripped.partition(",")
+                self.content_pdf = encoded.strip()
+
+    def save(self, *args, **kwargs):
+        self._ensure_pdf_is_base64()
+        super().save(*args, **kwargs)
+
 
 class ViewHistory(Entity):
     """Record of public site visits."""