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

ocpp/test_rfid.py

@@ -519,6 +519,76 @@ class ValidateRfidValueTests(SimpleTestCase):
         mock_popen.assert_not_called()
         self.assertEqual(result["endianness"], RFID.BIG_ENDIAN)
 
+    @patch("ocpp.rfid.reader.timezone.now")
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.subprocess.Popen")
+    @patch("ocpp.rfid.reader.subprocess.run")
+    @patch("ocpp.rfid.reader.RFID.register_scan")
+    def test_external_command_strips_trailing_percent_tokens(
+        self, mock_register, mock_run, mock_popen, mock_notify, mock_now
+    ):
+        mock_now.return_value = timezone.now()
+        tag = MagicMock()
+        tag.pk = 3
+        tag.label_id = 3
+        tag.allowed = True
+        tag.external_command = "echo weird"
+        tag.color = "Y"
+        tag.released = False
+        tag.reference = None
+        tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.BIG_ENDIAN
+        mock_register.return_value = (tag, False)
+        mock_run.return_value = types.SimpleNamespace(
+            returncode=0,
+            stdout="first %\nsecond 50%\r\nthird % %\n",
+            stderr="oops %\n",
+        )
+
+        result = validate_rfid_value("abc3")
+
+        output = result.get("command_output")
+        self.assertIsNotNone(output)
+        self.assertEqual(
+            output.get("stdout"), "first\nsecond 50%\r\nthird\n"
+        )
+        self.assertEqual(output.get("stderr"), "oops\n")
+        self.assertEqual(output.get("returncode"), 0)
+        self.assertEqual(output.get("error"), "")
+        mock_popen.assert_not_called()
+
+    @patch("ocpp.rfid.reader.timezone.now")
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.subprocess.Popen")
+    @patch("ocpp.rfid.reader.subprocess.run")
+    @patch("ocpp.rfid.reader.RFID.register_scan")
+    def test_external_command_error_strips_trailing_percent_tokens(
+        self, mock_register, mock_run, mock_popen, mock_notify, mock_now
+    ):
+        mock_now.return_value = timezone.now()
+        tag = MagicMock()
+        tag.pk = 4
+        tag.label_id = 4
+        tag.allowed = True
+        tag.external_command = "echo boom"
+        tag.color = "R"
+        tag.released = False
+        tag.reference = None
+        tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.BIG_ENDIAN
+        mock_register.return_value = (tag, False)
+        mock_run.side_effect = RuntimeError("bad % %")
+
+        result = validate_rfid_value("abcd")
+
+        output = result.get("command_output")
+        self.assertIsInstance(output, dict)
+        self.assertEqual(output.get("stdout"), "")
+        self.assertEqual(output.get("stderr"), "")
+        self.assertEqual(output.get("error"), "bad")
+        self.assertFalse(result["allowed"])
+        mock_popen.assert_not_called()
+
     @patch("ocpp.rfid.reader.timezone.now")
     @patch("ocpp.rfid.reader.notify_async")
     @patch("ocpp.rfid.reader.subprocess.Popen")

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")
@@ -2949,6 +2962,44 @@ class SimulatorAdminTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    async def test_authorize_requires_rfid_accepts_allowed_tag_without_account(self):
+        charger_id = "AUTHWARN"
+        tag_value = "WARN01"
+        await database_sync_to_async(Charger.objects.create)(
+            charger_id=charger_id, require_rfid=True
+        )
+        await database_sync_to_async(RFID.objects.create)(rfid=tag_value, allowed=True)
+
+        pending_key = store.pending_key(charger_id)
+        store.clear_log(pending_key, log_type="charger")
+
+        communicator = WebsocketCommunicator(application, f"/{charger_id}/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        message_id = "auth-unlinked"
+        await communicator.send_json_to(
+            [2, message_id, "Authorize", {"idTag": tag_value}]
+        )
+        response = await communicator.receive_json_from()
+        self.assertEqual(response[0], 3)
+        self.assertEqual(response[1], message_id)
+        self.assertEqual(response[2], {"idTagInfo": {"status": "Accepted"}})
+
+        log_entries = store.get_logs(pending_key, log_type="charger")
+        self.assertTrue(
+            any(
+                "Authorized RFID" in entry
+                and tag_value in entry
+                and charger_id in entry
+                for entry in log_entries
+            ),
+            log_entries,
+        )
+
+        await communicator.disconnect()
+        store.clear_log(pending_key, log_type="charger")
+
     async def test_authorize_without_requirement_records_rfid(self):
         await database_sync_to_async(Charger.objects.create)(
             charger_id="AUTHOPT", require_rfid=False
@@ -3041,6 +3092,61 @@ class SimulatorAdminTests(TransactionTestCase):
         )
         self.assertEqual(tx.account_id, user.energy_account.id)
 
+    async def test_start_transaction_allows_allowed_tag_without_account(self):
+        charger_id = "STARTWARN"
+        tag_value = "WARN02"
+        await database_sync_to_async(Charger.objects.create)(
+            charger_id=charger_id, require_rfid=True
+        )
+        await database_sync_to_async(RFID.objects.create)(rfid=tag_value, allowed=True)
+
+        pending_key = store.pending_key(charger_id)
+        store.clear_log(pending_key, log_type="charger")
+
+        communicator = WebsocketCommunicator(application, f"/{charger_id}/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        start_payload = {
+            "meterStart": 5,
+            "idTag": tag_value,
+            "connectorId": 1,
+        }
+        await communicator.send_json_to([2, "start-1", "StartTransaction", start_payload])
+        response = await communicator.receive_json_from()
+        self.assertEqual(response[0], 3)
+        self.assertEqual(response[2]["idTagInfo"]["status"], "Accepted")
+        tx_id = response[2]["transactionId"]
+
+        tx = await database_sync_to_async(Transaction.objects.get)(
+            pk=tx_id, charger__charger_id=charger_id
+        )
+        self.assertIsNone(tx.account_id)
+
+        log_entries = store.get_logs(pending_key, log_type="charger")
+        self.assertTrue(
+            any(
+                "Authorized RFID" in entry
+                and tag_value in entry
+                and charger_id in entry
+                for entry in log_entries
+            ),
+            log_entries,
+        )
+
+        await communicator.send_json_to(
+            [
+                2,
+                "stop-1",
+                "StopTransaction",
+                {"transactionId": tx_id, "meterStop": 6},
+            ]
+        )
+        await communicator.receive_json_from()
+
+        await communicator.disconnect()
+        store.clear_log(pending_key, log_type="charger")
+
     async def test_status_fields_updated(self):
         communicator = WebsocketCommunicator(application, "/STAT/")
         connected, _ = await communicator.connect()

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,17 +1235,65 @@ def charger_log_page(request, cid, connector=None):
             charger_id=cid
         )
         target_id = cid
