arthexis 0.1.17__tar.gz → 0.1.18__tar.gz

{arthexis-0.1.17 → arthexis-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arthexis
-Version: 0.1.17
+Version: 0.1.18
 Summary: Power & Energy Infrastructure
 Author-email: "Rafael J. Guillén-Osorio" <tecnologia@gelectriic.com>
 License-Expression: GPL-3.0-only

{arthexis-0.1.17 → arthexis-0.1.18}/arthexis.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arthexis
-Version: 0.1.17
+Version: 0.1.18
 Summary: Power & Energy Infrastructure
 Author-email: "Rafael J. Guillén-Osorio" <tecnologia@gelectriic.com>
 License-Expression: GPL-3.0-only

{arthexis-0.1.17 → arthexis-0.1.18}/arthexis.egg-info/SOURCES.txt

@@ -107,6 +107,7 @@ pages/forms.py
 pages/middleware.py
 pages/models.py
 pages/module_defaults.py
+pages/site_config.py
 pages/tasks.py
 pages/tests.py
 pages/urls.py
@@ -207,6 +208,7 @@ tests/test_release_progress.py
 tests/test_release_progress_pre_release_integration.py
 tests/test_release_push.py
 tests/test_release_tasks.py
+tests/test_render_nginx_sites.py
 tests/test_request_invite.py
 tests/test_rfid_admin_print_labels.py
 tests/test_rfid_admin_reference_clear.py

arthexis-0.1.18/config/middleware.py

@@ -0,0 +1,71 @@
+import socket
+from django.core.exceptions import DisallowedHost
+from django.http import HttpResponsePermanentRedirect
+from nodes.models import Node
+from utils.sites import get_site
+
+from .active_app import set_active_app
+
+
+class ActiveAppMiddleware:
+    """Store the current app based on the request's site."""
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        site = get_site(request)
+        node = Node.get_local()
+        role_name = node.role.name if node and node.role else "Terminal"
+        active = site.name or role_name
+        set_active_app(active)
+        request.site = site
+        request.active_app = active
+        try:
+            response = self.get_response(request)
+        finally:
+            set_active_app(socket.gethostname())
+        return response
+
+
+def _is_https_request(request) -> bool:
+    if request.is_secure():
+        return True
+
+    forwarded_proto = request.META.get("HTTP_X_FORWARDED_PROTO", "")
+    if forwarded_proto:
+        candidate = forwarded_proto.split(",")[0].strip().lower()
+        if candidate == "https":
+            return True
+
+    forwarded_header = request.META.get("HTTP_FORWARDED", "")
+    for forwarded_part in forwarded_header.split(","):
+        for element in forwarded_part.split(";"):
+            key, _, value = element.partition("=")
+            if key.strip().lower() == "proto" and value.strip().strip('"').lower() == "https":
+                return True
+
+    return False
+
+
+class SiteHttpsRedirectMiddleware:
+    """Redirect HTTP traffic to HTTPS for sites that require it."""
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        site = getattr(request, "site", None)
+        if site is None:
+            site = get_site(request)
+            request.site = site
+
+        if getattr(site, "require_https", False) and not _is_https_request(request):
+            try:
+                host = request.get_host()
+            except DisallowedHost:  # pragma: no cover - defensive guard
+                host = request.META.get("HTTP_HOST", "")
+            redirect_url = f"https://{host}{request.get_full_path()}"
+            return HttpResponsePermanentRedirect(redirect_url)
+
+        return self.get_response(request)

{arthexis-0.1.17 → arthexis-0.1.18}/config/settings.py

@@ -390,6 +390,7 @@ MIDDLEWARE = [
     "whitenoise.middleware.WhiteNoiseMiddleware",
     "django.contrib.sessions.middleware.SessionMiddleware",
     "config.middleware.ActiveAppMiddleware",
+    "config.middleware.SiteHttpsRedirectMiddleware",
     "django.middleware.locale.LocaleMiddleware",
     "django.middleware.common.CommonMiddleware",
     "django.middleware.csrf.CsrfViewMiddleware",

{arthexis-0.1.17 → arthexis-0.1.18}/config/urls.py

@@ -149,6 +149,11 @@ urlpatterns = [
         core_views.odoo_quote_report,
         name="odoo-quote-report",
     ),
+    path(
+        "admin/request-temp-password/",
+        core_views.request_temp_password,
+        name="admin-request-temp-password",
+    ),
     path("admin/", admin.site.urls),
     path("i18n/setlang/", csrf_exempt(set_language), name="set_language"),
     path("api/", include("core.workgroup_urls")),

{arthexis-0.1.17 → arthexis-0.1.18}/core/admin.py

@@ -2947,7 +2947,7 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
         "toggle_selected_released",
         "toggle_selected_allowed",
     ]
-    readonly_fields = ("added_on", "last_seen_on")
+    readonly_fields = ("added_on", "last_seen_on", "reversed_uid")
     form = RFIDForm
 
     def get_import_resource_kwargs(self, request, form=None, **kwargs):

{arthexis-0.1.17 → arthexis-0.1.18}/core/models.py

@@ -1775,6 +1775,14 @@ class RFID(Entity):
             )
         ],
     )
