arthexis 0.1.22__py3-none-any.whl → 0.1.24__py3-none-any.whl

ocpp/models.py

@@ -15,6 +15,7 @@ from nodes.models import Node
 
 from core.models import (
     EnergyAccount,
+    EnergyTariff,
     Reference,
     RFID as CoreRFID,
     ElectricVehicle as CoreElectricVehicle,
@@ -35,6 +36,22 @@ class Location(Entity):
     longitude = models.DecimalField(
         max_digits=9, decimal_places=6, null=True, blank=True
     )
+    zone = models.CharField(
+        max_length=3,
+        choices=EnergyTariff.Zone.choices,
+        blank=True,
+        null=True,
+        help_text=_("CFE climate zone used to select matching energy tariffs."),
+    )
+    contract_type = models.CharField(
+        max_length=16,
+        choices=EnergyTariff.ContractType.choices,
+        blank=True,
+        null=True,
+        help_text=_(
+            "CFE service contract type required to match energy tariff pricing."
+        ),
+    )
 
     def __str__(self) -> str:  # pragma: no cover - simple representation
         return self.name
@@ -215,6 +232,13 @@ class Charger(Entity):
             "Latest GetConfiguration response received from this charge point."
         ),
     )
+    node_origin = models.ForeignKey(
+        "nodes.Node",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="origin_chargers",
+    )
     manager_node = models.ForeignKey(
         "nodes.Node",
         on_delete=models.SET_NULL,
@@ -222,6 +246,9 @@ class Charger(Entity):
         blank=True,
         related_name="managed_chargers",
     )
