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

ocpp/test_rfid.py

@@ -1,4 +1,5 @@
 import io
+import json
 import os
 import sys
 import types
@@ -17,12 +18,13 @@ from django.test import SimpleTestCase, TestCase
 from django.urls import reverse
 from django.contrib.auth import get_user_model
 from django.contrib.sites.models import Site
+from django.utils import timezone
 
 from pages.models import Application, Module
 from nodes.models import Node, NodeRole
 
 from core.models import RFID
-from ocpp.rfid.reader import read_rfid, enable_deep_read
+from ocpp.rfid.reader import read_rfid, enable_deep_read, validate_rfid_value
 from ocpp.rfid.detect import detect_scanner, main as detect_main
 from ocpp.rfid import background_reader
 from ocpp.rfid.constants import (
@@ -71,6 +73,11 @@ class BackgroundReaderConfigurationTests(SimpleTestCase):
 
 
 class ScanNextViewTests(TestCase):
+    def setUp(self):
+        User = get_user_model()
+        self.user = User.objects.create_user("rfid-user", password="pwd")
+        self.client.force_login(self.user)
+
     @patch("config.middleware.Node.get_local", return_value=None)
     @patch("config.middleware.get_site")
     @patch(
@@ -103,6 +110,62 @@ class ScanNextViewTests(TestCase):
         self.assertEqual(resp.status_code, 500)
         self.assertEqual(resp.json(), {"error": "boom"})
 
+    @patch("config.middleware.Node.get_local", return_value=None)
+    @patch("config.middleware.get_site")
+    @patch(
+        "ocpp.rfid.views.validate_rfid_value",
+        return_value={"rfid": "ABCD1234", "label_id": 1, "created": False},
+    )
+    def test_scan_next_post_validates(self, mock_validate, mock_site, mock_node):
+        User = get_user_model()
+        user = User.objects.create_user("scanner", password="pwd")
+        self.client.force_login(user)
+        resp = self.client.post(
+            reverse("rfid-scan-next"),
+            data=json.dumps({"rfid": "ABCD1234"}),
+            content_type="application/json",
+        )
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(
+            resp.json(), {"rfid": "ABCD1234", "label_id": 1, "created": False}
+        )
+        mock_validate.assert_called_once_with("ABCD1234", kind=None)
+
+    @patch("config.middleware.Node.get_local", return_value=None)
+    @patch("config.middleware.get_site")
+    @patch("ocpp.rfid.views.validate_rfid_value")
+    def test_scan_next_post_requires_authentication(
+        self, mock_validate, mock_site, mock_node
+    ):
+        resp = self.client.post(
+            reverse("rfid-scan-next"),
+            data=json.dumps({"rfid": "ABCD1234"}),
+            content_type="application/json",
+        )
+        self.assertEqual(resp.status_code, 401)
+        self.assertEqual(resp.json(), {"error": "Authentication required"})
+        mock_validate.assert_not_called()
+
+    @patch("config.middleware.Node.get_local", return_value=None)
+    @patch("config.middleware.get_site")
+    def test_scan_next_post_invalid_json(self, mock_site, mock_node):
+        User = get_user_model()
+        user = User.objects.create_user("invalid-json", password="pwd")
+        self.client.force_login(user)
+        resp = self.client.post(
+            reverse("rfid-scan-next"),
+            data="{",
+            content_type="application/json",
+        )
+        self.assertEqual(resp.status_code, 400)
+        self.assertEqual(resp.json(), {"error": "Invalid JSON payload"})
+
+    def test_scan_next_requires_authentication(self):
+        self.client.logout()
+        resp = self.client.get(reverse("rfid-scan-next"))
+        self.assertEqual(resp.status_code, 302)
+        self.assertIn(reverse("pages:login"), resp.url)
+
 
 class ReaderNotificationTests(TestCase):
     def _mock_reader(self):
@@ -171,6 +234,74 @@ class ReaderNotificationTests(TestCase):
         self.assertTrue(getattr(reader, "stop_called", False))
 
 
+class ValidateRfidValueTests(SimpleTestCase):
+    @patch("ocpp.rfid.reader.timezone.now")
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.RFID.objects.get_or_create")
+    def test_creates_new_tag(self, mock_get, mock_notify, mock_now):
+        fake_now = object()
+        mock_now.return_value = fake_now
+        tag = MagicMock()
+        tag.pk = 1
+        tag.label_id = 1
+        tag.allowed = True
+        tag.color = "B"
+        tag.released = False
+        tag.reference = None
+        tag.kind = RFID.CLASSIC
+        mock_get.return_value = (tag, True)
+
+        result = validate_rfid_value("abcd1234")
+
+        mock_get.assert_called_once_with(rfid="ABCD1234", defaults={})
+        tag.save.assert_called_once_with(update_fields=["last_seen_on"])
+        self.assertIs(tag.last_seen_on, fake_now)
+        mock_notify.assert_called_once_with("RFID 1 OK", "ABCD1234 B")
+        self.assertTrue(result["created"])
+        self.assertEqual(result["rfid"], "ABCD1234")
+
+    @patch("ocpp.rfid.reader.timezone.now")
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.RFID.objects.get_or_create")
+    def test_updates_existing_tag_kind(self, mock_get, mock_notify, mock_now):
+        fake_now = object()
+        mock_now.return_value = fake_now
+        tag = MagicMock()
+        tag.pk = 5
+        tag.label_id = 5
+        tag.allowed = False
+        tag.color = "G"
+        tag.released = True
+        tag.reference = None
+        tag.kind = RFID.CLASSIC
+        mock_get.return_value = (tag, False)
+
+        result = validate_rfid_value("abcd", kind=RFID.NTAG215)
+
+        mock_get.assert_called_once_with(
+            rfid="ABCD", defaults={"kind": RFID.NTAG215}
+        )
+        tag.save.assert_called_once_with(update_fields=["kind", "last_seen_on"])
+        self.assertIs(tag.last_seen_on, fake_now)
+        self.assertEqual(tag.kind, RFID.NTAG215)
+        mock_notify.assert_called_once_with("RFID 5 BAD", "ABCD G")
+        self.assertFalse(result["allowed"])
+        self.assertFalse(result["created"])
+        self.assertEqual(result["kind"], RFID.NTAG215)
+
+    def test_rejects_invalid_value(self):
+        result = validate_rfid_value("invalid!")
+        self.assertEqual(result, {"error": "RFID must be hexadecimal digits"})
+
+    def test_rejects_non_string_values(self):
+        result = validate_rfid_value(12345)
+        self.assertEqual(result, {"error": "RFID must be a string"})
+
+    def test_rejects_missing_value(self):
+        result = validate_rfid_value(None)
+        self.assertEqual(result, {"error": "RFID value is required"})
+
+
 class CardTypeDetectionTests(TestCase):
     def _mock_ntag_reader(self):
         class MockReader:
@@ -301,7 +432,12 @@ class RFIDDetectionScriptTests(SimpleTestCase):
         mock_detect.assert_called_once()
 
 
-class RestartViewTests(SimpleTestCase):
+class RestartViewTests(TestCase):
+    def setUp(self):
+        User = get_user_model()
+        self.user = User.objects.create_user("restart-user", password="pwd")
+        self.client.force_login(self.user)
+
     @patch("config.middleware.Node.get_local", return_value=None)
     @patch("config.middleware.get_site")
     @patch("ocpp.rfid.views.restart_sources", return_value={"status": "restarted"})
@@ -311,8 +447,19 @@ class RestartViewTests(SimpleTestCase):
         self.assertEqual(resp.json(), {"status": "restarted"})
         mock_restart.assert_called_once()
 
+    def test_restart_requires_authentication(self):
+        self.client.logout()
+        resp = self.client.post(reverse("rfid-scan-restart"))
+        self.assertEqual(resp.status_code, 302)
+        self.assertIn(reverse("pages:login"), resp.url)
+
+
+class ScanTestViewTests(TestCase):
+    def setUp(self):
+        User = get_user_model()
+        self.user = User.objects.create_user("scan-test-user", password="pwd")
+        self.client.force_login(self.user)
 
-class ScanTestViewTests(SimpleTestCase):
     @patch("config.middleware.Node.get_local", return_value=None)
     @patch("config.middleware.get_site")
     @patch("ocpp.rfid.views.test_sources", return_value={"irq_pin": 7})
@@ -332,6 +479,12 @@ class ScanTestViewTests(SimpleTestCase):
         self.assertEqual(resp.status_code, 500)
         self.assertEqual(resp.json(), {"error": "no scanner detected"})
 
+    def test_scan_test_requires_authentication(self):
+        self.client.logout()
+        resp = self.client.get(reverse("rfid-scan-test"))
+        self.assertEqual(resp.status_code, 302)
+        self.assertIn(reverse("pages:login"), resp.url)
+
 
 class RFIDLandingTests(TestCase):
     def test_scanner_view_registered_as_landing(self):
@@ -352,6 +505,8 @@ class RFIDLandingTests(TestCase):
 class ScannerTemplateTests(TestCase):
     def setUp(self):
         self.url = reverse("rfid-reader")
+        User = get_user_model()
+        self.user = User.objects.create_user("scanner-user", password="pwd")
 
     def test_configure_link_for_staff(self):
         User = get_user_model()
@@ -360,9 +515,11 @@ class ScannerTemplateTests(TestCase):
         resp = self.client.get(self.url)
         self.assertContains(resp, 'id="rfid-configure"')
 
-    def test_no_link_for_anonymous(self):
+    def test_redirect_for_anonymous(self):
+        self.client.logout()
         resp = self.client.get(self.url)
-        self.assertNotContains(resp, 'id="rfid-configure"')
+        self.assertEqual(resp.status_code, 302)
+        self.assertIn(reverse("pages:login"), resp.url)
 
     def test_advanced_fields_for_staff(self):
         User = get_user_model()
@@ -374,9 +531,12 @@ class ScannerTemplateTests(TestCase):
         self.assertContains(resp, 'id="rfid-released"')
         self.assertContains(resp, 'id="rfid-reference"')
 
-    def test_basic_fields_for_public(self):
+    def test_basic_fields_for_authenticated_user(self):
+        self.client.logout()
+        self.client.force_login(self.user)
         resp = self.client.get(self.url)
         self.assertContains(resp, 'id="rfid-kind"')
+        self.assertNotContains(resp, 'id="rfid-connect-local"')
         self.assertNotContains(resp, 'id="rfid-rfid"')
         self.assertNotContains(resp, 'id="rfid-released"')
         self.assertNotContains(resp, 'id="rfid-reference"')
@@ -388,7 +548,9 @@ class ScannerTemplateTests(TestCase):
         resp = self.client.get(self.url)
         self.assertContains(resp, 'id="rfid-deep-read"')
 
-    def test_no_deep_read_button_for_public(self):
+    def test_no_deep_read_button_for_authenticated_user(self):
+        self.client.logout()
+        self.client.force_login(self.user)
         resp = self.client.get(self.url)
         self.assertNotContains(resp, 'id="rfid-deep-read"')
 

ocpp/tests.py

@@ -141,6 +141,17 @@ class ChargerUrlFallbackTests(TestCase):
         self.assertTrue(charger.reference.value.startswith("http://fallback.example"))
         self.assertTrue(charger.reference.value.endswith("/c/NO_SITE/"))
 
+    def test_reference_not_created_for_loopback_domain(self):
+        site = Site.objects.get_current()
+        site.domain = "127.0.0.1"
+        site.save()
+        Site.objects.clear_cache()
+
+        charger = Charger.objects.create(charger_id="LOCAL_LOOP")
+        charger.refresh_from_db()
+
+        self.assertIsNone(charger.reference)
+
 
 class SinkConsumerTests(TransactionTestCase):
     async def test_sink_replies(self):
@@ -667,6 +678,25 @@ class CSMSConsumerTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    async def test_console_reference_skips_loopback_ip(self):
+        communicator = ClientWebsocketCommunicator(
+            application,
+            "/LOCAL/",
+            client=("127.0.0.1", 34567),
+        )
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        await communicator.send_json_to([2, "1", "BootNotification", {}])
+        await communicator.receive_json_from()
+
+        exists = await database_sync_to_async(
+            lambda: Reference.objects.filter(alt_text="LOCAL Console").exists()
+        )()
+        self.assertFalse(exists)
+
+        await communicator.disconnect()
+
     async def test_transaction_created_from_meter_values(self):
         communicator = WebsocketCommunicator(application, "/NOSTART/")
         connected, _ = await communicator.connect()

ocpp/views.py

@@ -464,6 +464,7 @@ 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")
@@ -500,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
@@ -526,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

@@ -39,12 +39,12 @@ 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)
@@ -52,8 +52,8 @@ def nav_links(request):
             app_name = getattr(module.application, "name", "").lower()
             if app_name == "awg":
                 module.menu = "Calculate"
-            elif app_name == "man":
-                module.menu = "Manuals"
+            elif module.path.rstrip("/").lower() == "/man":
+                module.menu = "Manual"
             module.enabled_landings = landings
             valid_modules.append(module)
             if request.path.startswith(module.path):

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/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):

