arthexis 0.1.6__py3-none-any.whl → 0.1.7__py3-none-any.whl

nodes/models.py

@@ -1,6 +1,10 @@
 from django.db import models
 from core.entity import Entity
-from core.fields import SigilShortAutoField
+from core.fields import (
+    SigilShortAutoField,
+    SigilLongCheckField,
+    SigilLongAutoField,
+)
 import re
 import json
 import base64
@@ -18,6 +22,10 @@ from cryptography.hazmat.primitives import serialization, hashes
 from cryptography.hazmat.primitives.asymmetric import padding
 from django.contrib.auth import get_user_model
 from django.core.mail import get_connection, send_mail
+import logging
+
+
+logger = logging.getLogger(__name__)
 
 
 class NodeRoleManager(models.Manager):
@@ -250,10 +258,20 @@ class Node(Entity):
     def send_mail(self, subject: str, message: str, recipient_list: list[str], from_email: str | None = None, **kwargs):
         """Send an email using this node's configured outbox if available."""
         outbox = getattr(self, "email_outbox", None)
+        logger.info(
+            "Node %s sending email to %s using %s backend",
+            self.pk,
+            recipient_list,
+            "outbox" if outbox else "default",
+        )
         if outbox:
-            return outbox.send_mail(subject, message, recipient_list, from_email, **kwargs)
+            result = outbox.send_mail(subject, message, recipient_list, from_email, **kwargs)
+            logger.info("Outbox send_mail result: %s", result)
+            return result
         from_email = from_email or settings.DEFAULT_FROM_EMAIL
-        return send_mail(subject, message, from_email, recipient_list, **kwargs)
+        result = send_mail(subject, message, from_email, recipient_list, **kwargs)
+        logger.info("Default send_mail result: %s", result)
+        return result
 
 
 class EmailOutbox(Entity):
@@ -430,10 +448,12 @@ class NetMessage(Entity):
 
         reach_name = self.reach.name if self.reach else "Terminal"
         role_map = {
-            "Terminal": ["Terminal"],
-            "Control": ["Control", "Terminal"],
-            "Satellite": ["Satellite", "Control", "Terminal"],
-            "Constellation": ["Constellation", "Satellite", "Control", "Terminal"],
+            "Particle": ["Particle"],
+            "Terminal": ["Terminal", "Particle"],
+            "Control": ["Control", "Terminal", "Particle"],
+            "Satellite": ["Satellite", "Control", "Terminal", "Particle"],
+            "Constellation": ["Constellation", "Satellite", "Control", "Terminal", "Particle"],
+            "Virtual": ["Virtual", "Constellation", "Satellite", "Control", "Terminal", "Particle"],
         }
         role_order = role_map.get(reach_name, ["Terminal"])
         selected: list[Node] = []
@@ -562,6 +582,82 @@ class NodeTask(Entity):
         return result.stdout + result.stderr
 
 
+class Operation(Entity):
+    """Action that can change node or constellation state."""
+
+    name = models.SlugField(unique=True)
+    template = SigilLongCheckField(blank=True)
+    command = SigilLongAutoField(blank=True)
+    is_django = models.BooleanField(default=False)
+    next_operations = models.ManyToManyField(
+        "self",
+        through="Interrupt",
+        through_fields=("from_operation", "to_operation"),
+        symmetrical=False,
+        related_name="previous_operations",
+    )
+
+    class Meta:
+        ordering = ["name"]
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return self.name
+
+
+class Interrupt(Entity):
+    """Intermediate transition between operations."""
+
+    name = models.CharField(max_length=100)
+    preview = SigilLongAutoField(blank=True)
+    priority = models.PositiveIntegerField(default=0)
+    from_operation = models.ForeignKey(
+        Operation,
+        on_delete=models.CASCADE,
+        related_name="outgoing_interrupts",
+    )
+    to_operation = models.ForeignKey(
+        Operation,
+        on_delete=models.CASCADE,
+        related_name="incoming_interrupts",
+    )
+
+    class Meta:
+        ordering = ["-priority"]
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return self.name
+ 
+
+class Logbook(Entity):
+    """Record of executed operations."""
+
+    operation = models.ForeignKey(
+        Operation, on_delete=models.CASCADE, related_name="logs"
+    )
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+    )
+    input_text = models.TextField(blank=True)
+    output = models.TextField(blank=True)
+    error = models.TextField(blank=True)
+    interrupted = models.BooleanField(default=False)
+    interrupt = models.ForeignKey(
+        Interrupt, null=True, blank=True, on_delete=models.SET_NULL
+    )
+    created = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        ordering = ["-created"]
+        verbose_name = "Logbook Entry"
+        verbose_name_plural = "Logbook"
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return f"{self.operation} @ {self.created:%Y-%m-%d %H:%M:%S}"
+
+
 UserModel = get_user_model()
 
 

nodes/tests.py

