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

ocpp/tasks.py

@@ -1,21 +1,174 @@
+import json
 import logging
+import uuid
+from dataclasses import dataclass
 from datetime import date, datetime, time, timedelta
 from pathlib import Path
+from typing import Iterable
 
+from asgiref.sync import async_to_sync
 from celery import shared_task
 from django.conf import settings
 from django.contrib.auth import get_user_model
+from django.db.models import Q, Prefetch
 from django.utils import timezone
-from django.db.models import Q
+from urllib.parse import quote, urlsplit, urlunsplit
+from websocket import WebSocketException, create_connection
 
 from core import mailer
 from nodes.models import Node
 
-from .models import MeterValue, Transaction
-
+from . import store
+from .models import Charger, MeterValue, Transaction
 logger = logging.getLogger(__name__)
 
 
+@dataclass
+class ForwardingSession:
+    """Active websocket forwarding session for a charge point."""
+
+    charger_pk: int
+    node_id: int | None
+    url: str
+    connection: object
+    connected_at: datetime
+
+    @property
+    def is_connected(self) -> bool:
+        return bool(getattr(self.connection, "connected", False))
+
+
+_FORWARDING_SESSIONS: dict[int, ForwardingSession] = {}
+
+def _candidate_forwarding_urls(node: Node, charger: Charger) -> Iterable[str]:
+    """Yield websocket URLs suitable for forwarding ``charger`` via ``node``."""
+
+    charger_id = (charger.charger_id or "").strip()
+    if not charger_id:
+        return []
+
+    encoded_id = quote(charger_id, safe="")
+    for base in node.iter_remote_urls("/"):
+        if not base:
+            continue
+        parsed = urlsplit(base)
+        if parsed.scheme not in {"http", "https"}:
+            continue
+        scheme = "wss" if parsed.scheme == "https" else "ws"
+        base_path = parsed.path.rstrip("/")
+        for prefix in ("", "/ws"):
+            path = f"{base_path}{prefix}/{encoded_id}".replace("//", "/")
+            if not path.startswith("/"):
+                path = f"/{path}"
+            yield urlunsplit((scheme, parsed.netloc, path, "", ""))
+
+
+def _close_forwarding_session(session: ForwardingSession) -> None:
+    """Close the websocket connection associated with ``session`` if open."""
+
+    connection = session.connection
+    if connection is None:
+        return
+    try:
+        connection.close()
+    except Exception:  # pragma: no cover - best effort close
+        pass
+
+
+@shared_task
+def check_charge_point_configuration(charger_pk: int) -> bool:
+    """Request the latest configuration from a connected charge point."""
+
+    try:
+        charger = Charger.objects.get(pk=charger_pk)
+    except Charger.DoesNotExist:
+        logger.warning(
+            "Unable to request configuration for missing charger %s",
+            charger_pk,
+        )
+        return False
+
+    connector_value = charger.connector_id
+    if connector_value is not None:
+        logger.debug(
+            "Skipping charger %s: connector %s is not eligible for automatic configuration checks",
+            charger.charger_id,
+            connector_value,
+        )
+        return False
+
+    ws = store.get_connection(charger.charger_id, connector_value)
+    if ws is None:
+        logger.info(
+            "Charge point %s is not connected; configuration request skipped",
+            charger.charger_id,
+        )
+        return False
+
+    message_id = uuid.uuid4().hex
+    payload: dict[str, object] = {}
+    msg = json.dumps([2, message_id, "GetConfiguration", payload])
+
+    try:
+        async_to_sync(ws.send)(msg)
+    except Exception as exc:  # pragma: no cover - network error
+        logger.warning(
+            "Failed to send GetConfiguration to %s (%s)",
+            charger.charger_id,
+            exc,
+        )
+        return False
+
+    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": "GetConfiguration",
+            "charger_id": charger.charger_id,
+            "connector_id": connector_value,
+            "log_key": log_key,
+            "requested_at": timezone.now(),
+        },
+    )
+    store.schedule_call_timeout(
+        message_id,
+        timeout=5.0,
+        action="GetConfiguration",
+        log_key=log_key,
+        message=(
+            "GetConfiguration timed out: charger did not respond"
+            " (operation may not be supported)"
+        ),
+    )
+    logger.info(
+        "Requested configuration from charge point %s",
+        charger.charger_id,
+    )
+    return True
+
+
+@shared_task
+def schedule_daily_charge_point_configuration_checks() -> int:
+    """Dispatch configuration requests for eligible charge points."""
+
+    charger_ids = list(
+        Charger.objects.filter(connector_id__isnull=True).values_list("pk", flat=True)
+    )
+    if not charger_ids:
+        logger.debug("No eligible charge points available for configuration check")
+        return 0
+
+    scheduled = 0
+    for charger_pk in charger_ids:
+        check_charge_point_configuration.delay(charger_pk)
+        scheduled += 1
+    logger.info(
+        "Scheduled configuration checks for %s charge point(s)", scheduled
+    )
+    return scheduled
+
+
 @shared_task
 def purge_meter_values() -> int:
     """Delete meter values older than 7 days.
@@ -37,6 +190,101 @@ def purge_meter_values() -> int:
 purge_meter_readings = purge_meter_values
 
 
+@shared_task(rate_limit="1/10m")
+def push_forwarded_charge_points() -> int:
+    """Ensure websocket connections exist for forwarded charge points."""
+
+    local = Node.get_local()
+    if not local:
+        logger.debug("Forwarding skipped: local node not registered")
+        return 0
+
+    chargers_qs = (
+        Charger.objects.filter(export_transactions=True, forwarded_to__isnull=False)
+        .select_related("forwarded_to", "node_origin")
+        .order_by("pk")
+    )
+
+    node_filter = Q(node_origin__isnull=True)
+    if local.pk:
+        node_filter |= Q(node_origin=local)
+
+    chargers = list(chargers_qs.filter(node_filter))
+    active_ids = {charger.pk for charger in chargers}
+
+    # Close sessions that no longer map to active forwarded chargers.
+    for pk in list(_FORWARDING_SESSIONS.keys()):
+        if pk not in active_ids:
+            session = _FORWARDING_SESSIONS.pop(pk)
+            _close_forwarding_session(session)
+
+    if not chargers:
+        return 0
+
+    connected = 0
+
+    for charger in chargers:
+        target = charger.forwarded_to
+        if not target:
+            continue
+        if local.pk and target.pk == local.pk:
+            continue
+
+        existing = _FORWARDING_SESSIONS.get(charger.pk)
+        if existing and existing.node_id == getattr(target, "pk", None):
+            if existing.is_connected:
+                continue
+            _close_forwarding_session(existing)
+            _FORWARDING_SESSIONS.pop(charger.pk, None)
+
+        for url in _candidate_forwarding_urls(target, charger):
+            try:
+                connection = create_connection(
+                    url,
+                    timeout=5,
+                    subprotocols=["ocpp1.6"],
+                )
+            except (WebSocketException, OSError) as exc:
+                logger.warning(
+                    "Websocket forwarding connection to %s via %s failed: %s",
+                    target,
+                    url,
+                    exc,
+                )
+                continue
+
+            session = ForwardingSession(
+                charger_pk=charger.pk,
+                node_id=getattr(target, "pk", None),
+                url=url,
+                connection=connection,
+                connected_at=timezone.now(),
+            )
+            _FORWARDING_SESSIONS[charger.pk] = session
+            Charger.objects.filter(pk=charger.pk).update(
+                forwarding_watermark=session.connected_at
+            )
+            connected += 1
+            logger.info(
+                "Established forwarding websocket for charger %s to %s via %s",
+                charger.charger_id,
+                target,
+                url,
+            )
+            break
+        else:
+            logger.warning(
+                "Unable to establish forwarding websocket for charger %s",
+                charger.charger_id or charger.pk,
+            )
+
+    return connected
+
+
+# Backwards compatibility alias for legacy schedules
+sync_remote_chargers = push_forwarded_charge_points
+
+
 def _resolve_report_window() -> tuple[datetime, datetime, date]:
     """Return the start/end datetimes for today's reporting window."""
 