pages/tests.py

@@ -1042,9 +1042,9 @@ class PowerNavTests(TestCase):
             node_role=role, application=awg_app, path="/awg/"
         )
         awg_module.create_landings()
-        man_app, _ = Application.objects.get_or_create(name="man")
+        manuals_app, _ = Application.objects.get_or_create(name="pages")
         man_module, _ = Module.objects.get_or_create(
-            node_role=role, application=man_app, path="/man/"
+            node_role=role, application=manuals_app, path="/man/"
         )
         man_module.create_landings()
         User = get_user_model()
@@ -1070,7 +1070,7 @@ class PowerNavTests(TestCase):
                 manuals_module = module
                 break
         self.assertIsNotNone(manuals_module)
-        self.assertEqual(manuals_module.menu_label.upper(), "MANUALS")
+        self.assertEqual(manuals_module.menu_label.upper(), "MANUAL")
         landing_labels = {landing.label for landing in manuals_module.enabled_landings}
         self.assertIn("Manuals", landing_labels)
 
@@ -1163,6 +1163,13 @@ class ApplicationAdminDisplayTests(TestCase):
         config = django_apps.get_app_config("ocpp")
         self.assertContains(resp, config.verbose_name)
 
+    def test_changelist_shows_description(self):
+        Application.objects.create(
+            name="awg", description="Power, Energy and Cost calculations."
+        )
+        resp = self.client.get(reverse("admin:pages_application_changelist"))
+        self.assertContains(resp, "Power, Energy and Cost calculations.")
+
 
 class LandingCreationTests(TestCase):
     def setUp(self):
@@ -1231,8 +1238,16 @@ class RFIDPageTests(TestCase):
         Site.objects.update_or_create(
             id=1, defaults={"domain": "testserver", "name": "pages"}
         )
+        User = get_user_model()
+        self.user = User.objects.create_user("rfid-user", password="pwd")
 
-    def test_page_renders(self):
+    def test_page_redirects_when_anonymous(self):
+        resp = self.client.get(reverse("rfid-reader"))
+        self.assertEqual(resp.status_code, 302)
+        self.assertIn(reverse("pages:login"), resp.url)
+
+    def test_page_renders_for_authenticated_user(self):
+        self.client.force_login(self.user)
         resp = self.client.get(reverse("rfid-reader"))
         self.assertContains(resp, "Scanner ready")
 

pages/urls.py

@@ -18,4 +18,7 @@ urlpatterns = [
         name="invitation-login",
     ),
     path("datasette-auth/", views.datasette_auth, name="datasette-auth"),
+    path("man/", views.manual_list, name="manual-list"),
+    path("man/<slug:slug>/", views.manual_detail, name="manual-detail"),
+    path("man/<slug:slug>/pdf/", views.manual_pdf, name="manual-pdf"),
 ]