@@ -37,6 +37,8 @@ from .tasks import capture_node_screenshot, sample_clipboard
 from cryptography.hazmat.primitives.asymmetric import rsa, padding
 from cryptography.hazmat.primitives import serialization, hashes
 from core.models import PackageRelease
+from .models import Operation
+from .admin import RUN_CONTEXTS
 
 
 class NodeTests(TestCase):
@@ -1065,3 +1067,28 @@ class NodeRoleAdminTests(TestCase):
         self.assertEqual(node2.role, role)
 
 
+class OperationWorkflowTests(TestCase):
+    def setUp(self):
+        self.client = Client()
+        User = get_user_model()
+        self.user = User.objects.create_superuser(
+            username="admin", email="admin@example.com", password="pwd"
+        )
+        self.client.force_login(self.user)
+
+    def tearDown(self):
+        RUN_CONTEXTS.clear()
+
+    def test_unresolved_sigils_prompt(self):
+        op = Operation.objects.create(name="op1", command="[ENV.MISSING]")
+        url = reverse("admin:nodes_operation_run", args=[op.pk])
+        resp = self.client.post(url, follow=True)
+        self.assertContains(resp, 'name="ENV__MISSING"')
+
+    def test_continue_effect(self):
+        op = Operation.objects.create(name="op2", command="...")
+        url = reverse("admin:nodes_operation_run", args=[op.pk])
+        resp = self.client.post(url, follow=True)
+        self.assertContains(resp, 'value="Continue"')
+
+

ocpp/apps.py

@@ -6,7 +6,7 @@ from django.conf import settings
 class OcppConfig(AppConfig):
     default_auto_field = "django.db.models.BigAutoField"
     name = "ocpp"
-    verbose_name = "OCPP"
+    verbose_name = "3. Protocols"
 
     def ready(self):  # pragma: no cover - startup side effects
         lock = Path(settings.BASE_DIR) / "locks" / "control.lck"

ocpp/models.py

@@ -172,7 +172,7 @@ class Transaction(Entity):
 
     class Meta:
         verbose_name = _("Transaction")
-        verbose_name_plural = _("Transactions")
+        verbose_name_plural = _("CP Transactions")
 
     @property
     def kw(self) -> float:

ocpp/simulator.py

@@ -94,6 +94,10 @@ class ChargePointSimulator:
                         log_type="simulator",
                     )
                     raise
+                except websockets.exceptions.ConnectionClosed:
+                    self.status = "stopped"
+                    self._stop_event.set()
+                    raise
                 except Exception:
                     self.status = "error"
                     raise

ocpp/tests.py

@@ -1027,7 +1027,11 @@ class ChargePointSimulatorTests(TransactionTestCase):
         sim = ChargePointSimulator(cfg)
         store.simulators[99] = sim
         try:
-            with patch("ocpp.simulator.asyncio.wait_for", side_effect=asyncio.TimeoutError):
+            async def fake_wait_for(coro, timeout):
+                coro.close()
+                raise asyncio.TimeoutError
+
+            with patch("ocpp.simulator.asyncio.wait_for", fake_wait_for):
                 started, status, _ = await asyncio.to_thread(sim.start)
             await asyncio.to_thread(sim._thread.join)
             self.assertFalse(started)

pages/admin.py

@@ -170,8 +170,9 @@ class ModuleAdmin(admin.ModelAdmin):
 def favorite_toggle(request, ct_id):
     ct = get_object_or_404(ContentType, pk=ct_id)
     fav = Favorite.objects.filter(user=request.user, content_type=ct).first()
+    next_url = request.GET.get("next")
     if fav:
-        return redirect("admin:favorite_list")
+        return redirect(next_url or "admin:favorite_list")
     if request.method == "POST":
         label = request.POST.get("custom_label", "").strip()
         user_data = request.POST.get("user_data") == "on"
@@ -181,8 +182,12 @@ def favorite_toggle(request, ct_id):
             custom_label=label,
             user_data=user_data,
         )
-        return redirect("admin:index")
-    return render(request, "admin/favorite_confirm.html", {"content_type": ct})
+        return redirect(next_url or "admin:index")
+    return render(
+        request,
+        "admin/favorite_confirm.html",
+        {"content_type": ct, "next": next_url},
+    )
 
 
 def favorite_list(request):

pages/apps.py

@@ -4,7 +4,7 @@ from django.apps import AppConfig
 class PagesConfig(AppConfig):
     default_auto_field = "django.db.models.BigAutoField"
     name = "pages"
-    verbose_name = "Web Experience"
+    verbose_name = "7. Experience"
 
     def ready(self):  # pragma: no cover - import for side effects
         from . import checks  # noqa: F401

pages/tests.py

@@ -1,5 +1,6 @@
 from django.test import Client, TestCase, override_settings
 from django.urls import reverse
+from urllib.parse import quote
 from django.contrib.auth import get_user_model
 from django.contrib.sites.models import Site
 from django.contrib import admin
@@ -9,7 +10,7 @@ from pages.models import Application, Module, SiteBadge, Favorite
 from core.user_data import UserDatum
 from pages.admin import ApplicationAdmin
 from django.apps import apps as django_apps
