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

ocpp/tasks.py

@@ -1,21 +1,143 @@
+import base64
+import json
 import logging
+import uuid
 from datetime import date, datetime, time, timedelta
 from pathlib import Path
 
+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.utils import timezone
 from django.db.models import Q
+from django.utils import timezone
+import requests
+from requests import RequestException
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import padding
 
 from core import mailer
 from nodes.models import Node
 
-from .models import MeterValue, Transaction
+from . import store
+from .models import Charger, MeterValue, Transaction
+from .network import (
+    newest_transaction_timestamp,
+    serialize_charger_for_network,
+    serialize_transactions_for_forwarding,
+)
 
 logger = logging.getLogger(__name__)
 
 
+def _sign_payload(payload_json: str, private_key) -> str | None:
+    if not private_key:
+        return None
+    try:
+        signature = private_key.sign(
+            payload_json.encode(),
+            padding.PKCS1v15(),
+            hashes.SHA256(),
+        )
+    except Exception:
+        return None
+    return base64.b64encode(signature).decode()
+
+
+@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 +159,174 @@ def purge_meter_values() -> int:
 purge_meter_readings = purge_meter_values
 
 
+@shared_task
+def push_forwarded_charge_points() -> int:
+    """Push local charge point sessions to configured upstream nodes."""
+
+    local = Node.get_local()
+    if not local:
+        logger.debug("Forwarding skipped: local node not registered")
+        return 0
+
+    private_key = local.get_private_key()
+    if private_key is None:
+        logger.warning("Forwarding skipped: missing local node private key")
+        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))
+    if not chargers:
+        return 0
+
+    grouped: dict[Node, list[Charger]] = {}
+    for charger in chargers:
+        target = charger.forwarded_to
+        if not target:
+            continue
+        if local.pk and target.pk == local.pk:
+            continue
+        grouped.setdefault(target, []).append(charger)
+
+    if not grouped:
+        return 0
+
+    forwarded_total = 0
+
+    for node, node_chargers in grouped.items():
+        if not node_chargers:
+            continue
+
+        initializing = [ch for ch in node_chargers if ch.forwarding_watermark is None]
+        charger_by_pk = {ch.pk: ch for ch in node_chargers}
+        transactions_map: dict[int, list[Transaction]] = {}
+
+        for charger in node_chargers:
+            watermark = charger.forwarding_watermark
+            if watermark is None:
+                continue
+            tx_queryset = (
+                Transaction.objects.filter(charger=charger, start_time__gt=watermark)
+                .select_related("charger")
+                .prefetch_related("meter_values")
+                .order_by("start_time")
+            )
+            txs = list(tx_queryset)
+            if txs:
+                transactions_map[charger.pk] = txs
+
+        transaction_payload = {"chargers": [], "transactions": []}
+        for charger_pk, txs in transactions_map.items():
+            charger = charger_by_pk[charger_pk]
+            transaction_payload["chargers"].append(
+                {
+                    "charger_id": charger.charger_id,
+                    "connector_id": charger.connector_id,
+                    "require_rfid": charger.require_rfid,
+                }
+            )
+            transaction_payload["transactions"].extend(
+                serialize_transactions_for_forwarding(txs)
+            )
+
+        payload = {
+            "requester": str(local.uuid),
+            "requester_mac": local.mac_address,
+            "requester_public_key": local.public_key,
+            "chargers": [serialize_charger_for_network(ch) for ch in initializing],
+        }
+
+        has_transactions = bool(transaction_payload["transactions"])
+        if has_transactions or payload["chargers"]:
+            payload["transactions"] = transaction_payload
+        else:
+            continue
+
+        payload_json = json.dumps(payload, separators=(",", ":"), sort_keys=True)
+        signature = _sign_payload(payload_json, private_key)
+        headers = {"Content-Type": "application/json"}
+        if signature:
+            headers["X-Signature"] = signature
+
+        success = False
+        attempted = False
+        for url in node.iter_remote_urls("/nodes/network/chargers/forward/"):
+            if not url:
+                continue
+
+            attempted = True
+            try:
+                response = requests.post(
+                    url, data=payload_json, headers=headers, timeout=5
+                )
+            except RequestException as exc:
+                logger.warning("Failed to forward chargers to %s: %s", node, exc)
+                continue
+
+            if not response.ok:
+                logger.warning(
+                    "Forwarding request to %s via %s returned %s",
+                    node,
+                    url,
+                    response.status_code,
+                )
+                continue
+
+            try:
+                data = response.json()
+            except ValueError:
+                logger.warning("Invalid JSON payload received from %s", node)
+                continue
+
+            if data.get("status") != "ok":
+                detail = data.get("detail") if isinstance(data, dict) else None
+                logger.warning(
+                    "Forwarding rejected by %s via %s: %s",
+                    node,
+                    url,
+                    detail or response.text or "Remote node rejected the request.",
+                )
+                continue
+
+            success = True
+            break
+
+        if not success:
+            if not attempted:
+                logger.warning(
+                    "No reachable host found for %s when forwarding chargers", node
+                )
+            continue
+
+        updates: dict[int, datetime] = {}
+        now = timezone.now()
+        for charger in initializing:
+            updates[charger.pk] = now
+        for charger_pk, txs in transactions_map.items():
+            latest = newest_transaction_timestamp(txs)
+            if latest:
+                updates[charger_pk] = latest
+
+        for pk, timestamp in updates.items():
+            Charger.objects.filter(pk=pk).update(forwarding_watermark=timestamp)
+
+        forwarded_total += len(transaction_payload["transactions"])
+
+    return forwarded_total
+
+
+# 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."""
 
@@ -149,6 +439,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):
@@ -656,7 +771,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):