+    reversed_uid = models.CharField(
+        max_length=255,
+        default="",
+        blank=True,
+        editable=False,
+        verbose_name="Reversed UID",
+        help_text="UID value stored with opposite endianness for reference.",
+    )
     custom_label = models.CharField(
         max_length=32,
         blank=True,
@@ -1906,7 +1914,16 @@ class RFID(Entity):
                 if self.key_b and old["key_b"] != self.key_b.upper():
                     self.key_b_verified = False
         if self.rfid:
-            self.rfid = self.rfid.upper()
+            normalized_rfid = self.rfid.upper()
+            self.rfid = normalized_rfid
+            reversed_uid = self.reverse_uid(normalized_rfid)
+            if reversed_uid != self.reversed_uid:
+                self.reversed_uid = reversed_uid
+                if update_fields:
+                    fields = set(update_fields)
+                    if "reversed_uid" not in fields:
+                        fields.add("reversed_uid")
+                        kwargs["update_fields"] = tuple(fields)
         if self.key_a:
             self.key_a = self.key_a.upper()
         if self.key_b:
@@ -1933,6 +1950,19 @@ class RFID(Entity):
                 return candidate
         return cls.BIG_ENDIAN
 
+    @staticmethod
+    def reverse_uid(value: str) -> str:
+        """Return ``value`` with reversed byte order for reference storage."""
+
+        normalized = "".join((value or "").split()).upper()
+        if not normalized:
+            return ""
+        if len(normalized) % 2 != 0:
+            return normalized[::-1]
+        bytes_list = [normalized[index : index + 2] for index in range(0, len(normalized), 2)]
+        bytes_list.reverse()
+        return "".join(bytes_list)
+
     @classmethod
     def next_scan_label(
         cls, *, step: int | None = None, start: int | None = None

{arthexis-0.1.17 → arthexis-0.1.18}/core/tests.py

@@ -550,6 +550,15 @@ class RFIDValidationTests(TestCase):
         tag = RFID.objects.create(rfid="DEADBEEF10")
         self.assertEqual(tag.rfid, "DEADBEEF10")
 
+    def test_reversed_uid_updates_with_rfid(self):
+        tag = RFID.objects.create(rfid="A1B2C3D4")
+        self.assertEqual(tag.reversed_uid, "D4C3B2A1")
+
+        tag.rfid = "112233"
+        tag.save(update_fields=["rfid"])
+        tag.refresh_from_db()
+        self.assertEqual(tag.reversed_uid, "332211")
+
     def test_find_user_by_rfid(self):
         user = User.objects.create_user(username="finder", password="pwd")
         acc = EnergyAccount.objects.create(user=user, name="FINDER")

{arthexis-0.1.17 → arthexis-0.1.18}/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."""
@@ -1855,26 +1885,34 @@ 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
+    if not pending_items:
+        ctx["todos_ack"] = True
+        ctx["todos_ack_auto"] = True
+    elif ack_todos_requested:
+        failures = []
+        for todo in pending_items:
+            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,
@@ -1885,9 +1923,6 @@ def release_progress(request, pk: int, action: str):
             for todo in pending_items
         ]
         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 +1932,8 @@ def release_progress(request, pk: int, action: str):
             "started": ctx.get("started", False),
         }
         step_count = 0
+        if not pending_items:
+            ctx["todos_ack"] = True
     log_path = log_dir / log_name
     ctx.setdefault("log", log_name)
     ctx.setdefault("paused", False)

{arthexis-0.1.17 → arthexis-0.1.18}/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)(

{arthexis-0.1.17 → arthexis-0.1.18}/ocpp/test_rfid.py

@@ -519,6 +519,76 @@ class ValidateRfidValueTests(SimpleTestCase):
         mock_popen.assert_not_called()
         self.assertEqual(result["endianness"], RFID.BIG_ENDIAN)
 
+    @patch("ocpp.rfid.reader.timezone.now")
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.subprocess.Popen")
+    @patch("ocpp.rfid.reader.subprocess.run")
+    @patch("ocpp.rfid.reader.RFID.register_scan")
+    def test_external_command_strips_trailing_percent_tokens(
+        self, mock_register, mock_run, mock_popen, mock_notify, mock_now
+    ):
+        mock_now.return_value = timezone.now()
+        tag = MagicMock()
+        tag.pk = 3
+        tag.label_id = 3
+        tag.allowed = True
+        tag.external_command = "echo weird"
+        tag.color = "Y"
+        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="first %\nsecond 50%\r\nthird % %\n",
+            stderr="oops %\n",
+        )
+
+        result = validate_rfid_value("abc3")
+
+        output = result.get("command_output")
+        self.assertIsNotNone(output)
+        self.assertEqual(
+            output.get("stdout"), "first\nsecond 50%\r\nthird\n"
+        )
+        self.assertEqual(output.get("stderr"), "oops\n")
+        self.assertEqual(output.get("returncode"), 0)
+        self.assertEqual(output.get("error"), "")
+        mock_popen.assert_not_called()
+
+    @patch("ocpp.rfid.reader.timezone.now")
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.subprocess.Popen")
+    @patch("ocpp.rfid.reader.subprocess.run")
+    @patch("ocpp.rfid.reader.RFID.register_scan")
+    def test_external_command_error_strips_trailing_percent_tokens(
+        self, mock_register, mock_run, mock_popen, mock_notify, mock_now
+    ):
+        mock_now.return_value = timezone.now()
+        tag = MagicMock()
+        tag.pk = 4
+        tag.label_id = 4
+        tag.allowed = True
+        tag.external_command = "echo boom"
+        tag.color = "R"
+        tag.released = False
+        tag.reference = None
+        tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.BIG_ENDIAN
+        mock_register.return_value = (tag, False)
+        mock_run.side_effect = RuntimeError("bad % %")
+
+        result = validate_rfid_value("abcd")
+
+        output = result.get("command_output")
+        self.assertIsInstance(output, dict)
+        self.assertEqual(output.get("stdout"), "")
+        self.assertEqual(output.get("stderr"), "")
+        self.assertEqual(output.get("error"), "bad")
+        self.assertFalse(result["allowed"])
+        mock_popen.assert_not_called()
+
     @patch("ocpp.rfid.reader.timezone.now")
     @patch("ocpp.rfid.reader.notify_async")
     @patch("ocpp.rfid.reader.subprocess.Popen")

{arthexis-0.1.17 → arthexis-0.1.18}/ocpp/tests.py

@@ -2949,6 +2949,44 @@ class SimulatorAdminTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    async def test_authorize_requires_rfid_accepts_allowed_tag_without_account(self):
+        charger_id = "AUTHWARN"
+        tag_value = "WARN01"
+        await database_sync_to_async(Charger.objects.create)(
+            charger_id=charger_id, require_rfid=True
+        )
+        await database_sync_to_async(RFID.objects.create)(rfid=tag_value, allowed=True)
+
+        pending_key = store.pending_key(charger_id)
+        store.clear_log(pending_key, log_type="charger")
+
+        communicator = WebsocketCommunicator(application, f"/{charger_id}/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        message_id = "auth-unlinked"
+        await communicator.send_json_to(
+            [2, message_id, "Authorize", {"idTag": tag_value}]
+        )
+        response = await communicator.receive_json_from()
+        self.assertEqual(response[0], 3)
+        self.assertEqual(response[1], message_id)
+        self.assertEqual(response[2], {"idTagInfo": {"status": "Accepted"}})
+
+        log_entries = store.get_logs(pending_key, log_type="charger")
+        self.assertTrue(
+            any(
+                "Authorized RFID" in entry
+                and tag_value in entry
+                and charger_id in entry
+                for entry in log_entries
+            ),
+            log_entries,
+        )
+
+        await communicator.disconnect()
+        store.clear_log(pending_key, log_type="charger")
+
     async def test_authorize_without_requirement_records_rfid(self):
         await database_sync_to_async(Charger.objects.create)(
             charger_id="AUTHOPT", require_rfid=False
@@ -3041,6 +3079,61 @@ class SimulatorAdminTests(TransactionTestCase):
         )
         self.assertEqual(tx.account_id, user.energy_account.id)
 
+    async def test_start_transaction_allows_allowed_tag_without_account(self):
+        charger_id = "STARTWARN"
+        tag_value = "WARN02"
+        await database_sync_to_async(Charger.objects.create)(
+            charger_id=charger_id, require_rfid=True
+        )
+        await database_sync_to_async(RFID.objects.create)(rfid=tag_value, allowed=True)
+
+        pending_key = store.pending_key(charger_id)
+        store.clear_log(pending_key, log_type="charger")
+
+        communicator = WebsocketCommunicator(application, f"/{charger_id}/")
+        connected, _ = await communicator.connect()
+        self.assertTrue(connected)
+
+        start_payload = {
+            "meterStart": 5,
+            "idTag": tag_value,
+            "connectorId": 1,
+        }
+        await communicator.send_json_to([2, "start-1", "StartTransaction", start_payload])
+        response = await communicator.receive_json_from()
+        self.assertEqual(response[0], 3)
+        self.assertEqual(response[2]["idTagInfo"]["status"], "Accepted")
+        tx_id = response[2]["transactionId"]
+
+        tx = await database_sync_to_async(Transaction.objects.get)(
+            pk=tx_id, charger__charger_id=charger_id
+        )
+        self.assertIsNone(tx.account_id)
+
+        log_entries = store.get_logs(pending_key, log_type="charger")
+        self.assertTrue(
+            any(
+                "Authorized RFID" in entry
+                and tag_value in entry
+                and charger_id in entry
+                for entry in log_entries
+            ),
+            log_entries,
+        )
+
+        await communicator.send_json_to(
+            [
+                2,
+                "stop-1",
+                "StopTransaction",
+                {"transactionId": tx_id, "meterStop": 6},
+            ]
+        )
+        await communicator.receive_json_from()
+
+        await communicator.disconnect()
+        store.clear_log(pending_key, log_type="charger")
+
     async def test_status_fields_updated(self):
         communicator = WebsocketCommunicator(application, "/STAT/")
         connected, _ = await communicator.connect()

{arthexis-0.1.17 → arthexis-0.1.18}/ocpp/views.py

@@ -1209,17 +1209,38 @@ def charger_log_page(request, cid, connector=None):
             charger_id=cid
         )
         target_id = cid
-    log = store.get_logs(target_id, log_type=log_type)
+    limit_options = [
+        {"value": "10", "label": "10"},
+        {"value": "20", "label": "20"},
+        {"value": "40", "label": "40"},
+        {"value": "100", "label": "100"},
+        {"value": "all", "label": gettext("All")},
+    ]
+    allowed_values = [item["value"] for item in limit_options]
+    limit_choice = request.GET.get("limit", "20")
+    if limit_choice not in allowed_values:
+        limit_choice = "20"
+
+    log_entries = list(store.get_logs(target_id, log_type=log_type) or [])
+    if limit_choice != "all":
+        try:
+            limit_value = int(limit_choice)
+        except (TypeError, ValueError):
+            limit_value = 20
+            limit_choice = "20"
+        log_entries = log_entries[-limit_value:]
     return render(
         request,
         "ocpp/charger_logs.html",
         {
             "charger": charger,
-            "log": log,
+            "log": log_entries,
             "log_type": log_type,
             "connector_slug": connector_slug,
             "connector_links": connector_links,
             "status_url": status_url,
+            "log_limit_options": limit_options,
+            "log_limit_index": allowed_values.index(limit_choice),
         },
     )