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

nodes/models.py

@@ -98,6 +98,12 @@ class NodeFeature(Entity):
                 url_name="admin:nodes_nodefeature_celery_report",
             ),
         ),
+        "audio-capture": (
+            NodeFeatureDefaultAction(
+                label="View Waveform",
+                url_name="admin:nodes_nodefeature_view_waveform",
+            ),
+        ),
         "screenshot-poll": (
             NodeFeatureDefaultAction(
                 label="Take Screenshot",
@@ -244,7 +250,7 @@ class Node(Entity):
         "ap-router",
         "gway-runner",
     }
-    MANUAL_FEATURE_SLUGS = {"clipboard-poll", "screenshot-poll"}
+    MANUAL_FEATURE_SLUGS = {"clipboard-poll", "screenshot-poll", "audio-capture"}
 
     def __str__(self) -> str:  # pragma: no cover - simple representation
         return f"{self.hostname}:{self.port}"
@@ -747,6 +753,7 @@ class Node(Entity):
         self._sync_clipboard_task(clipboard_enabled)
         self._sync_screenshot_task(screenshot_enabled)
         self._sync_landing_lead_task(celery_enabled)
+        self._sync_ocpp_session_report_task(celery_enabled)
 
     def _sync_clipboard_task(self, enabled: bool):
         from django_celery_beat.models import IntervalSchedule, PeriodicTask
@@ -819,6 +826,39 @@ class Node(Entity):
         else:
             PeriodicTask.objects.filter(name=task_name).delete()
 
+    def _sync_ocpp_session_report_task(self, celery_enabled: bool):
+        from django_celery_beat.models import CrontabSchedule, PeriodicTask
+        from django.db.utils import OperationalError, ProgrammingError
+
+        task_name = "ocpp_send_daily_session_report"
+
+        if not self.is_local:
+            return
+
+        if not celery_enabled or not mailer.can_send_email():
+            PeriodicTask.objects.filter(name=task_name).delete()
+            return
+
+        try:
+            schedule, _ = CrontabSchedule.objects.get_or_create(
+                minute="0",
+                hour="18",
+                day_of_week="*",
+                day_of_month="*",
+                month_of_year="*",
+            )
+            PeriodicTask.objects.update_or_create(
+                name=task_name,
+                defaults={
+                    "crontab": schedule,
+                    "interval": None,
+                    "task": "ocpp.tasks.send_daily_session_report",
+                    "enabled": True,
+                },
+            )
+        except (OperationalError, ProgrammingError):
+            logger.debug("Skipping OCPP session report task sync; tables not ready")
+
     def send_mail(
         self,
         subject: str,
@@ -955,15 +995,18 @@ class NodeManager(Profile):
     )
     api_key = SigilShortAutoField(
         max_length=255,
+        verbose_name="API key",
         help_text="API key issued by the DNS provider.",
     )
     api_secret = SigilShortAutoField(
         max_length=255,
+        verbose_name="API secret",
         help_text="API secret issued by the DNS provider.",
     )
     customer_id = SigilShortAutoField(
         max_length=100,
         blank=True,
+        verbose_name="Customer ID",
         help_text="Optional GoDaddy customer identifier for the account.",
     )
     default_domain = SigilShortAutoField(
@@ -1367,6 +1410,7 @@ class NetMessage(Entity):
     propagated_to = models.ManyToManyField(
         Node, blank=True, related_name="received_net_messages"
     )
+    confirmed_peers = models.JSONField(default=dict, blank=True)
     created = models.DateTimeField(auto_now_add=True)
     complete = models.BooleanField(default=False, editable=False)
 
@@ -1596,7 +1640,10 @@ class NetMessage(Entity):
         seen_list = seen.copy()
         selected_ids = [str(n.uuid) for n in selected]
         payload_seen = seen_list + selected_ids
+        confirmed_peers = dict(self.confirmed_peers or {})
+
         for node in selected:
+            now = timezone.now().isoformat()
             payload = {
                 "uuid": str(self.uuid),
                 "subject": self.subject,
@@ -1632,20 +1679,39 @@ class NetMessage(Entity):
                     headers["X-Signature"] = base64.b64encode(signature).decode()
                 except Exception:
                     pass
+            status_entry = {
+                "status": "pending",
+                "status_code": None,
+                "updated": now,
+            }
             try:
-                requests.post(
+                response = requests.post(
                     f"http://{node.address}:{node.port}/nodes/net-message/",
                     data=payload_json,
                     headers=headers,
                     timeout=1,
                 )
+                status_entry["status_code"] = getattr(response, "status_code", None)
+                if getattr(response, "ok", False):
+                    status_entry["status"] = "acknowledged"
+                else:
+                    status_entry["status"] = "failed"
             except Exception:
-                pass
+                status_entry["status"] = "error"
             self.propagated_to.add(node)
+            confirmed_peers[str(node.uuid)] = status_entry
+
+        save_fields: list[str] = []
+        if confirmed_peers != (self.confirmed_peers or {}):
+            self.confirmed_peers = confirmed_peers
+            save_fields.append("confirmed_peers")
 
         if total_known and self.propagated_to.count() >= total_known:
             self.complete = True
-        self.save(update_fields=["complete"] if self.complete else [])
+            save_fields.append("complete")
+
+        if save_fields:
+            self.save(update_fields=save_fields)
 
 
 class ContentSample(Entity):

nodes/rfid_sync.py

@@ -45,6 +45,8 @@ def serialize_rfid(tag: RFID) -> dict[str, Any]:
         "color": tag.color,
         "kind": tag.kind,
         "released": tag.released,
+        "external_command": tag.external_command,
+        "post_auth_command": tag.post_auth_command,
         "last_seen_on": tag.last_seen_on.isoformat() if tag.last_seen_on else None,
         "energy_accounts": [account.id for account in accounts],
         "energy_account_names": [
@@ -64,6 +66,17 @@ def apply_rfid_payload(
         outcome.error = "Missing RFID value"
         return outcome
 
+    external_command = entry.get("external_command")
+    if not isinstance(external_command, str):
+        external_command = ""
+    else:
+        external_command = external_command.strip()
+    post_auth_command = entry.get("post_auth_command")
+    if not isinstance(post_auth_command, str):
+        post_auth_command = ""
+    else:
+        post_auth_command = post_auth_command.strip()
+
     defaults: dict[str, Any] = {
         "custom_label": entry.get("custom_label", ""),
         "key_a": entry.get("key_a", RFID._meta.get_field("key_a").default),
@@ -75,6 +88,8 @@ def apply_rfid_payload(
         "color": entry.get("color", RFID.BLACK),
         "kind": entry.get("kind", RFID.CLASSIC),
         "released": bool(entry.get("released", False)),
+        "external_command": external_command,
+        "post_auth_command": post_auth_command,
     }
 
     if origin_node is not None:

nodes/tests.py

@@ -1293,6 +1293,51 @@ class NodeRegisterCurrentTests(TestCase):
             PeriodicTask.objects.filter(name="pages_purge_landing_leads").exists()
         )
 
+    def test_ocpp_session_report_task_syncs_with_feature(self):
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="celery-queue", defaults={"display": "Celery Queue"}
+        )
+        node, _ = Node.objects.update_or_create(
+            mac_address=Node.get_current_mac(),
+            defaults={
+                "hostname": socket.gethostname(),
+                "address": "127.0.0.1",
+                "port": 9400,
+                "base_path": settings.BASE_DIR,
+            },
+        )
+        task_name = "ocpp_send_daily_session_report"
+        PeriodicTask.objects.filter(name=task_name).delete()
+
+        with patch("nodes.models.mailer.can_send_email", return_value=True):
+            NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+
+        self.assertTrue(PeriodicTask.objects.filter(name=task_name).exists())
+
+        NodeFeatureAssignment.objects.filter(node=node, feature=feature).delete()
+        self.assertFalse(PeriodicTask.objects.filter(name=task_name).exists())
+
+    def test_ocpp_session_report_task_requires_email(self):
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="celery-queue", defaults={"display": "Celery Queue"}
+        )
+        node, _ = Node.objects.update_or_create(
+            mac_address=Node.get_current_mac(),
+            defaults={
+                "hostname": socket.gethostname(),
+                "address": "127.0.0.1",
+                "port": 9500,
+                "base_path": settings.BASE_DIR,
+            },
+        )
+        task_name = "ocpp_send_daily_session_report"
+        PeriodicTask.objects.filter(name=task_name).delete()
+
+        with patch("nodes.models.mailer.can_send_email", return_value=False):
+            NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+
+        self.assertFalse(PeriodicTask.objects.filter(name=task_name).exists())
+
 
 class CheckRegistrationReadyCommandTests(TestCase):
     def test_command_completes_successfully(self):
@@ -1348,6 +1393,16 @@ class NodeAdminTests(TestCase):
         self.assertContains(response, f'href="{snapshot_url}"')
         self.assertContains(response, f'href="{stream_url}"')
 
+    def test_node_feature_list_shows_waveform_action_when_enabled(self):
+        node = self._create_local_node()
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="audio-capture", defaults={"display": "Audio Capture"}
+        )
+        NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+        response = self.client.get(reverse("admin:nodes_nodefeature_changelist"))
+        action_url = reverse("admin:nodes_nodefeature_view_waveform")
+        self.assertContains(response, f'href="{action_url}"')
+
     def test_node_feature_list_hides_default_action_when_disabled(self):
         self._create_local_node()
         NodeFeature.objects.get_or_create(
@@ -1750,6 +1805,34 @@ class NodeAdminTests(TestCase):
         self.assertEqual(response.context_data["stream_embed"], "unsupported")
         self.assertContains(response, "camera-stream__unsupported")
 
+    def test_view_waveform_requires_enabled_feature(self):
+        self._create_local_node()
+        NodeFeature.objects.get_or_create(
+            slug="audio-capture", defaults={"display": "Audio Capture"}
+        )
+        response = self.client.get(
+            reverse("admin:nodes_nodefeature_view_waveform"), follow=True
+        )
+        self.assertEqual(response.status_code, 200)
+        changelist_url = reverse("admin:nodes_nodefeature_changelist")
+        self.assertEqual(response.wsgi_request.path, changelist_url)
+        self.assertContains(
+            response, "Audio Capture feature is not enabled on this node."
+        )
+
+    def test_view_waveform_renders_when_feature_enabled(self):
+        node = self._create_local_node()
+        feature, _ = NodeFeature.objects.get_or_create(
+            slug="audio-capture", defaults={"display": "Audio Capture"}
+        )
+        NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+        response = self.client.get(reverse("admin:nodes_nodefeature_view_waveform"))
+        self.assertEqual(response.status_code, 200)
+        response.render()
+        self.assertEqual(response.context_data["feature"], feature)
+        self.assertEqual(response.context_data["title"], "Audio Capture Waveform")
+        self.assertContains(response, "audio-capture__canvas")
+
     @patch("nodes.admin.requests.post")
     def test_import_rfids_action_fetches_and_imports(self, mock_post):
         local = self._create_local_node()
@@ -2496,6 +2579,8 @@ class NetMessagePropagationTests(TestCase):
     def test_propagate_forwards_to_three_and_notifies_local(
         self, mock_notify, mock_post
     ):
+        mock_post.return_value.ok = True
+        mock_post.return_value.status_code = 200
         msg = NetMessage.objects.create(subject="s", body="b", reach=self.role)
         with patch.object(Node, "get_local", return_value=self.local):
             msg.propagate(seen=[str(self.remotes[0].uuid)])
@@ -2512,6 +2597,13 @@ 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)
@@ -2587,6 +2679,21 @@ class NetMessagePropagationTests(TestCase):
         self.assertTrue(NetMessage.objects.filter(pk=old_remote.pk).exists())
         self.assertTrue(NetMessage.objects.filter(pk=msg.pk).exists())
 
+    @patch("core.notifications.notify", return_value=False)
+    def test_propagate_records_error_status(self, mock_notify):
+        msg = NetMessage.objects.create(subject="s", body="b", reach=self.role)
+        with (
+            patch.object(Node, "get_local", return_value=self.local),
+            patch("random.shuffle", side_effect=lambda seq: None),
+            patch("requests.post", side_effect=Exception("boom")),
+        ):
+            msg.propagate()
+
+        self.assertTrue(msg.confirmed_peers)
+        self.assertTrue(
+            all(entry["status"] == "error" for entry in msg.confirmed_peers.values())
+        )
+
 
 class NetMessageSignatureTests(TestCase):
     def setUp(self):
@@ -3196,6 +3303,18 @@ class NodeFeatureTests(TestCase):
         self.assertIn("Take a Snapshot", labels)
         self.assertIn("View stream", labels)
 
+    def test_audio_capture_feature_has_view_waveform_action(self):
+        feature = NodeFeature.objects.create(
+            slug="audio-capture", display="Audio Capture"
+        )
+        actions = feature.get_default_actions()
+        self.assertEqual(len(actions), 1)
+        action = actions[0]
+        self.assertEqual(action.label, "View Waveform")
+        self.assertEqual(
+            action.url_name, "admin:nodes_nodefeature_view_waveform"
+        )
+
     def test_default_action_missing_when_unconfigured(self):
         feature = NodeFeature.objects.create(
             slug="custom-feature", display="Custom Feature"

nodes/utils.py

@@ -89,6 +89,7 @@ def save_screenshot(
     transaction_uuid=None,
     *,
     content: str | None = None,
+    user=None,
 ):
     """Save screenshot file info if not already recorded.
 
@@ -115,6 +116,8 @@ def save_screenshot(
         data["transaction_uuid"] = transaction_uuid
     if content is not None:
         data["content"] = content
+    if user is not None:
+        data["user"] = user
     with suppress_default_classifiers():
         sample = ContentSample.objects.create(**data)
     run_default_classifiers(sample)

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/consumers.py

@@ -321,6 +321,44 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             except (TypeError, ValueError):
                 return
         if connector_value is None:
+            aggregate = self.aggregate_charger
+            if (
+                not aggregate
+                or aggregate.connector_id is not None
+                or aggregate.charger_id != self.charger_id
+            ):
+                aggregate, _ = await database_sync_to_async(
+                    Charger.objects.get_or_create
+                )(
+                    charger_id=self.charger_id,
+                    connector_id=None,
+                    defaults={"last_path": self.scope.get("path", "")},
+                )
+                await database_sync_to_async(aggregate.refresh_manager_node)()
+                self.aggregate_charger = aggregate
+            self.charger = self.aggregate_charger
+            previous_key = self.store_key
+            new_key = store.identity_key(self.charger_id, None)
+            if previous_key != new_key:
+                existing_consumer = store.connections.get(new_key)
+                if existing_consumer is not None and existing_consumer is not self:
+                    await existing_consumer.close()
+                store.reassign_identity(previous_key, new_key)
+                store.connections[new_key] = self
+                store.logs["charger"].setdefault(new_key, [])
+            aggregate_name = await sync_to_async(
+                lambda: self.charger.name or self.charger.charger_id
+            )()
+            friendly_name = aggregate_name or self.charger_id
+            store.register_log_name(new_key, friendly_name, log_type="charger")
+            store.register_log_name(
+                store.identity_key(self.charger_id, None),
+                friendly_name,
+                log_type="charger",
+            )
+            store.register_log_name(self.charger_id, friendly_name, log_type="charger")
+            self.store_key = new_key
+            self.connector_value = None
             if not self._header_reference_created and self.client_ip:
                 await database_sync_to_async(self._ensure_console_reference)()
                 self._header_reference_created = True

ocpp/models.py

@@ -854,11 +854,26 @@ class DataTransferMessage(models.Model):
         on_delete=models.CASCADE,
         related_name="data_transfer_messages",
     )
-    connector_id = models.PositiveIntegerField(null=True, blank=True)
+    connector_id = models.PositiveIntegerField(
+        null=True,
+        blank=True,
+        verbose_name="Connector ID",
+    )
     direction = models.CharField(max_length=16, choices=DIRECTION_CHOICES)
-    ocpp_message_id = models.CharField(max_length=64)
-    vendor_id = models.CharField(max_length=255, blank=True)
-    message_id = models.CharField(max_length=255, blank=True)
+    ocpp_message_id = models.CharField(
+        max_length=64,
+        verbose_name="OCPP message ID",
+    )
+    vendor_id = models.CharField(
+        max_length=255,
+        blank=True,
+        verbose_name="Vendor ID",
+    )
+    message_id = models.CharField(
+        max_length=255,
+        blank=True,
+        verbose_name="Message ID",
+    )
     payload = models.JSONField(default=dict, blank=True)
     status = models.CharField(max_length=64, blank=True)
     response_data = models.JSONField(null=True, blank=True)