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

core/tests.py

@@ -20,6 +20,7 @@ import types
 from glob import glob
 from datetime import datetime, timedelta, timezone as datetime_timezone
 import tempfile
+from io import StringIO
 from urllib.parse import quote
 
 from django.utils import timezone
@@ -57,6 +58,7 @@ from nodes.models import ContentSample
 
 from django.core.exceptions import ValidationError
 from django.core.management import call_command
+from django.core.management.base import CommandError
 from django.db import IntegrityError
 from .backends import LocalhostAdminBackend
 from core.views import (
@@ -983,6 +985,40 @@ class RFIDImportExportCommandTests(TestCase):
         self.assertTrue(tag.energy_accounts.filter(pk=account.pk).exists())
 
 
+class CheckRFIDCommandTests(TestCase):
+    def test_successful_validation_outputs_json(self):
+        out = StringIO()
+
+        call_command("check_rfid", "abcd1234", stdout=out)
+
+        payload = json.loads(out.getvalue())
+        self.assertEqual(payload["rfid"], "ABCD1234")
+        self.assertTrue(payload["created"])
+        self.assertTrue(RFID.objects.filter(rfid="ABCD1234").exists())
+
+    def test_invalid_value_raises_error(self):
+        with self.assertRaises(CommandError):
+            call_command("check_rfid", "invalid!")
+
+    def test_kind_option_updates_existing_tag(self):
+        tag = RFID.objects.create(rfid="EXISTING", allowed=False, kind=RFID.CLASSIC)
+        out = StringIO()
+
+        call_command(
+            "check_rfid",
+            "existing",
+            "--kind",
+            RFID.NTAG215,
+            stdout=out,
+        )
+
+        payload = json.loads(out.getvalue())
+        tag.refresh_from_db()
+        self.assertFalse(payload["created"])
+        self.assertEqual(payload["kind"], RFID.NTAG215)
+        self.assertEqual(tag.kind, RFID.NTAG215)
+
+
 class RFIDKeyVerificationFlagTests(TestCase):
     def test_flags_reset_on_key_change(self):
         tag = RFID.objects.create(
@@ -1037,6 +1073,44 @@ class ReleaseProcessTests(TestCase):
         )
         sync_main.assert_called_once_with(Path("rel.log"))
 
+    def test_step_check_todos_logs_instruction_when_pending(self):
+        log_path = Path("rel.log")
+        log_path.unlink(missing_ok=True)
+        Todo.objects.create(request="Review checklist")
+        ctx: dict[str, object] = {}
+
+        try:
+            with self.assertRaises(core_views.PendingTodos):
+                core_views._step_check_todos(self.release, ctx, log_path)
+
+            contents = log_path.read_text(encoding="utf-8")
+            message = "Release checklist requires acknowledgment before continuing."
+            self.assertIn(message, contents)
+            self.assertIn("Review outstanding TODO items", contents)
+
+            with self.assertRaises(core_views.PendingTodos):
+                core_views._step_check_todos(self.release, ctx, log_path)
+
+            contents = log_path.read_text(encoding="utf-8")
+            self.assertEqual(contents.count(message), 1)
+        finally:
+            log_path.unlink(missing_ok=True)
+
+    def test_step_check_todos_auto_ack_when_no_pending(self):
+        log_path = Path("rel.log")
+        log_path.unlink(missing_ok=True)
+        ctx: dict[str, object] = {}
+
+        try:
+            with mock.patch("core.views._refresh_changelog_once"):
+                core_views._step_check_todos(self.release, ctx, log_path)
+        finally:
+            log_path.unlink(missing_ok=True)
+
+        self.assertTrue(ctx.get("todos_ack"))
+        self.assertNotIn("todos_required", ctx)
+        self.assertIsNone(ctx.get("todos"))
+
     @mock.patch("core.views._sync_with_origin_main")
     @mock.patch("core.views.release_utils._git_clean", return_value=True)
     @mock.patch("core.views.release_utils.network_available", return_value=False)
@@ -1527,6 +1601,54 @@ class ReleaseProcessTests(TestCase):
         ctx = session.get(f"release_publish_{self.release.pk}")
         self.assertTrue(ctx.get("dry_run"))
 
+    def test_resume_button_shown_when_credentials_missing(self):
+        user = User.objects.create_superuser("admin", "admin@example.com", "pw")
+        url = reverse("release-progress", args=[self.release.pk, "publish"])
+        self.client.force_login(user)
+
+        self.client.get(f"{url}?start=1")
+
+        session = self.client.session
+        ctx = session.get(f"release_publish_{self.release.pk}") or {}
+        ctx.update({"step": 7, "started": True, "paused": False})
+        session[f"release_publish_{self.release.pk}"] = ctx
+        session.save()
+
+        response = self.client.get(f"{url}?step=7")
+        self.assertEqual(response.status_code, 200)
+        context = response.context
+        if isinstance(context, list):
+            context = context[-1]
+        self.assertTrue(context["resume_available"])
+        self.assertIn(b"Resume Publish", response.content)
+
+    def test_resume_without_step_parameter_defaults_to_current_progress(self):
+        run: list[str] = []
+
+        def step_fn(release, ctx, log_path):
+            run.append("step")
+
+        steps = [("Only step", step_fn)]
+        user = User.objects.create_superuser("admin", "admin@example.com", "pw")
+        url = reverse("release-progress", args=[self.release.pk, "publish"])
+        with mock.patch("core.views.PUBLISH_STEPS", steps):
+            self.client.force_login(user)
+            session = self.client.session
+            session[f"release_publish_{self.release.pk}"] = {
+                "step": 0,
+                "started": True,
+                "paused": False,
+            }
+            session.save()
+
+            response = self.client.get(f"{url}?resume=1")
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(run, ["step"])
+
+            session = self.client.session
+            ctx = session.get(f"release_publish_{self.release.pk}")
+            self.assertEqual(ctx.get("step"), 1)
+
     def test_new_todo_does_not_reset_pending_flow(self):
         user = User.objects.create_superuser("admin", "admin@example.com", "pw")
         url = reverse("release-progress", args=[self.release.pk, "publish"])

core/views.py

@@ -656,8 +656,8 @@ def _should_use_python_changelog(exc: OSError) -> bool:
 def _generate_changelog_with_python(log_path: Path) -> None:
     _append_log(log_path, "Falling back to Python changelog generator")
     changelog_path = Path("CHANGELOG.rst")
-    range_spec = changelog_utils.determine_range_spec()
     previous = changelog_path.read_text(encoding="utf-8") if changelog_path.exists() else None
+    range_spec = changelog_utils.determine_range_spec(previous_text=previous)
     sections = changelog_utils.collect_sections(range_spec=range_spec, previous_text=previous)
     content = changelog_utils.render_changelog(sections)
     if not content.endswith("\n"):
@@ -897,7 +897,18 @@ def _step_check_todos(release, ctx, log_path: Path) -> None:
     pending_values = list(
         pending_qs.values("id", "request", "url", "request_details")
     )
+    if not pending_values:
+        ctx["todos_ack"] = True
+
     if not ctx.get("todos_ack"):
+        if not ctx.get("todos_block_logged"):
+            _append_log(
+                log_path,
+                "Release checklist requires acknowledgment before continuing. "
+                "Review outstanding TODO items and confirm the checklist; "
+                "publishing will resume automatically afterward.",
+            )
+            ctx["todos_block_logged"] = True
         ctx["todos"] = pending_values
         ctx["todos_required"] = True
         raise PendingTodos()
@@ -1451,12 +1462,29 @@ def _step_publish(release, ctx, log_path: Path) -> None:
         )
     else:
         _append_log(log_path, "Uploading distribution")
