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

ocpp/models.py

@@ -232,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,
@@ -239,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,
@@ -293,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")

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."""
 

pages/views.py

@@ -66,6 +66,7 @@ from core.models import (
     SecurityGroup,
     Todo,
 )
+from ocpp.models import Charger
 
 try:  # pragma: no cover - optional dependency guard
     from graphviz import Digraph
@@ -1269,6 +1270,25 @@ class ClientReportForm(forms.Form):
         input_formats=["%Y-%m"],
         help_text=_("Generates the report for the calendar month that you select."),
     )
+    language = forms.ChoiceField(
+        label=_("Report language"),
+        choices=settings.LANGUAGES,
+        help_text=_("Choose the language used for the generated report."),
+    )
+    title = forms.CharField(
+        label=_("Report title"),
+        required=False,
+        max_length=200,
+        help_text=_("Optional heading that replaces the default report title."),
+    )
+    chargers = forms.ModelMultipleChoiceField(
+        label=_("Charge points"),
+        queryset=Charger.objects.filter(connector_id__isnull=True)
+        .order_by("display_name", "charger_id"),
+        required=False,
+        widget=forms.CheckboxSelectMultiple,
+        help_text=_("Choose which charge points are included in the report."),
+    )
     owner = forms.ModelChoiceField(
         queryset=get_user_model().objects.all(),
         required=False,
@@ -1299,6 +1319,13 @@ class ClientReportForm(forms.Form):
         super().__init__(*args, **kwargs)
         if request and getattr(request, "user", None) and request.user.is_authenticated:
             self.fields["owner"].initial = request.user.pk
+        self.fields["chargers"].widget.attrs["class"] = "charger-options"
+        language_initial = ClientReport.default_language()
+        if request:
+            language_initial = ClientReport.normalize_language(
+                getattr(request, "LANGUAGE_CODE", language_initial)
+            )
+        self.fields["language"].initial = language_initial
 
     def clean(self):
         cleaned = super().clean()
@@ -1348,6 +1375,10 @@ class ClientReportForm(forms.Form):
             emails.append(candidate)
         return emails
 
+    def clean_title(self):
+        title = self.cleaned_data.get("title")
+        return ClientReport.normalize_title(title)
+
 
 @live_update()
 def client_report(request):
@@ -1358,7 +1389,7 @@ def client_report(request):
         if not request.user.is_authenticated:
             form.is_valid()  # Run validation to surface field errors alongside auth error.
             form.add_error(
-                None, _("You must log in to generate client reports."),
+                None, _("You must log in to generate consumer reports."),
             )
         elif form.is_valid():
             throttle_seconds = getattr(settings, "CLIENT_REPORT_THROTTLE_SECONDS", 60)
@@ -1387,7 +1418,7 @@ def client_report(request):
                 form.add_error(
                     None,
                     _(
-                        "Client reports can only be generated periodically. Please wait before trying again."
+                        "Consumer reports can only be generated periodically. Please wait before trying again."
                     ),
                 )
             else:
@@ -1399,14 +1430,36 @@ def client_report(request):
                 recipients = (
                     form.cleaned_data.get("destinations") if enable_emails else []
                 )
+                chargers = list(form.cleaned_data.get("chargers") or [])
+                language = form.cleaned_data.get("language")
+                title = form.cleaned_data.get("title")
                 report = ClientReport.generate(
                     form.cleaned_data["start"],
                     form.cleaned_data["end"],
                     owner=owner,
                     recipients=recipients,
                     disable_emails=disable_emails,
+                    chargers=chargers,
+                    language=language,
+                    title=title,
                 )
                 report.store_local_copy()
+                if chargers:
+                    report.chargers.set(chargers)
+                if enable_emails and recipients:
+                    delivered = report.send_delivery(
+                        to=recipients,
+                        cc=[],
+                        outbox=ClientReport.resolve_outbox_for_owner(owner),
+                        reply_to=ClientReport.resolve_reply_to_for_owner(owner),
+                    )
+                    if delivered:
+                        report.recipients = delivered
+                        report.save(update_fields=["recipients"])
+                        messages.success(
+                            request,
+                            _("Consumer report emailed to the selected recipients."),
+                        )
                 recurrence = form.cleaned_data.get("recurrence")
                 if recurrence and recurrence != ClientReportSchedule.PERIODICITY_NONE:
                     schedule = ClientReportSchedule.objects.create(
@@ -1415,13 +1468,17 @@ def client_report(request):
                         periodicity=recurrence,
                         email_recipients=recipients,
                         disable_emails=disable_emails,
+                        language=language,
+                        title=title,
                     )
+                    if chargers:
+                        schedule.chargers.set(chargers)
                     report.schedule = schedule
                     report.save(update_fields=["schedule"])
                     messages.success(
                         request,
                         _(
-                            "Client report schedule created; future reports will be generated automatically."
+                            "Consumer report schedule created; future reports will be generated automatically."
                         ),
                     )
                 if disable_emails:
@@ -1459,7 +1516,6 @@ def client_report(request):
         "schedule": schedule,
         "login_url": login_url,
         "download_url": download_url,
-        "previous_reports": _client_report_history(request),
     }
     return render(request, "pages/client_report.html", context)
 
@@ -1478,32 +1534,6 @@ def client_report_download(request, report_id: int):
     response = FileResponse(pdf_path.open("rb"), content_type="application/pdf")
     response["Content-Disposition"] = f'attachment; filename="{filename}"'
     return response
-
-
-def _client_report_history(request, limit: int = 20):
-    if not request.user.is_authenticated:
-        return []
-    qs = ClientReport.objects.order_by("-created_on")
-    if not request.user.is_staff:
-        qs = qs.filter(owner=request.user)
-    history = []
-    for report in qs[:limit]:
-        totals = report.rows_for_display.get("totals", {})
-        history.append(
-            {
-                "instance": report,
-                "download_url": reverse("pages:client-report-download", args=[report.pk]),
-                "email_enabled": not report.disable_emails,
-                "recipients": report.recipients or [],
-                "totals": {
-                    "total_kw": totals.get("total_kw", 0.0),
-                    "total_kw_period": totals.get("total_kw_period", 0.0),
-                },
-            }
-        )
-    return history
-
-
 def _get_request_language_code(request) -> str:
     language_code = ""
     if hasattr(request, "session"):