+    allow_remote = models.BooleanField(default=False)
+    export_transactions = models.BooleanField(default=False)
+    last_online_at = models.DateTimeField(null=True, blank=True)
     owner_users = models.ManyToManyField(
         settings.AUTH_USER_MODEL,
         blank=True,
@@ -276,6 +303,24 @@ class Charger(Entity):
         user_group_ids = user.groups.values_list("pk", flat=True)
         return self.owner_groups.filter(pk__in=user_group_ids).exists()
 
+    @property
+    def is_local(self) -> bool:
+        """Return ``True`` when this charger originates from the local node."""
+
+        local = Node.get_local()
+        if not local:
+            return False
+        if self.node_origin_id is None:
+            return True
+        return self.node_origin_id == local.pk
+
+    def save(self, *args, **kwargs):
+        if self.node_origin_id is None:
+            local = Node.get_local()
+            if local:
+                self.node_origin = local
+        super().save(*args, **kwargs)
+
     class Meta:
         verbose_name = _("Charge Point")
         verbose_name_plural = _("Charge Points")
@@ -481,11 +526,17 @@ class Charger(Entity):
         ref_value = self._full_url()
         if url_targets_local_loopback(ref_value):
             return
-        if not self.reference or self.reference.value != ref_value:
+        if not self.reference:
             self.reference = Reference.objects.create(
                 value=ref_value, alt_text=self.charger_id
             )
             super().save(update_fields=["reference"])
+        elif self.reference.value != ref_value:
+            Reference.objects.filter(pk=self.reference_id).update(
+                value=ref_value, alt_text=self.charger_id
+            )
+            self.reference.value = ref_value
+            self.reference.alt_text = self.charger_id
 
     def refresh_manager_node(self, node: Node | None = None) -> Node | None:
         """Ensure ``manager_node`` matches the provided or local node."""
@@ -783,7 +834,11 @@ class Transaction(Entity):
     def vehicle_identifier(self) -> str:
         """Return the preferred vehicle identifier for this transaction."""
 
-        return (self.vid or self.vin or "").strip()
+        vid = (self.vid or "").strip()
+        if vid:
+            return vid
+
+        return (self.vin or "").strip()
 
     @property
     def vehicle_identifier_source(self) -> str:

ocpp/tasks.py

@@ -1,7 +1,9 @@
+import base64
 import json
 import logging
 import uuid
 from datetime import date, datetime, time, timedelta
+from decimal import Decimal, InvalidOperation
 from pathlib import Path
 
 from asgiref.sync import async_to_sync
@@ -9,17 +11,259 @@ 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.utils.dateparse import parse_datetime
 from django.db.models import Q
+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 . import store
-from .models import Charger, MeterValue, Transaction
+from .models import Charger, Location, MeterValue, Transaction
 
 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()
+
+
+def _parse_remote_datetime(value):
+    if not value:
+        return None
+    dt = parse_datetime(value)
+    if dt is None:
+        return None
+    if timezone.is_naive(dt):
+        dt = timezone.make_aware(dt, timezone.get_current_timezone())
+    return dt
+
+
+def _to_decimal(value):
+    if value in (None, ""):
+        return None
+    try:
+        return Decimal(str(value))
+    except (InvalidOperation, TypeError, ValueError):
+        return None
+
+
+def _apply_remote_charger_payload(node, payload: dict) -> Charger | None:
+    serial = Charger.normalize_serial(payload.get("charger_id"))
+    if not serial or Charger.is_placeholder_serial(serial):
+        return None
+
+    connector = payload.get("connector_id")
+    if connector in (None, ""):
+        connector_value = None
+    elif isinstance(connector, int):
+        connector_value = connector
+    else:
+        try:
+            connector_value = int(str(connector))
+        except (TypeError, ValueError):
+            connector_value = None
+
+    charger = Charger.objects.filter(
+        charger_id=serial, connector_id=connector_value
+    ).first()
+    if not charger:
+        return None
+
+    location_payload = payload.get("location")
+    location_obj = None
+    if isinstance(location_payload, dict):
+        name = location_payload.get("name")
+        if name:
+            location_obj, _ = Location.objects.get_or_create(name=name)
+            for field in ("latitude", "longitude", "zone", "contract_type"):
+                setattr(location_obj, field, location_payload.get(field))
+            location_obj.save()
+
+    datetime_fields = [
+        "firmware_timestamp",
+        "last_heartbeat",
+        "availability_state_updated_at",
+        "availability_requested_at",
+        "availability_request_status_at",
+        "diagnostics_timestamp",
+        "last_status_timestamp",
+    ]
+
+    updates: dict[str, object] = {
+        "node_origin": node,
+        "allow_remote": bool(payload.get("allow_remote", False)),
+        "export_transactions": bool(payload.get("export_transactions", False)),
+        "last_online_at": timezone.now(),
+    }
+
+    simple_fields = [
+        "display_name",
+        "language",
+        "public_display",
+        "require_rfid",
+        "firmware_status",
+        "firmware_status_info",
+        "last_status",
+        "last_error_code",
+        "last_status_vendor_info",
+        "availability_state",
+        "availability_requested_state",
+        "availability_request_status",
+        "availability_request_details",
+        "temperature",
+        "temperature_unit",
+        "diagnostics_status",
+        "diagnostics_location",
+    ]
+
+    for field in simple_fields:
+        updates[field] = payload.get(field)
+
+    if location_obj is not None:
+        updates["location"] = location_obj
+
+    for field in datetime_fields:
+        updates[field] = _parse_remote_datetime(payload.get(field))
+
+    updates["last_meter_values"] = payload.get("last_meter_values") or {}
+
+    Charger.objects.filter(pk=charger.pk).update(**updates)
+    charger.refresh_from_db()
+    return charger
+
+
+def _sync_transactions_payload(payload: dict) -> int:
+    if not isinstance(payload, dict):
+        return 0
+
+    chargers_map: dict[tuple[str, int | None], Charger] = {}
+    for entry in payload.get("chargers", []):
+        serial = Charger.normalize_serial(entry.get("charger_id"))
+        if not serial or Charger.is_placeholder_serial(serial):
+            continue
+        connector = entry.get("connector_id")
+        if connector in (None, ""):
+            connector_value = None
+        elif isinstance(connector, int):
+            connector_value = connector
+        else:
+            try:
+                connector_value = int(str(connector))
+            except (TypeError, ValueError):
+                connector_value = None
+        charger = Charger.objects.filter(
+            charger_id=serial, connector_id=connector_value
+        ).first()
+        if charger:
+            chargers_map[(serial, connector_value)] = charger
+
+    imported = 0
+    for tx in payload.get("transactions", []):
+        if not isinstance(tx, dict):
+            continue
+        serial = Charger.normalize_serial(tx.get("charger"))
+        if not serial:
+            continue
+        connector = tx.get("connector_id")
+        if connector in (None, ""):
+            connector_value = None
+        elif isinstance(connector, int):
+            connector_value = connector
+        else:
+            try:
+                connector_value = int(str(connector))
+            except (TypeError, ValueError):
+                connector_value = None
+
+        charger = chargers_map.get((serial, connector_value))
+        if charger is None:
+            charger = chargers_map.get((serial, None))
+        if charger is None:
+            continue
+
+        start_time = _parse_remote_datetime(tx.get("start_time"))
+        if start_time is None:
+            continue
+
+        defaults = {
+            "connector_id": connector_value,
+            "account_id": tx.get("account"),
+            "rfid": tx.get("rfid", ""),
+            "vid": tx.get("vid", ""),
+            "vin": tx.get("vin", ""),
+            "meter_start": tx.get("meter_start"),
+            "meter_stop": tx.get("meter_stop"),
+            "voltage_start": _to_decimal(tx.get("voltage_start")),
+            "voltage_stop": _to_decimal(tx.get("voltage_stop")),
+            "current_import_start": _to_decimal(tx.get("current_import_start")),
+            "current_import_stop": _to_decimal(tx.get("current_import_stop")),
+            "current_offered_start": _to_decimal(tx.get("current_offered_start")),
+            "current_offered_stop": _to_decimal(tx.get("current_offered_stop")),
+            "temperature_start": _to_decimal(tx.get("temperature_start")),
+            "temperature_stop": _to_decimal(tx.get("temperature_stop")),
+            "soc_start": _to_decimal(tx.get("soc_start")),
+            "soc_stop": _to_decimal(tx.get("soc_stop")),
+            "stop_time": _parse_remote_datetime(tx.get("stop_time")),
+            "received_start_time": _parse_remote_datetime(
+                tx.get("received_start_time")
+            ),
+            "received_stop_time": _parse_remote_datetime(
+                tx.get("received_stop_time")
+            ),
+        }
+
+        transaction, _ = Transaction.objects.update_or_create(
+            charger=charger,
+            start_time=start_time,
+            defaults=defaults,
+        )
+        transaction.meter_values.all().delete()
+        for mv in tx.get("meter_values", []):
+            if not isinstance(mv, dict):
+                continue
+            timestamp = _parse_remote_datetime(mv.get("timestamp"))
+            if timestamp is None:
+                continue
+            connector_mv = mv.get("connector_id")
+            if connector_mv in (None, ""):
+                connector_mv = None
+            elif isinstance(connector_mv, str):
+                try:
+                    connector_mv = int(connector_mv)
+                except (TypeError, ValueError):
+                    connector_mv = None
+            MeterValue.objects.create(
+                charger=charger,
+                transaction=transaction,
+                connector_id=connector_mv,
+                timestamp=timestamp,
+                context=mv.get("context", ""),
+                energy=_to_decimal(mv.get("energy")),
+                voltage=_to_decimal(mv.get("voltage")),
+                current_import=_to_decimal(mv.get("current_import")),
+                current_offered=_to_decimal(mv.get("current_offered")),
+                temperature=_to_decimal(mv.get("temperature")),
+                soc=_to_decimal(mv.get("soc")),
+            )
+        imported += 1
+
+    return imported
+
+
 @shared_task
 def check_charge_point_configuration(charger_pk: int) -> bool:
     """Request the latest configuration from a connected charge point."""
@@ -135,6 +379,97 @@ def purge_meter_values() -> int:
 purge_meter_readings = purge_meter_values
 
 
+@shared_task
+def sync_remote_chargers() -> int:
+    """Synchronize remote charger metadata and transactions."""
+
+    local = Node.get_local()
+    if not local:
+        logger.debug("Remote sync skipped: local node not registered")
+        return 0
+
+    private_key = local.get_private_key()
+    if private_key is None:
+        logger.warning("Remote sync skipped: missing local node private key")
+        return 0
+
+    chargers = (
+        Charger.objects.filter(export_transactions=True)
+        .exclude(node_origin__isnull=True)
+        .select_related("node_origin")
+    )
+    if local.pk:
+        chargers = chargers.exclude(node_origin=local)
+
+    grouped: dict[Node, list[Charger]] = {}
+    for charger in chargers:
+        origin = charger.node_origin
+        if not origin:
+            continue
+        grouped.setdefault(origin, []).append(charger)
+
+    if not grouped:
+        return 0
+
+    synced = 0
+    for node, node_chargers in grouped.items():
+        payload = {
+            "requester": str(local.uuid),
+            "include_transactions": True,
+            "chargers": [],
+        }
+        for charger in node_chargers:
+            payload["chargers"].append(
+                {
+                    "charger_id": charger.charger_id,
+                    "connector_id": charger.connector_id,
+                    "since": charger.last_online_at.isoformat()
+                    if charger.last_online_at
+                    else None,
+                }
+            )
+        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
+
+        url = f"http://{node.address}:{node.port}/nodes/network/chargers/"
+        try:
+            response = requests.post(url, data=payload_json, headers=headers, timeout=5)
+        except RequestException as exc:
+            logger.warning("Failed to sync chargers from %s: %s", node, exc)
+            continue
+
+        if not response.ok:
+            logger.warning(
+                "Sync request to %s returned %s", node, response.status_code
+            )
+            continue
+
+        try:
+            data = response.json()
+        except ValueError:
+            logger.warning("Invalid JSON payload received from %s", node)
+            continue
+
+        chargers_payload = data.get("chargers", [])
+        for entry in chargers_payload:
+            charger = _apply_remote_charger_payload(node, entry)
+            if charger:
+                synced += 1
+
+        transactions_payload = data.get("transactions")
+        if transactions_payload:
+            imported = _sync_transactions_payload(transactions_payload)
+            if imported:
+                logger.info(
+                    "Imported %s transaction(s) from node %s", imported, node
+                )
+
+    return synced
+
+
 def _resolve_report_window() -> tuple[datetime, datetime, date]:
     """Return the start/end datetimes for today's reporting window."""
 

ocpp/tests.py

@@ -177,6 +177,36 @@ class DispatchActionTests(TestCase):
         self.assertEqual(metadata.get("trigger_target"), "BootNotification")
         self.assertEqual(metadata.get("log_key"), log_key)
 
+    def test_reset_rejected_when_transaction_active(self):
+        charger = Charger.objects.create(charger_id="RESETBLOCK")
+        dummy = DummyWebSocket()
+        connection_key = store.set_connection(charger.charger_id, charger.connector_id, dummy)
+        self.addCleanup(lambda: store.connections.pop(connection_key, None))
+        tx_obj = Transaction.objects.create(
+            charger=charger,
+            connector_id=charger.connector_id,
+            start_time=timezone.now(),
+        )
+        tx_key = store.set_transaction(charger.charger_id, charger.connector_id, tx_obj)
+        self.addCleanup(lambda: store.transactions.pop(tx_key, None))
+
+        request = self.factory.post(
+            "/chargers/RESETBLOCK/action/",
+            data=json.dumps({"action": "reset"}),
+            content_type="application/json",
+        )
+        request.user = SimpleNamespace(
+            is_authenticated=True,
+            is_superuser=True,
+            is_staff=True,
+        )
+
+        response = dispatch_action(request, charger.charger_id)
+        self.assertEqual(response.status_code, 409)
+        payload = json.loads(response.content.decode("utf-8"))
+        self.assertIn("stop the session first", payload.get("detail", "").lower())
+        self.assertFalse(dummy.sent)
+
 class ChargerFixtureTests(TestCase):
     fixtures = [
         p.name
@@ -218,6 +248,62 @@ class ChargerFixtureTests(TestCase):
         self.assertEqual(cp2.name, "Simulator #2")
 
 
+class ChargerRefreshManagerNodeTests(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        local = Node.objects.create(
+            hostname="local-node",
+            address="127.0.0.1",
+            port=8000,
+            mac_address="aa:bb:cc:dd:ee:ff",
+            current_relation=Node.Relation.SELF,
+        )
+        Node.objects.filter(pk=local.pk).update(mac_address="AA:BB:CC:DD:EE:FF")
+        cls.local_node = Node.objects.get(pk=local.pk)
+
+    def test_refresh_manager_node_assigns_local_to_unsaved_charger(self):
+        charger = Charger(charger_id="UNSAVED")
+
+        with patch("nodes.models.Node.get_current_mac", return_value="aa:bb:cc:dd:ee:ff"):
+            result = charger.refresh_manager_node()
+
+        self.assertEqual(result, self.local_node)
+        self.assertEqual(charger.manager_node, self.local_node)
+
+    def test_refresh_manager_node_updates_persisted_charger(self):
+        remote = Node.objects.create(
+            hostname="remote-node",
+            address="10.0.0.1",
+            port=9000,
+            mac_address="11:22:33:44:55:66",
+        )
+        charger = Charger.objects.create(
+            charger_id="PERSISTED",
+            manager_node=remote,
+        )
+
+        charger.refresh_manager_node(node=self.local_node)
+
+        self.assertEqual(charger.manager_node, self.local_node)
+        charger.refresh_from_db()
+        self.assertEqual(charger.manager_node, self.local_node)
+
+    def test_refresh_manager_node_handles_missing_local_node(self):
+        remote = Node.objects.create(
+            hostname="existing-manager",
+            address="10.0.0.2",
+            port=9001,
+            mac_address="22:33:44:55:66:77",
+        )
+        charger = Charger(charger_id="NOLOCAL", manager_node=remote)
+
+        with patch.object(Node, "get_local", return_value=None):
+            result = charger.refresh_manager_node()
+
+        self.assertIsNone(result)
+        self.assertEqual(charger.manager_node, remote)
+
+
 class ChargerUrlFallbackTests(TestCase):
     @override_settings(ALLOWED_HOSTS=["fallback.example", "10.0.0.0/8"])
     def test_reference_created_when_site_missing(self):
@@ -2320,6 +2406,43 @@ class ChargerAdminTests(TestCase):
             store.pop_connection(charger.charger_id, charger.connector_id)
             store.clear_pending_calls(charger.charger_id)
 
+    def test_reset_charger_action_skips_when_transaction_active(self):
+        charger = Charger.objects.create(charger_id="RESETADMIN")
+
+        class DummyConnection:
+            def __init__(self):
+                self.sent: list[str] = []
+
+            async def send(self, message):
+                self.sent.append(message)
+
+        ws = DummyConnection()
+        store.set_connection(charger.charger_id, charger.connector_id, ws)
+        tx_obj = Transaction.objects.create(
+            charger=charger,
+            connector_id=charger.connector_id,
+            start_time=timezone.now(),
+        )
+        store.set_transaction(charger.charger_id, charger.connector_id, tx_obj)
+        try:
+            url = reverse("admin:ocpp_charger_changelist")
+            response = self.client.post(
+                url,
+                {
+                    "action": "reset_chargers",
+                    "index": 0,
+                    "select_across": 0,
+                    "_selected_action": [charger.pk],
+                },
+                follow=True,
+            )
+            self.assertEqual(response.status_code, 200)
+            self.assertFalse(ws.sent)
+            self.assertContains(response, "stop the session first")
+        finally:
+            store.pop_connection(charger.charger_id, charger.connector_id)
+            store.pop_transaction(charger.charger_id, charger.connector_id)
+
     def test_admin_log_view_displays_entries(self):
         charger = Charger.objects.create(charger_id="LOG2")
         log_id = store.identity_key(charger.charger_id, charger.connector_id)

ocpp/views.py

@@ -1609,6 +1609,15 @@ def charger_session_search(request, cid, connector=None):
             transactions = qs.order_by("-start_time")
         except ValueError:
             transactions = []
+    if transactions is not None:
+        transactions = list(transactions)
+        rfid_cache: dict[str, dict[str, str | None]] = {}
+        for tx in transactions:
+            details = _transaction_rfid_details(tx, cache=rfid_cache)
+            label_value = None
+            if details:
+                label_value = str(details.get("label") or "").strip() or None
+            tx.rfid_label = label_value
     overview = _connector_overview(charger, request.user)
     connector_links = [
         {
@@ -1734,7 +1743,7 @@ def charger_log_page(request, cid, connector=None):
 @csrf_exempt
 @api_login_required
 def dispatch_action(request, cid, connector=None):
-    connector_value, _ = _normalize_connector_slug(connector)
+    connector_value, _normalized_slug = _normalize_connector_slug(connector)
     log_key = store.identity_key(cid, connector_value)
     if connector_value is None:
         charger_obj = (
@@ -1750,11 +1759,11 @@ def dispatch_action(request, cid, connector=None):
         )
     if charger_obj is None:
         if connector_value is None:
-            charger_obj, _ = Charger.objects.get_or_create(
+            charger_obj, _created = Charger.objects.get_or_create(
                 charger_id=cid, connector_id=None
             )
         else:
-            charger_obj, _ = Charger.objects.get_or_create(
+            charger_obj, _created = Charger.objects.get_or_create(
                 charger_id=cid, connector_id=connector_value
             )
 
@@ -1925,6 +1934,13 @@ def dispatch_action(request, cid, connector=None):
             },
         )
     elif action == "reset":
+        tx_obj = store.get_transaction(cid, connector_value)
+        if tx_obj is not None:
+            detail = _(
+                "Reset is blocked while a charging session is active. "
+                "Stop the session first."
+            )
+            return JsonResponse({"detail": detail}, status=409)
         message_id = uuid.uuid4().hex
         ocpp_action = "Reset"
         expected_statuses = CALL_EXPECTED_STATUSES.get(ocpp_action)