-    release_utils.publish(
-        package=release.to_package(),
-        version=release.version,
-        creds=release.to_credentials(),
-        repositories=targets,
-    )
+    publish_warning: release_utils.PostPublishWarning | None = None
+    try:
+        release_utils.publish(
+            package=release.to_package(),
+            version=release.version,
+            creds=release.to_credentials(),
+            repositories=targets,
+        )
+    except release_utils.PostPublishWarning as warning:
+        publish_warning = warning
+
+    if publish_warning is not None:
+        message = str(publish_warning)
+        followups = _dedupe_preserve_order(publish_warning.followups)
+        warning_entries = ctx.setdefault("warnings", [])
+        if not any(entry.get("message") == message for entry in warning_entries):
+            entry: dict[str, object] = {"message": message}
+            if followups:
+                entry["followups"] = followups
+            warning_entries.append(entry)
+        _append_log(log_path, message)
+        for note in followups:
+            _append_log(log_path, f"Follow-up: {note}")
     release.pypi_url = (
         f"https://pypi.org/project/{release.package.name}/{release.version}/"
     )
@@ -1804,8 +1832,16 @@ def release_progress(request, pk: int, action: str):
             ctx["release_approval"] = "approved"
         if request.GET.get("reject"):
             ctx["release_approval"] = "rejected"