-    log = store.get_logs(target_id, log_type=log_type)
+
+    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": "20", "label": "20"},
+        {"value": "40", "label": "40"},
+        {"value": "100", "label": "100"},
+        {"value": "all", "label": gettext("All")},
+    ]
+    allowed_values = [item["value"] for item in limit_options]
+    limit_choice = request.GET.get("limit", "20")
+    if limit_choice not in allowed_values:
+        limit_choice = "20"
+    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",
         {
             "charger": charger,
-            "log": log,
+            "log": log_entries,
             "log_type": log_type,
             "connector_slug": connector_slug,
             "connector_links": connector_links,
             "status_url": status_url,
+            "log_limit_options": limit_options,
+            "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
@@ -6,12 +7,14 @@ from django.contrib.sites.admin import SiteAdmin as DjangoSiteAdmin
 from django.contrib.sites.models import Site
 from django import forms
 from django.shortcuts import redirect, render, get_object_or_404
-from django.urls import path, reverse
+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
 from django.db.models.functions import TruncDate
 from datetime import datetime, time, timedelta
 import ipaddress
@@ -25,6 +28,7 @@ from nodes.utils import capture_screenshot, save_screenshot
 
 from .forms import UserManualAdminForm
 from .module_defaults import reload_default_modules as restore_default_modules
+from .site_config import ensure_site_fields
 from .utils import landing_leads_supported
 
 from .models import (
@@ -41,6 +45,7 @@ from .models import (
     UserStory,
 )
 from django.contrib.contenttypes.models import ContentType
+from core.models import ReleaseManager
 from core.user_data import EntityModelAdmin
 
 
@@ -73,12 +78,47 @@ class SiteForm(forms.ModelForm):
         fields = "__all__"
 
 
+ensure_site_fields()
+
+
+class _BooleanAttributeListFilter(admin.SimpleListFilter):
+    """Filter helper for boolean attributes on :class:`~django.contrib.sites.models.Site`."""
+
+    field_name: str
+
+    def lookups(self, request, model_admin):  # pragma: no cover - admin UI
+        return (("1", _("Yes")), ("0", _("No")))
+
+    def queryset(self, request, queryset):
+        value = self.value()
+        if value not in {"0", "1"}:
+            return queryset
+        expected = value == "1"
+        try:
+            return queryset.filter(**{self.field_name: expected})
+        except FieldError:  # pragma: no cover - defensive when fields missing
+            return queryset
+
+
+class ManagedSiteListFilter(_BooleanAttributeListFilter):
+    title = _("Managed by local NGINX")
+    parameter_name = "managed"
+    field_name = "managed"
+
+
+class RequireHttpsListFilter(_BooleanAttributeListFilter):
+    title = _("Require HTTPS")
+    parameter_name = "require_https"
+    field_name = "require_https"
+
+
 class SiteAdmin(DjangoSiteAdmin):
     form = SiteForm
     inlines = [SiteBadgeInline]
     change_list_template = "admin/sites/site/change_list.html"
-    fields = ("domain", "name")
-    list_display = ("domain", "name")
+    fields = ("domain", "name", "managed", "require_https")
+    list_display = ("domain", "name", "managed", "require_https")
+    list_filter = (ManagedSiteListFilter, RequireHttpsListFilter)
     actions = ["capture_screenshot"]
 
     @admin.action(description="Capture screenshot")
@@ -110,6 +150,27 @@ class SiteAdmin(DjangoSiteAdmin):
                     messages.INFO,
                 )
 
+    def save_model(self, request, obj, form, change):
+        super().save_model(request, obj, form, change)
+        if {"managed", "require_https"} & set(form.changed_data or []):
+            self.message_user(
+                request,
+                _(
+                    "Managed NGINX configuration staged. Run network-setup.sh to apply changes."
+                ),
+                messages.INFO,
+            )
+
+    def delete_model(self, request, obj):
+        super().delete_model(request, obj)
+        self.message_user(
+            request,
+            _(
+                "Managed NGINX configuration staged. Run network-setup.sh to apply changes."
+            ),
+            messages.INFO,
+        )
+
     def _reload_site_fixtures(self, request):
         fixtures_dir = Path(settings.BASE_DIR) / "core" / "fixtures"
         fixture_paths = sorted(fixtures_dir.glob("references__00_site_*.json"))
@@ -230,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",
@@ -246,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")
 
 
@@ -708,10 +774,33 @@ class UserStoryAdmin(EntityModelAdmin):
                 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)
