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

core/views.py

@@ -43,6 +43,7 @@ logger = logging.getLogger(__name__)
 PYPI_REQUEST_TIMEOUT = 10
 
 from . import changelog as changelog_utils
+from . import temp_passwords
 from .models import OdooProfile, Product, EnergyAccount, PackageRelease, Todo
 from .models import RFID
 
@@ -336,6 +337,35 @@ def odoo_quote_report(request):
     return TemplateResponse(request, "admin/core/odoo_quote_report.html", context)
 
 
+@staff_member_required
+@require_GET
+def request_temp_password(request):
+    """Generate a temporary password for the authenticated staff member."""
+
+    user = request.user
+    username = user.get_username()
+    password = temp_passwords.generate_password()
+    entry = temp_passwords.store_temp_password(
+        username,
+        password,
+        allow_change=True,
+    )
+    context = {
+        **admin_site.each_context(request),
+        "title": _("Temporary password"),
+        "username": username,
+        "password": password,
+        "expires_at": timezone.localtime(entry.expires_at),
+        "allow_change": entry.allow_change,
+        "return_url": reverse("admin:password_change"),
+    }
+    return TemplateResponse(
+        request,
+        "admin/core/request_temp_password.html",
+        context,
+    )
+
+
 @require_GET
 def version_info(request):
     """Return the running application version and Git revision."""