+    resume_requested = bool(request.GET.get("resume"))
+
     if request.GET.get("pause") and ctx.get("started"):
         ctx["paused"] = True
+
+    if resume_requested:
+        if not ctx.get("started"):
+            ctx["started"] = True
+        if ctx.get("paused"):
+            ctx["paused"] = False
     restart_count = 0
     if restart_path.exists():
         try:
@@ -1814,6 +1850,8 @@ def release_progress(request, pk: int, action: str):
             restart_count = 0
     step_count = ctx.get("step", 0)
     step_param = request.GET.get("step")
+    if resume_requested and step_param is None:
+        step_param = str(step_count)
 
     pending_qs = Todo.objects.filter(is_deleted=False, done_on__isnull=True)
     pending_items = list(pending_qs)
@@ -1833,6 +1871,9 @@ def release_progress(request, pk: int, action: str):
         else:
             ctx["todos_ack"] = True
 
+    if ctx.get("todos_ack"):
+        ctx.pop("todos_block_logged", None)
+
     if not ctx.get("todos_ack"):
         ctx["todos"] = [
             {
@@ -2049,6 +2090,14 @@ def release_progress(request, pk: int, action: str):
         )
 
     is_running = ctx.get("started") and not paused and not done and not ctx.get("error")
+    resume_available = (
+        ctx.get("started")
+        and not paused
+        and not done
+        and not ctx.get("error")
+        and step_count < len(steps)
+        and next_step is None
+    )
     can_resume = ctx.get("started") and paused and not done and not ctx.get("error")
     release_manager_owner = manager.owner_display() if manager else ""
     try:
@@ -2103,9 +2152,11 @@ def release_progress(request, pk: int, action: str):
         "has_release_manager": bool(manager),
         "current_user_admin_url": current_user_admin_url,
         "is_running": is_running,
+        "resume_available": resume_available,
         "can_resume": can_resume,
         "dry_run": dry_run_active,
         "dry_run_toggle_enabled": dry_run_toggle_enabled,
+        "warnings": ctx.get("warnings", []),
     }
     request.session[session_key] = ctx
     if done or ctx.get("error"):

ocpp/admin.py

@@ -29,6 +29,7 @@ from .transactions_io import (
     import_transactions as import_transactions_data,
 )
 from .status_display import STATUS_BADGE_MAP, ERROR_OK_VALUES
+from .views import _charger_state, _live_sessions
 from core.admin import SaveBeforeChangeAction
 from core.user_data import EntityModelAdmin
 
@@ -253,6 +254,8 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
     actions = [
         "purge_data",
         "fetch_cp_configuration",
+        "toggle_rfid_authentication",
+        "recheck_charger_status",
         "change_availability_operative",
         "change_availability_inoperative",
         "set_availability_state_operative",
@@ -317,16 +320,14 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
             "charger-status-connector",
             args=[obj.charger_id, obj.connector_slug],
         )
-        label = (obj.last_status or "status").strip() or "status"
-        status_key = label.lower()
-        error_code = (obj.last_error_code or "").strip().lower()
-        if (
-            self._has_active_session(obj)
-            and error_code in ERROR_OK_VALUES
-            and (status_key not in STATUS_BADGE_MAP or status_key == "available")
-        ):
-            label = STATUS_BADGE_MAP["charging"][0]
-        return format_html('<a href="{}" target="_blank">{}</a>', url, label)
+        tx_obj = store.get_transaction(obj.charger_id, obj.connector_id)
+        state, _ = _charger_state(
+            obj,
+            tx_obj
+            if obj.connector_id is not None
+            else (_live_sessions(obj) or None),
+        )
+        return format_html('<a href="{}" target="_blank">{}</a>', url, state)
 
     status_link.short_description = "Status"
 
@@ -359,6 +360,63 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
 
     purge_data.short_description = "Purge data"
 
