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

nodes/models.py

@@ -16,7 +16,6 @@ import base64
 from django.utils import timezone
 from django.utils.text import slugify
 from django.conf import settings
-from django.contrib.sites.models import Site
 from datetime import timedelta
 import uuid
 import os
@@ -99,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",
@@ -245,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}"
@@ -344,7 +349,6 @@ class Node(Entity):
             if terminal:
                 node.role = terminal
                 node.save(update_fields=["role"])
-        Site.objects.get_or_create(domain=hostname, defaults={"name": "host"})
         node.ensure_keys()
         node.notify_peers_of_update()
         return node, created
@@ -745,8 +749,11 @@ class Node(Entity):
     def sync_feature_tasks(self):
         clipboard_enabled = self.has_feature("clipboard-poll")
         screenshot_enabled = self.has_feature("screenshot-poll")
+        celery_enabled = self.is_local and self.has_feature("celery-queue")
         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
@@ -792,6 +799,66 @@ class Node(Entity):
         else:
             PeriodicTask.objects.filter(name=task_name).delete()
 
+    def _sync_landing_lead_task(self, enabled: bool):
+        if not self.is_local:
+            return
+
+        from django_celery_beat.models import CrontabSchedule, PeriodicTask
+
+        task_name = "pages_purge_landing_leads"
+        if enabled:
+            schedule, _ = CrontabSchedule.objects.get_or_create(
+                minute="0",
+                hour="3",
+                day_of_week="*",
+                day_of_month="*",
+                month_of_year="*",
+            )
+            PeriodicTask.objects.update_or_create(
+                name=task_name,
+                defaults={
+                    "crontab": schedule,
+                    "interval": None,
+                    "task": "pages.tasks.purge_expired_landing_leads",
+                    "enabled": True,
+                },
+            )
+        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,
@@ -928,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(
@@ -1340,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)
 
@@ -1569,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,
@@ -1605,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

@@ -35,7 +35,6 @@ from django.urls import reverse
 from django.contrib.auth import get_user_model
 from django.contrib import admin
 from django.contrib.auth.models import Permission
-from django.contrib.sites.models import Site
 from django_celery_beat.models import IntervalSchedule, PeriodicTask
 from django.conf import settings
 from django.utils import timezone
@@ -1271,6 +1270,74 @@ class NodeRegisterCurrentTests(TestCase):
         NodeFeatureAssignment.objects.filter(node=node, feature=feature).delete()
         self.assertFalse(PeriodicTask.objects.filter(name=task_name).exists())
 
+    def test_landing_lead_purge_task_syncs_with_celery_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": 9300,
+                "base_path": settings.BASE_DIR,
+            },
+        )
+        PeriodicTask.objects.filter(name="pages_purge_landing_leads").delete()
+        NodeFeatureAssignment.objects.get_or_create(node=node, feature=feature)
+        self.assertTrue(
+            PeriodicTask.objects.filter(name="pages_purge_landing_leads").exists()
+        )
+        NodeFeatureAssignment.objects.filter(node=node, feature=feature).delete()
+        self.assertFalse(
+            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):
@@ -1326,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(
@@ -1357,8 +1434,6 @@ class NodeAdminTests(TestCase):
         self.assertTrue(priv.exists())
         self.assertTrue(pub.exists())
         self.assertTrue(node.public_key)
-        self.assertTrue(Site.objects.filter(domain=hostname, name="host").exists())
-
     def test_register_current_updates_existing_node(self):
         hostname = socket.gethostname()
         Node.objects.create(
@@ -1730,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()
@@ -2476,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)])
@@ -2492,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)
@@ -2567,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):
@@ -3176,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/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)