@@ -706,6 +736,34 @@ def _ensure_release_todo(
     return todo, fixture_path
 
 
+def _todo_blocks_publish(todo: Todo, release: PackageRelease) -> bool:
+    """Return ``True`` when ``todo`` should block the release workflow."""
+
+    request = (todo.request or "").strip()
+    release_name = (release.package.name or "").strip()
+    if not request or not release_name:
+        return True
+
+    prefix = f"create release {release_name.lower()} "
+    if not request.lower().startswith(prefix):
+        return True
+
+    release_version = (release.version or "").strip()
+    generated_version = (todo.generated_for_version or "").strip()
+    if not release_version or release_version != generated_version:
+        return True
+
+    generated_revision = (todo.generated_for_revision or "").strip()
+    release_revision = (release.revision or "").strip()
+    if generated_revision and release_revision and generated_revision != release_revision:
+        return True
+
+    if not todo.is_seed_data:
+        return True
+
+    return False
+
+
 def _sync_release_with_revision(release: PackageRelease) -> tuple[bool, str]:
     """Ensure ``release`` matches the repository revision and version.
 
@@ -1855,26 +1913,37 @@ def release_progress(request, pk: int, action: str):
 
     pending_qs = Todo.objects.filter(is_deleted=False, done_on__isnull=True)
     pending_items = list(pending_qs)
-    if ack_todos_requested:
-        if pending_items:
-            failures = []
-            for todo in pending_items:
-                result = todo.check_on_done_condition()
-                if not result.passed:
-                    failures.append((todo, result))
-            if failures:
-                ctx.pop("todos_ack", None)
-                for todo, result in failures:
-                    messages.error(request, _format_condition_failure(todo, result))
-            else:
-                ctx["todos_ack"] = True
+    blocking_todos = [
+        todo for todo in pending_items if _todo_blocks_publish(todo, release)
+    ]
+    if not blocking_todos:
+        ctx["todos_ack"] = True
+        ctx["todos_ack_auto"] = True
+    elif ack_todos_requested:
+        failures = []
+        for todo in blocking_todos:
+            result = todo.check_on_done_condition()
+            if not result.passed:
+                failures.append((todo, result))
+        if failures:
+            ctx["todos_ack"] = False
+            ctx.pop("todos_ack_auto", None)
+            for todo, result in failures:
+                messages.error(request, _format_condition_failure(todo, result))
         else:
             ctx["todos_ack"] = True
+            ctx.pop("todos_ack_auto", None)
+    else:
+        if ctx.pop("todos_ack_auto", None):
+            ctx["todos_ack"] = False
+        else:
+            ctx.setdefault("todos_ack", False)
 
     if ctx.get("todos_ack"):
         ctx.pop("todos_block_logged", None)
-
-    if not ctx.get("todos_ack"):
+        ctx.pop("todos", None)
+        ctx.pop("todos_required", None)
+    else:
         ctx["todos"] = [
             {
                 "id": todo.pk,
@@ -1882,12 +1951,9 @@ def release_progress(request, pk: int, action: str):
                 "url": todo.url,
                 "request_details": todo.request_details,
             }
-            for todo in pending_items
+            for todo in blocking_todos
         ]
         ctx["todos_required"] = True
-    else:
-        ctx.pop("todos", None)
-        ctx.pop("todos_required", None)
 
     log_name = _release_log_name(release.package.name, release.version)
     if ctx.get("log") != log_name:
@@ -1897,6 +1963,8 @@ def release_progress(request, pk: int, action: str):
             "started": ctx.get("started", False),
         }
         step_count = 0
+        if not blocking_todos:
+            ctx["todos_ack"] = True
     log_path = log_dir / log_name
     ctx.setdefault("log", log_name)
     ctx.setdefault("paused", False)

nodes/admin.py

@@ -1565,7 +1565,7 @@ class NetMessageAdmin(EntityModelAdmin):
     search_fields = ("subject", "body")
     list_filter = ("complete", "filter_node_role", "filter_current_relation")
     ordering = ("-created",)
-    readonly_fields = ("complete", "confirmed_peers")
+    readonly_fields = ("complete",)
     actions = ["send_messages"]
     fieldsets = (
         (None, {"fields": ("subject", "body")}),
@@ -1590,7 +1590,6 @@ class NetMessageAdmin(EntityModelAdmin):
                     "node_origin",
                     "target_limit",
                     "propagated_to",
-                    "confirmed_peers",
                     "complete",
                 )
             },

nodes/models.py

@@ -293,7 +293,13 @@ class Node(Entity):
     @classmethod
     def register_current(cls):
         """Create or update the :class:`Node` entry for this host."""
-        hostname = socket.gethostname()
+        hostname_override = (
+            os.environ.get("NODE_HOSTNAME")
+            or os.environ.get("HOSTNAME")
+            or ""
+        )
+        hostname_override = hostname_override.strip()
+        hostname = hostname_override or socket.gethostname()
         try:
             address = socket.gethostbyname(hostname)
         except OSError:
@@ -305,7 +311,11 @@ class Node(Entity):
         rev_value = revision.get_revision()
         installed_revision = rev_value if rev_value else ""
         mac = cls.get_current_mac()
-        slug = slugify(hostname)
+        endpoint_override = os.environ.get("NODE_PUBLIC_ENDPOINT", "").strip()
+        slug_source = endpoint_override or hostname
+        slug = slugify(slug_source)
+        if not slug:
+            slug = cls._generate_unique_public_endpoint(hostname or mac)
         node = cls.objects.filter(mac_address=mac).first()
         if not node:
             node = cls.objects.filter(public_endpoint=slug).first()
@@ -1410,7 +1420,6 @@ 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)
 
@@ -1640,10 +1649,7 @@ 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,
@@ -1679,33 +1685,22 @@ class NetMessage(Entity):
                     headers["X-Signature"] = base64.b64encode(signature).decode()
                 except Exception:
                     pass
-            status_entry = {
-                "status": "pending",
-                "status_code": None,
-                "updated": now,
-            }
             try:
-                response = requests.post(
+                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:
-                status_entry["status"] = "error"
+                logger.exception(
+                    "Failed to propagate NetMessage %s to node %s",
+                    self.pk,
+                    node.pk,
+                )
             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
             save_fields.append("complete")

nodes/tests.py

@@ -223,6 +223,46 @@ class NodeGetLocalTests(TestCase):
             node.refresh_from_db()
             self.assertEqual(node.role.name, "Constellation")
 
+    def test_register_current_respects_node_hostname_env(self):
+        with TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            with override_settings(BASE_DIR=base):
+                with (
+                    patch.dict(os.environ, {"NODE_HOSTNAME": "gway-002"}, clear=False),
+                    patch("nodes.models.Node.get_current_mac", return_value="00:11:22:33:44:55"),
+                    patch("nodes.models.socket.gethostname", return_value="localhost"),
+                    patch("nodes.models.socket.gethostbyname", return_value="127.0.0.1"),
+                    patch("nodes.models.revision.get_revision", return_value="rev"),
+                    patch.object(Node, "ensure_keys"),
+                    patch.object(Node, "notify_peers_of_update"),
+                ):
+                    node, created = Node.register_current()
+        self.assertTrue(created)
+        self.assertEqual(node.hostname, "gway-002")
+        self.assertEqual(node.public_endpoint, "gway-002")
+
+    def test_register_current_respects_public_endpoint_env(self):
+        with TemporaryDirectory() as tmp:
+            base = Path(tmp)
+            with override_settings(BASE_DIR=base):
+                with (
+                    patch.dict(
+                        os.environ,
+                        {"NODE_HOSTNAME": "gway-alpha", "NODE_PUBLIC_ENDPOINT": "gway-002"},
+                        clear=False,
+                    ),
+                    patch("nodes.models.Node.get_current_mac", return_value="00:11:22:33:44:56"),
+                    patch("nodes.models.socket.gethostname", return_value="localhost"),
+                    patch("nodes.models.socket.gethostbyname", return_value="127.0.0.1"),
+                    patch("nodes.models.revision.get_revision", return_value="rev"),
+                    patch.object(Node, "ensure_keys"),
+                    patch.object(Node, "notify_peers_of_update"),
+                ):
+                    node, created = Node.register_current()
+        self.assertTrue(created)
+        self.assertEqual(node.hostname, "gway-alpha")
+        self.assertEqual(node.public_endpoint, "gway-002")
+
     def test_register_and_list_node(self):
         response = self.client.post(
             reverse("register-node"),
@@ -2315,29 +2355,6 @@ class NetMessageAdminTests(TransactionTestCase):
         self.assertEqual(form["subject"].value(), "Re: Ping")
         self.assertEqual(str(form["filter_node"].value()), str(node.pk))
 
-
-class LastNetMessageViewTests(TestCase):
-    def setUp(self):
-        self.client = Client()
-        NodeRole.objects.get_or_create(name="Terminal")
-
-    def test_returns_latest_message(self):
-        NetMessage.objects.create(subject="old", body="msg1")
-        latest = NetMessage.objects.create(subject="new", body="msg2")
-        resp = self.client.get(reverse("last-net-message"))
-        self.assertEqual(resp.status_code, 200)
-        self.assertEqual(
-            resp.json(),
-            {
-                "subject": "new",
-                "body": "msg2",
-                "admin_url": reverse(
-                    "admin:nodes_netmessage_change", args=[latest.pk]
-                ),
-            },
-        )
-
-
 class NetMessageReachTests(TestCase):
     def setUp(self):
         self.roles = {}
@@ -2597,13 +2614,6 @@ 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)
@@ -2689,10 +2699,8 @@ class NetMessagePropagationTests(TestCase):
         ):
             msg.propagate()
 
-        self.assertTrue(msg.confirmed_peers)
-        self.assertTrue(
-            all(entry["status"] == "error" for entry in msg.confirmed_peers.values())
-        )
+        self.assertEqual(msg.propagated_to.count(), len(self.remotes))
+        self.assertTrue(msg.complete)
 
 
 class NetMessageSignatureTests(TestCase):

nodes/urls.py

@@ -8,7 +8,6 @@ urlpatterns = [
     path("register/", views.register_node, name="register-node"),
     path("screenshot/", views.capture, name="node-screenshot"),
     path("net-message/", views.net_message, name="net-message"),
-    path("last-message/", views.last_net_message, name="last-net-message"),
     path("rfid/export/", views.export_rfids, name="node-rfid-export"),
     path("rfid/import/", views.import_rfids, name="node-rfid-import"),
     path("<slug:endpoint>/", views.public_node_endpoint, name="node-public-endpoint"),

nodes/views.py

@@ -104,6 +104,8 @@ def _get_host_domain(request) -> str:
     domain, _ = split_domain_port(host)
     if not domain:
         return ""
+    if domain.lower() == "localhost":
+        return ""
     try:
         ipaddress.ip_address(domain)
     except ValueError:
@@ -666,18 +668,3 @@ def net_message(request):
         msg.apply_attachments(attachments)
     msg.propagate(seen=seen)
     return JsonResponse({"status": "propagated", "complete": msg.complete})
-
-
-def last_net_message(request):
-    """Return the most recent :class:`NetMessage`."""
-
-    msg = NetMessage.objects.order_by("-created").first()
-    if not msg:
-        return JsonResponse({"subject": "", "body": "", "admin_url": ""})
-    return JsonResponse(
-        {
-            "subject": msg.subject,
-            "body": msg.body,
-            "admin_url": reverse("admin:nodes_netmessage_change", args=[msg.pk]),
-        }
-    )

ocpp/admin.py

@@ -6,7 +6,7 @@ from datetime import timedelta
 import json
 
 from django.shortcuts import redirect
-from django.utils import timezone
+from django.utils import formats, timezone, translation
 from django.urls import path
 from django.http import HttpResponse, HttpResponseRedirect
 from django.template.response import TemplateResponse
@@ -163,6 +163,7 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
                     "charger_id",
                     "display_name",
                     "connector_id",
+                    "language",
                     "location",
                     "last_path",
                     "last_heartbeat",
@@ -719,7 +720,7 @@ class SimulatorAdmin(SaveBeforeChangeAction, LogViewAdminMixin, EntityModelAdmin
         "ws_port",
         "ws_url",
         "interval",
-        "kw_max",
+        "kw_max_display",
         "running",
         "log_link",
     )
@@ -759,6 +760,26 @@ class SimulatorAdmin(SaveBeforeChangeAction, LogViewAdminMixin, EntityModelAdmin
 
     log_type = "simulator"
 
+    @admin.display(description="kW Max", ordering="kw_max")
+    def kw_max_display(self, obj):
+        """Display ``kw_max`` with a dot decimal separator for Spanish locales."""
+
+        language = translation.get_language() or ""
+        if language.startswith("es"):
+            return formats.number_format(
+                obj.kw_max,
+                decimal_pos=2,
+                use_l10n=False,
+                force_grouping=False,
+            )
+
+        return formats.number_format(
+            obj.kw_max,
+            decimal_pos=2,
+            use_l10n=True,
+            force_grouping=False,
+        )
+
     def save_model(self, request, obj, form, change):
         previous_door_open = False
         if change and obj.pk:

ocpp/consumers.py

@@ -5,6 +5,7 @@ from datetime import datetime
 import asyncio
 import inspect
 import json
+import logging
 from urllib.parse import parse_qs
 from django.utils import timezone
 from core.models import EnergyAccount, Reference, RFID as CoreRFID
@@ -32,6 +33,9 @@ from .evcs_discovery import (
 FORWARDED_PAIR_RE = re.compile(r"for=(?:\"?)(?P<value>[^;,\"\s]+)(?:\"?)", re.IGNORECASE)
 
 
+logger = logging.getLogger(__name__)
+
+
 # Query parameter keys that may contain the charge point serial. Keys are
 # matched case-insensitively and trimmed before use.
 SERIAL_QUERY_PARAM_NAMES = (
@@ -309,6 +313,19 @@ class CSMSConsumer(AsyncWebsocketConsumer):
 
         return await database_sync_to_async(_ensure)()
 
+    def _log_unlinked_rfid(self, rfid: str) -> None:
+        """Record a warning when an RFID is authorized without an account."""
+
+        message = (
+            f"Authorized RFID {rfid} on charger {self.charger_id} without linked energy account"
+        )
+        logger.warning(message)
+        store.add_log(
+            store.pending_key(self.charger_id),
+            message,
+            log_type="charger",
+        )
+
     async def _assign_connector(self, connector: int | str | None) -> None:
         """Ensure ``self.charger`` matches the provided connector id."""
         if connector in (None, "", "-"):
@@ -1395,13 +1412,25 @@ class CSMSConsumer(AsyncWebsocketConsumer):
             elif action == "Authorize":
                 id_tag = payload.get("idTag")
                 account = await self._get_account(id_tag)
+                status = "Invalid"
                 if self.charger.require_rfid:
-                    status = (
-                        "Accepted"
-                        if account
-                        and await database_sync_to_async(account.can_authorize)()
-                        else "Invalid"
-                    )
+                    tag = None
+                    tag_created = False
+                    if id_tag:
+                        tag, tag_created = await database_sync_to_async(
+                            CoreRFID.register_scan
+                        )(id_tag)
+                    if account:
+                        if await database_sync_to_async(account.can_authorize)():
+                            status = "Accepted"
+                    elif (
+                        id_tag
+                        and tag
+                        and not tag_created
+                        and tag.allowed
+                    ):
+                        status = "Accepted"
+                        self._log_unlinked_rfid(tag.rfid)
                 else:
                     await self._ensure_rfid_seen(id_tag)
                     status = "Accepted"
@@ -1475,23 +1504,38 @@ class CSMSConsumer(AsyncWebsocketConsumer):
                 reply_payload = {}
             elif action == "StartTransaction":
                 id_tag = payload.get("idTag")
-                account = await self._get_account(id_tag)
+                tag = None
+                tag_created = False
                 if id_tag:
-                    if self.charger.require_rfid:
-                        await database_sync_to_async(CoreRFID.register_scan)(
-                            id_tag.upper()
-                        )
-                    else:
-                        await self._ensure_rfid_seen(id_tag)
+                    tag, tag_created = await database_sync_to_async(
+                        CoreRFID.register_scan
+                    )(id_tag)
+                account = await self._get_account(id_tag)
+                if id_tag and not self.charger.require_rfid:
+                    seen_tag = await self._ensure_rfid_seen(id_tag)
+                    if seen_tag:
+                        tag = seen_tag
                 await self._assign_connector(payload.get("connectorId"))
+                authorized = True
+                authorized_via_tag = False
                 if self.charger.require_rfid:
-                    authorized = (
-                        account is not None
-                        and await database_sync_to_async(account.can_authorize)()
-                    )
-                else:
-                    authorized = True
+                    if account is not None:
+                        authorized = await database_sync_to_async(
+                            account.can_authorize
+                        )()
+                    elif (
+                        id_tag
+                        and tag
+                        and not tag_created
+                        and getattr(tag, "allowed", False)
+                    ):
+                        authorized = True
+                        authorized_via_tag = True
+                    else:
+                        authorized = False
                 if authorized:
+                    if authorized_via_tag and tag:
+                        self._log_unlinked_rfid(tag.rfid)
                     start_timestamp = _parse_ocpp_timestamp(payload.get("timestamp"))
                     received_start = timezone.now()
                     tx_obj = await database_sync_to_async(Transaction.objects.create)(

ocpp/models.py

@@ -82,6 +82,13 @@ class Charger(Entity):
         default=True,
         help_text="Display this charger on the public status dashboard.",
     )
+    language = models.CharField(
+        _("Language"),
+        max_length=12,
+        choices=settings.LANGUAGES,
+        default="es",
+        help_text=_("Preferred language for the public landing page."),
+    )
     require_rfid = models.BooleanField(
         _("Require RFID Authorization"),
         default=False,

ocpp/store.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-from datetime import datetime
+from datetime import datetime, timezone
 import json
 from pathlib import Path
 import re
@@ -427,7 +427,7 @@ def _file_path(cid: str, log_type: str = "charger") -> Path:
 def add_log(cid: str, entry: str, log_type: str = "charger") -> None:
     """Append a timestamped log entry for the given id and log type."""
 
-    timestamp = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
+    timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
     entry = f"{timestamp} {entry}"
 
     store = logs[log_type]
@@ -454,7 +454,7 @@ def start_session_log(cid: str, tx_id: int) -> None:
 
     history[cid] = {
         "transaction": tx_id,
-        "start": datetime.utcnow(),
+        "start": datetime.now(timezone.utc),
         "messages": [],
     }
 
@@ -467,7 +467,9 @@ def add_session_message(cid: str, message: str) -> None:
         return
     sess["messages"].append(
         {
-            "timestamp": datetime.utcnow().isoformat() + "Z",
+            "timestamp": datetime.now(timezone.utc)
+            .isoformat()
+            .replace("+00:00", "Z"),
             "message": message,
         }
     )