+    @admin.action(description="Re-check Charger Status")
+    def recheck_charger_status(self, request, queryset):
+        requested = 0
+        for charger in queryset:
+            connector_value = charger.connector_id
+            ws = store.get_connection(charger.charger_id, connector_value)
+            if ws is None:
+                self.message_user(
+                    request,
+                    f"{charger}: no active connection",
+                    level=messages.ERROR,
+                )
+                continue
+            payload: dict[str, object] = {"requestedMessage": "StatusNotification"}
+            trigger_connector: int | None = None
+            if connector_value is not None:
+                payload["connectorId"] = connector_value
+                trigger_connector = connector_value
+            message_id = uuid.uuid4().hex
+            msg = json.dumps([2, message_id, "TriggerMessage", payload])
+            try:
+                async_to_sync(ws.send)(msg)
+            except Exception as exc:  # pragma: no cover - network error
+                self.message_user(
+                    request,
+                    f"{charger}: failed to send TriggerMessage ({exc})",
+                    level=messages.ERROR,
+                )
+                continue
+            log_key = store.identity_key(charger.charger_id, connector_value)
+            store.add_log(log_key, f"< {msg}", log_type="charger")
+            store.register_pending_call(
+                message_id,
+                {
+                    "action": "TriggerMessage",
+                    "charger_id": charger.charger_id,
+                    "connector_id": connector_value,
+                    "log_key": log_key,
+                    "trigger_target": "StatusNotification",
+                    "trigger_connector": trigger_connector,
+                    "requested_at": timezone.now(),
+                },
+            )
+            store.schedule_call_timeout(
+                message_id,
+                timeout=5.0,
+                action="TriggerMessage",
+                log_key=log_key,
+                message="TriggerMessage StatusNotification timed out",
+            )
+            requested += 1
+        if requested:
+            self.message_user(
+                request,
+                f"Requested status update from {requested} charger(s)",
+            )
+
     @admin.action(description="Fetch CP configuration")
     def fetch_cp_configuration(self, request, queryset):
         fetched = 0
@@ -413,6 +471,30 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
                 f"Requested configuration from {fetched} charger(s)",
             )
 
+    @admin.action(description="Toggle RFID Authentication")
+    def toggle_rfid_authentication(self, request, queryset):
+        enabled = 0
+        disabled = 0
+        for charger in queryset:
+            new_value = not charger.require_rfid
+            Charger.objects.filter(pk=charger.pk).update(require_rfid=new_value)
+            charger.require_rfid = new_value
+            if new_value:
+                enabled += 1
+            else:
+                disabled += 1
+        if enabled or disabled:
+            changes = []
+            if enabled:
+                changes.append(f"enabled for {enabled} charger(s)")
+            if disabled:
+                changes.append(f"disabled for {disabled} charger(s)")
+            summary = "; ".join(changes)
+            self.message_user(
+                request,
+                f"Updated RFID authentication: {summary}",
+            )
+
     def _dispatch_change_availability(self, request, queryset, availability_type: str):
         sent = 0
         for charger in queryset:

ocpp/test_rfid.py

@@ -131,7 +131,7 @@ class ScanNextViewTests(TestCase):
         self.assertEqual(
             resp.json(), {"rfid": "ABCD1234", "label_id": 1, "created": False}
         )
-        mock_validate.assert_called_once_with("ABCD1234", kind=None)
+        mock_validate.assert_called_once_with("ABCD1234", kind=None, endianness=None)
 
     @patch("config.middleware.Node.get_local", return_value=None)
     @patch("config.middleware.get_site")
@@ -342,16 +342,20 @@ class ValidateRfidValueTests(SimpleTestCase):
         tag.released = False
         tag.reference = None
         tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.BIG_ENDIAN
         mock_register.return_value = (tag, True)
 
         result = validate_rfid_value("abcd1234")
 
-        mock_register.assert_called_once_with("ABCD1234", kind=None)
+        mock_register.assert_called_once_with(
+            "ABCD1234", kind=None, endianness=RFID.BIG_ENDIAN
+        )
         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")
+        self.assertEqual(result["endianness"], RFID.BIG_ENDIAN)
 
     @patch("ocpp.rfid.reader.timezone.now")
     @patch("ocpp.rfid.reader.notify_async")
@@ -367,11 +371,14 @@ class ValidateRfidValueTests(SimpleTestCase):
         tag.released = True
         tag.reference = None
         tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.BIG_ENDIAN
         mock_register.return_value = (tag, False)
 
         result = validate_rfid_value("abcd", kind=RFID.NTAG215)
 