+                message = _("Unable to create a GitHub issue for %(story)s: %(error)s") % {
+                    "story": story,
+                    "error": exc,
+                }
+
+                if (
+                    isinstance(exc, RuntimeError)
+                    and "GitHub token is not configured" in str(exc)
+                ):
+                    try:
+                        opts = ReleaseManager._meta
+                        config_url = reverse(
+                            f"{self.admin_site.name}:{opts.app_label}_{opts.model_name}_changelist"
+                        )
+                    except NoReverseMatch:  # pragma: no cover - defensive guard
+                        config_url = None
+                    if config_url:
+                        message = format_html(
+                            "{} <a href=\"{}\">{}</a>",
+                            message,
+                            config_url,
+                            _("Configure GitHub credentials."),
+                        )
+
                 self.message_user(
                     request,
-                    _("Unable to create a GitHub issue for %(story)s: %(error)s")
-                    % {"story": story, "error": exc},
+                    message,
                     messages.ERROR,
                 )
                 continue
@@ -796,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()
@@ -813,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 = _(
@@ -840,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(
         {
@@ -850,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/apps.py

@@ -8,3 +8,6 @@ class PagesConfig(AppConfig):
 
     def ready(self):  # pragma: no cover - import for side effects
         from . import checks  # noqa: F401
+        from . import site_config
+
+        site_config.ready()

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