-from core.models import AdminHistory
+from core.models import AdminHistory, InviteLead
 from django.core.files.uploadedfile import SimpleUploadedFile
 import base64
 import tempfile
@@ -118,6 +119,16 @@ class InvitationTests(TestCase):
             resp, "If the email exists, an invitation has been sent."
         )
 
+    def test_request_invite_creates_lead_with_comment(self):
+        resp = self.client.post(
+            reverse("pages:request-invite"),
+            {"email": "new@example.com", "comment": "Hello"},
+        )
+        self.assertEqual(resp.status_code, 200)
+        lead = InviteLead.objects.get()
+        self.assertEqual(lead.email, "new@example.com")
+        self.assertEqual(lead.comment, "Hello")
+
 
 class NavbarBrandTests(TestCase):
     def setUp(self):
@@ -600,13 +611,21 @@ class FavoriteTests(TestCase):
 
     def test_add_favorite(self):
         ct = ContentType.objects.get_by_natural_key("pages", "application")
-        url = reverse("admin:favorite_toggle", args=[ct.id])
+        next_url = reverse("admin:pages_application_changelist")
+        url = reverse("admin:favorite_toggle", args=[ct.id]) + f"?next={quote(next_url)}"
         resp = self.client.post(url, {"custom_label": "Apps", "user_data": "on"})
-        self.assertRedirects(resp, reverse("admin:index"))
+        self.assertRedirects(resp, next_url)
         fav = Favorite.objects.get(user=self.user, content_type=ct)
         self.assertEqual(fav.custom_label, "Apps")
         self.assertTrue(fav.user_data)
 
+    def test_cancel_link_uses_next(self):
+        ct = ContentType.objects.get_by_natural_key("pages", "application")
+        next_url = reverse("admin:pages_application_changelist")
+        url = reverse("admin:favorite_toggle", args=[ct.id]) + f"?next={quote(next_url)}"
+        resp = self.client.get(url)
+        self.assertContains(resp, f'href="{next_url}"')
+
     def test_existing_favorite_redirects_to_list(self):
         ct = ContentType.objects.get_by_natural_key("pages", "application")
         Favorite.objects.create(user=self.user, content_type=ct)
@@ -647,5 +666,5 @@ class FavoriteTests(TestCase):
         )
         resp = self.client.get(reverse("admin:index"))
         url = reverse("admin:nodes_noderole_changelist")
-        self.assertEqual(resp.content.decode().count(url), 1)
+        self.assertGreaterEqual(resp.content.decode().count(url), 1)
         self.assertContains(resp, NodeRole._meta.verbose_name_plural)

pages/views.py

@@ -17,6 +17,7 @@ from django.utils.http import urlsafe_base64_decode, urlsafe_base64_encode
 from django.core.mail import send_mail
 from django.utils.translation import gettext as _
 from django.views.decorators.csrf import csrf_exempt, ensure_csrf_cookie
+from core.models import InviteLead
 
 import markdown
 from pages.utils import landing
@@ -115,6 +116,7 @@ login_view = CustomLoginView.as_view()
 
 class InvitationRequestForm(forms.Form):
     email = forms.EmailField()
+    comment = forms.CharField(required=False, widget=forms.Textarea, label=_("Comment"))
 
 @csrf_exempt
 @ensure_csrf_cookie
@@ -123,8 +125,22 @@ def request_invite(request):
     sent = False
     if request.method == "POST" and form.is_valid():
         email = form.cleaned_data["email"]
+        comment = form.cleaned_data.get("comment", "")
+        InviteLead.objects.create(
+            email=email,
+            comment=comment,
+            user=request.user if request.user.is_authenticated else None,
+            path=request.path,
+            referer=request.META.get("HTTP_REFERER", ""),
+            user_agent=request.META.get("HTTP_USER_AGENT", ""),
+            ip_address=request.META.get("REMOTE_ADDR"),
+        )
+        logger.info("Invitation requested for %s", email)
         User = get_user_model()
-        for user in User.objects.filter(email__iexact=email):
+        users = list(User.objects.filter(email__iexact=email))
+        if not users:
+            logger.warning("Invitation requested for unknown email %s", email)
+        for user in users:
             uid = urlsafe_base64_encode(force_bytes(user.pk))
             token = default_token_generator.make_token(user)
             link = request.build_absolute_uri(
@@ -137,9 +153,12 @@ def request_invite(request):
             try:
                 node = Node.get_local()
                 if node:
-                    node.send_mail(subject, body, [email])
+                    result = node.send_mail(subject, body, [email])
                 else:
-                    send_mail(subject, body, settings.DEFAULT_FROM_EMAIL, [email])
+                    result = send_mail(subject, body, settings.DEFAULT_FROM_EMAIL, [email])
+                logger.info(
+                    "Invitation email sent to %s (user %s): %s", email, user.pk, result
+                )
             except Exception:
                 logger.exception("Failed to send invitation email to %s", email)
         sent = True