-        mock_register.assert_called_once_with("ABCD", kind=RFID.NTAG215)
+        mock_register.assert_called_once_with(
+            "ABCD", kind=RFID.NTAG215, endianness=RFID.BIG_ENDIAN
+        )
         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)
@@ -379,6 +386,36 @@ class ValidateRfidValueTests(SimpleTestCase):
         self.assertFalse(result["allowed"])
         self.assertFalse(result["created"])
         self.assertEqual(result["kind"], RFID.NTAG215)
+        self.assertEqual(result["endianness"], RFID.BIG_ENDIAN)
+
+    @patch("ocpp.rfid.reader.timezone.now")
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.RFID.register_scan")
+    def test_registers_little_endian_value(
+        self, mock_register, mock_notify, mock_now
+    ):
+        fake_now = object()
+        mock_now.return_value = fake_now
+        tag = MagicMock()
+        tag.pk = 7
+        tag.label_id = 7
+        tag.allowed = True
+        tag.color = "B"
+        tag.released = False
+        tag.reference = None
+        tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.LITTLE_ENDIAN
+        mock_register.return_value = (tag, True)
+
+        result = validate_rfid_value("A1B2C3D4", endianness=RFID.LITTLE_ENDIAN)
+
+        mock_register.assert_called_once_with(
+            "D4C3B2A1", kind=None, endianness=RFID.LITTLE_ENDIAN
+        )
+        tag.save.assert_called_once_with(update_fields=["last_seen_on"])
+        self.assertEqual(result["rfid"], "D4C3B2A1")
+        self.assertEqual(result["endianness"], RFID.LITTLE_ENDIAN)
+        mock_notify.assert_called_once()
 
     def test_rejects_invalid_value(self):
         result = validate_rfid_value("invalid!")
@@ -412,6 +449,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         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="ok\n", stderr=""
@@ -427,6 +465,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         env = run_kwargs.get("env", {})
         self.assertEqual(env.get("RFID_VALUE"), "ABCD1234")
         self.assertEqual(env.get("RFID_LABEL_ID"), "1")
+        self.assertEqual(env.get("RFID_ENDIANNESS"), RFID.BIG_ENDIAN)
         mock_popen.assert_not_called()
         mock_notify.assert_called_once_with("RFID 1 OK", "ABCD1234 B")
         tag.save.assert_called_once_with(update_fields=["last_seen_on"])
@@ -437,6 +476,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         self.assertEqual(output.get("stderr"), "")
         self.assertEqual(output.get("returncode"), 0)
         self.assertEqual(output.get("error"), "")
+        self.assertEqual(result["endianness"], RFID.BIG_ENDIAN)
 
     @patch("ocpp.rfid.reader.timezone.now")
     @patch("ocpp.rfid.reader.notify_async")
@@ -457,6 +497,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         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=1, stdout="", stderr="failure"
@@ -476,6 +517,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         self.assertEqual(output.get("stderr"), "failure")
         self.assertEqual(output.get("error"), "")
         mock_popen.assert_not_called()
+        self.assertEqual(result["endianness"], RFID.BIG_ENDIAN)
 
     @patch("ocpp.rfid.reader.timezone.now")
     @patch("ocpp.rfid.reader.notify_async")
@@ -497,6 +539,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         tag.released = False
         tag.reference = None
         tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.BIG_ENDIAN
         mock_register.return_value = (tag, False)
         result = validate_rfid_value("abcdef")
 
@@ -507,10 +550,12 @@ class ValidateRfidValueTests(SimpleTestCase):
         env = kwargs.get("env", {})
         self.assertEqual(env.get("RFID_VALUE"), "ABCDEF")
         self.assertEqual(env.get("RFID_LABEL_ID"), "3")
+        self.assertEqual(env.get("RFID_ENDIANNESS"), RFID.BIG_ENDIAN)
         self.assertIs(kwargs.get("stdout"), subprocess.DEVNULL)
         self.assertIs(kwargs.get("stderr"), subprocess.DEVNULL)
         self.assertTrue(result["allowed"])
         mock_notify.assert_called_once_with("RFID 3 OK", "ABCDEF B")
+        self.assertEqual(result["endianness"], RFID.BIG_ENDIAN)
 
 
 class CardTypeDetectionTests(TestCase):