@@ -113,9 +361,15 @@ def send_daily_session_report() -> int:
         return 0
 
     start, end, today = _resolve_report_window()
+    meter_value_prefetch = Prefetch(
+        "meter_values",
+        queryset=MeterValue.objects.filter(energy__isnull=False).order_by("timestamp"),
+        to_attr="prefetched_meter_values",
+    )
     transactions = list(
         Transaction.objects.filter(start_time__gte=start, start_time__lt=end)
         .select_related("charger", "account")
+        .prefetch_related(meter_value_prefetch)
         .order_by("start_time")
     )
     if not transactions:
@@ -149,6 +403,10 @@ def send_daily_session_report() -> int:
         lines.append(f"   Account: {account}")
         if transaction.rfid:
             lines.append(f"   RFID: {transaction.rfid}")
+        identifier = transaction.vehicle_identifier
+        if identifier:
+            label = "VID" if transaction.vehicle_identifier_source == "vid" else "VIN"
+            lines.append(f"   {label}: {identifier}")
         if connector:
             lines.append(f"   {connector}")
         lines.append(

ocpp/test_export_import.py

@@ -111,6 +111,7 @@ class TransactionAdminExportImportTests(TestCase):
                     "charger": "C9",
                     "account": None,
                     "rfid": "",
+                    "vid": "",
                     "vin": "",
                     "meter_start": 0,
                     "meter_stop": 0,

ocpp/test_rfid.py

@@ -131,7 +131,7 @@ class ScanNextViewTests(TestCase):
         self.assertEqual(
             resp.json(), {"rfid": "ABCD1234", "label_id": 1, "created": False}
         )
-        mock_validate.assert_called_once_with("ABCD1234", kind=None)
+        mock_validate.assert_called_once_with("ABCD1234", kind=None, endianness=None)
 
     @patch("config.middleware.Node.get_local", return_value=None)
     @patch("config.middleware.get_site")
@@ -342,16 +342,20 @@ class ValidateRfidValueTests(SimpleTestCase):
         tag.released = False
         tag.reference = None
         tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.BIG_ENDIAN
         mock_register.return_value = (tag, True)
 
         result = validate_rfid_value("abcd1234")
 
-        mock_register.assert_called_once_with("ABCD1234", kind=None)
+        mock_register.assert_called_once_with(
+            "ABCD1234", kind=None, endianness=RFID.BIG_ENDIAN
+        )
         tag.save.assert_called_once_with(update_fields=["last_seen_on"])
         self.assertIs(tag.last_seen_on, fake_now)
         mock_notify.assert_called_once_with("RFID 1 OK", "ABCD1234 B")
         self.assertTrue(result["created"])
         self.assertEqual(result["rfid"], "ABCD1234")
+        self.assertEqual(result["endianness"], RFID.BIG_ENDIAN)
 
     @patch("ocpp.rfid.reader.timezone.now")
     @patch("ocpp.rfid.reader.notify_async")
@@ -367,11 +371,14 @@ class ValidateRfidValueTests(SimpleTestCase):
         tag.released = True
         tag.reference = None
         tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.BIG_ENDIAN
         mock_register.return_value = (tag, False)
 
         result = validate_rfid_value("abcd", kind=RFID.NTAG215)
 
-        mock_register.assert_called_once_with("ABCD", kind=RFID.NTAG215)
+        mock_register.assert_called_once_with(
+            "ABCD", kind=RFID.NTAG215, endianness=RFID.BIG_ENDIAN
+        )
         tag.save.assert_called_once_with(update_fields=["kind", "last_seen_on"])
         self.assertIs(tag.last_seen_on, fake_now)
         self.assertEqual(tag.kind, RFID.NTAG215)
@@ -379,6 +386,36 @@ class ValidateRfidValueTests(SimpleTestCase):
         self.assertFalse(result["allowed"])
         self.assertFalse(result["created"])
         self.assertEqual(result["kind"], RFID.NTAG215)
+        self.assertEqual(result["endianness"], RFID.BIG_ENDIAN)
+
+    @patch("ocpp.rfid.reader.timezone.now")
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.RFID.register_scan")
+    def test_registers_little_endian_value(
+        self, mock_register, mock_notify, mock_now
+    ):
+        fake_now = object()
+        mock_now.return_value = fake_now
+        tag = MagicMock()
+        tag.pk = 7
+        tag.label_id = 7
+        tag.allowed = True
+        tag.color = "B"
+        tag.released = False
+        tag.reference = None
+        tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.LITTLE_ENDIAN
+        mock_register.return_value = (tag, True)
+
+        result = validate_rfid_value("A1B2C3D4", endianness=RFID.LITTLE_ENDIAN)
+
+        mock_register.assert_called_once_with(
+            "D4C3B2A1", kind=None, endianness=RFID.LITTLE_ENDIAN
+        )
+        tag.save.assert_called_once_with(update_fields=["last_seen_on"])
+        self.assertEqual(result["rfid"], "D4C3B2A1")
+        self.assertEqual(result["endianness"], RFID.LITTLE_ENDIAN)
+        mock_notify.assert_called_once()
 
     def test_rejects_invalid_value(self):
         result = validate_rfid_value("invalid!")
@@ -412,6 +449,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         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="ok\n", stderr=""
@@ -427,6 +465,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         env = run_kwargs.get("env", {})
         self.assertEqual(env.get("RFID_VALUE"), "ABCD1234")
         self.assertEqual(env.get("RFID_LABEL_ID"), "1")
+        self.assertEqual(env.get("RFID_ENDIANNESS"), RFID.BIG_ENDIAN)
         mock_popen.assert_not_called()
         mock_notify.assert_called_once_with("RFID 1 OK", "ABCD1234 B")
         tag.save.assert_called_once_with(update_fields=["last_seen_on"])
@@ -437,6 +476,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         self.assertEqual(output.get("stderr"), "")
         self.assertEqual(output.get("returncode"), 0)
         self.assertEqual(output.get("error"), "")
+        self.assertEqual(result["endianness"], RFID.BIG_ENDIAN)
 
     @patch("ocpp.rfid.reader.timezone.now")
     @patch("ocpp.rfid.reader.notify_async")
@@ -457,6 +497,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         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=1, stdout="", stderr="failure"
@@ -476,6 +517,77 @@ class ValidateRfidValueTests(SimpleTestCase):
         self.assertEqual(output.get("stderr"), "failure")
         self.assertEqual(output.get("error"), "")
         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")
@@ -497,6 +609,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         tag.released = False
         tag.reference = None
         tag.kind = RFID.CLASSIC
+        tag.endianness = RFID.BIG_ENDIAN
         mock_register.return_value = (tag, False)
         result = validate_rfid_value("abcdef")
 
@@ -507,10 +620,12 @@ class ValidateRfidValueTests(SimpleTestCase):
         env = kwargs.get("env", {})
         self.assertEqual(env.get("RFID_VALUE"), "ABCDEF")
         self.assertEqual(env.get("RFID_LABEL_ID"), "3")
+        self.assertEqual(env.get("RFID_ENDIANNESS"), RFID.BIG_ENDIAN)
         self.assertIs(kwargs.get("stdout"), subprocess.DEVNULL)
         self.assertIs(kwargs.get("stderr"), subprocess.DEVNULL)
         self.assertTrue(result["allowed"])
         mock_notify.assert_called_once_with("RFID 3 OK", "ABCDEF B")
+        self.assertEqual(result["endianness"], RFID.BIG_ENDIAN)
 
 
 class CardTypeDetectionTests(TestCase):
@@ -592,11 +707,12 @@ class RFIDLastSeenTests(TestCase):
 
 class RFIDDetectionScriptTests(SimpleTestCase):
     @patch("ocpp.rfid.detect._ensure_django")
+    @patch("ocpp.rfid.detect._lockfile_status", return_value=(False, None))
     @patch(
         "ocpp.rfid.irq_wiring_check.check_irq_pin",
         return_value={"irq_pin": DEFAULT_IRQ_PIN},
     )
-    def test_detect_scanner_success(self, mock_check, _mock_setup):
+    def test_detect_scanner_success(self, mock_check, _mock_lock, _mock_setup):
         result = detect_scanner()
         self.assertEqual(
             result,
@@ -608,16 +724,34 @@ class RFIDDetectionScriptTests(SimpleTestCase):
         mock_check.assert_called_once()
 
     @patch("ocpp.rfid.detect._ensure_django")
+    @patch("ocpp.rfid.detect._lockfile_status", return_value=(False, None))
     @patch(
         "ocpp.rfid.irq_wiring_check.check_irq_pin",
         return_value={"error": "no scanner detected"},
     )
-    def test_detect_scanner_failure(self, mock_check, _mock_setup):
+    def test_detect_scanner_failure(self, mock_check, _mock_lock, _mock_setup):
         result = detect_scanner()
         self.assertFalse(result["detected"])
         self.assertEqual(result["reason"], "no scanner detected")
         mock_check.assert_called_once()
 
+    @patch("ocpp.rfid.detect._ensure_django")
+    @patch(
+        "ocpp.rfid.detect._lockfile_status",
+        return_value=(True, Path("/locks/rfid.lck")),
+    )
+    @patch(
+        "ocpp.rfid.irq_wiring_check.check_irq_pin",
+        return_value={"error": "no scanner detected"},
+    )
+    def test_detect_scanner_assumed_with_lock(self, mock_check, _mock_lock, _mock_setup):
+        result = detect_scanner()
+        self.assertTrue(result["detected"])
+        self.assertTrue(result["assumed"])
+        self.assertEqual(result["reason"], "no scanner detected")
+        self.assertEqual(result["lockfile"], "/locks/rfid.lck")
+        mock_check.assert_called_once()
+
     @patch(
         "ocpp.rfid.detect.detect_scanner",
         return_value={"detected": True, "irq_pin": DEFAULT_IRQ_PIN},
@@ -642,6 +776,58 @@ class RFIDDetectionScriptTests(SimpleTestCase):
         self.assertIn("missing hardware", buffer.getvalue())
         mock_detect.assert_called_once()
 
+    @patch(
+        "ocpp.rfid.detect.detect_scanner",
+        return_value={
+            "detected": True,
+            "assumed": True,
+            "reason": "no scanner detected",
+            "lockfile": "/locks/rfid.lck",
+        },
+    )
+    def test_detect_main_assumed_output(self, mock_detect):
+        buffer = io.StringIO()
+        with patch("sys.stdout", new=buffer):
+            exit_code = detect_main([])
+        self.assertEqual(exit_code, 0)
+        self.assertIn("assumed active", buffer.getvalue())
+        self.assertIn("/locks/rfid.lck", buffer.getvalue())
+        mock_detect.assert_called_once()
+
+
+class RFIDLockFileUsageTests(SimpleTestCase):
+    @patch("ocpp.rfid.background_reader.is_configured", return_value=True)
+    def test_queue_result_marks_lock(self, _mock_config):
+        with patch(
+            "ocpp.rfid.background_reader._tag_queue.get",
+            return_value={"rfid": "ABC"},
+        ) as mock_get, patch(
+            "ocpp.rfid.background_reader._mark_scanner_used"
+        ) as mock_mark:
+            result = background_reader.get_next_tag()
+        self.assertEqual(result["rfid"], "ABC")
+        mock_get.assert_called_once()
+        mock_mark.assert_called_once()
+
+    @patch("ocpp.rfid.background_reader.is_configured", return_value=True)
+    def test_direct_read_marks_lock(self, _mock_config):
+        with (
+            patch(
+                "ocpp.rfid.background_reader._tag_queue.get",
+                side_effect=background_reader.queue.Empty,
+            ) as mock_get,
+            patch(
+                "ocpp.rfid.reader.read_rfid",
+                return_value={"rfid": "XYZ"},
+            ) as mock_read,
+            patch("ocpp.rfid.background_reader._mark_scanner_used") as mock_mark,
+        ):
+            result = background_reader.get_next_tag()
+        self.assertEqual(result["rfid"], "XYZ")
+        mock_get.assert_called_once()
+        mock_read.assert_called_once()
+        mock_mark.assert_called_once()
+
 
 class RFIDLandingTests(TestCase):
     def test_scanner_view_registered_as_landing(self):
@@ -656,7 +842,9 @@ class RFIDLandingTests(TestCase):
         app = Application.objects.create(name="Ocpp")
         module = Module.objects.create(node_role=role, application=app, path="/ocpp/")
         module.create_landings()
-        self.assertTrue(module.landings.filter(path="/ocpp/rfid/").exists())
+        self.assertTrue(
+            module.landings.filter(path="/ocpp/rfid/validator/").exists()
+        )
 
 
 class ScannerTemplateTests(TestCase):