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

ocpp/models.py

@@ -1,5 +1,8 @@
+import json
 import re
 import socket
+import uuid
+from datetime import timedelta
 from decimal import Decimal, InvalidOperation
 
 from django.conf import settings
@@ -9,12 +12,16 @@ from django.db.models import Q
 from django.core.exceptions import ValidationError
 from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
+from django.utils import timezone
+
+from asgiref.sync import async_to_sync
 
 from core.entity import Entity, EntityManager
 from nodes.models import Node
 
 from core.models import (
     EnergyAccount,
+    EnergyTariff,
     Reference,
     RFID as CoreRFID,
     ElectricVehicle as CoreElectricVehicle,
@@ -22,6 +29,7 @@ from core.models import (
     EVModel as CoreEVModel,
     SecurityGroup,
 )
+from . import store
 from .reference_utils import url_targets_local_loopback
 
 
@@ -35,6 +43,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
@@ -48,6 +72,7 @@ class Charger(Entity):
     """Known charge point."""
 
     _PLACEHOLDER_SERIAL_RE = re.compile(r"^<[^>]+>$")
+    _AUTO_LOCATION_SANITIZE_RE = re.compile(r"[^0-9A-Za-z_-]+")
 
     OPERATIVE_STATUSES = {
         "Available",
@@ -82,6 +107,13 @@ class Charger(Entity):
         default=True,
         help_text="Display this charger on the public status dashboard.",
     )
+    language = models.CharField(
+        _("Language"),
+        max_length=12,
+        choices=settings.LANGUAGES,
+        default="es",
+        help_text=_("Preferred language for the public landing page."),
+    )
     require_rfid = models.BooleanField(
         _("Require RFID Authorization"),
         default=False,
@@ -197,6 +229,23 @@ class Charger(Entity):
         related_name="chargers",
     )
     last_path = models.CharField(max_length=255, blank=True)
+    configuration = models.ForeignKey(
+        "ChargerConfiguration",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        related_name="chargers",
+        help_text=_(
+            "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,
@@ -204,6 +253,22 @@ class Charger(Entity):
         blank=True,
         related_name="managed_chargers",
     )
+    forwarded_to = models.ForeignKey(
+        "nodes.Node",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="forwarded_chargers",
+        help_text=_("Remote node receiving forwarded transactions."),
+    )
+    forwarding_watermark = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text=_("Timestamp of the last forwarded transaction."),
+    )
+    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,
@@ -258,6 +323,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")
@@ -307,6 +390,16 @@ class Charger(Entity):
             )
         return normalized
 
+    @classmethod
+    def sanitize_auto_location_name(cls, value: str) -> str:
+        """Return a location name containing only safe characters."""
+
+        sanitized = cls._AUTO_LOCATION_SANITIZE_RE.sub("_", value)
+        sanitized = re.sub(r"_+", "_", sanitized).strip("_")
+        if not sanitized:
+            return "Charger"
+        return sanitized
+
     AGGREGATE_CONNECTOR_SLUG = "all"
 
     def identity_tuple(self) -> tuple[str, int | None]:
@@ -442,7 +535,8 @@ class Charger(Entity):
             if existing:
                 self.location = existing.location
             else:
-                location, _ = Location.objects.get_or_create(name=self.charger_id)
+                auto_name = type(self).sanitize_auto_location_name(self.charger_id)
+                location, _ = Location.objects.get_or_create(name=auto_name)
                 self.location = location
             if update_list is not None and "location" not in update_list:
                 update_list.append("location")
@@ -452,11 +546,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."""
@@ -527,6 +627,20 @@ class Charger(Entity):
             return qs
         return qs.filter(pk=self.pk)
 
+    def total_kw_for_range(
+        self,
+        start=None,
+        end=None,
+    ) -> float:
+        """Return total energy delivered within ``start``/``end`` window."""
+
+        from . import store
+
+        total = 0.0
+        for charger in self._target_chargers():
+            total += charger._total_kw_range_single(store, start, end)
+        return total
+
     def _total_kw_single(self, store_module) -> float:
         """Return total kW for this specific charger identity."""
 
@@ -547,6 +661,40 @@ class Charger(Entity):
                 total += kw
         return total
 
+    def _total_kw_range_single(self, store_module, start=None, end=None) -> float:
+        """Return total kW for a date range for this charger."""
+
+        tx_active = None
+        if self.connector_id is not None:
+            tx_active = store_module.get_transaction(self.charger_id, self.connector_id)
+
+        qs = self.transactions.all()
+        if start is not None:
+            qs = qs.filter(start_time__gte=start)
+        if end is not None:
+            qs = qs.filter(start_time__lt=end)
+        if tx_active and tx_active.pk is not None:
+            qs = qs.exclude(pk=tx_active.pk)
+
+        total = 0.0
+        for tx in qs:
+            kw = tx.kw
+            if kw:
+                total += kw
+
+        if tx_active:
+            start_time = getattr(tx_active, "start_time", None)
+            include = True
+            if start is not None and start_time and start_time < start:
+                include = False
+            if end is not None and start_time and start_time >= end:
+                include = False
+            if include:
+                kw = tx_active.kw
+                if kw:
+                    total += kw
+        return total
+
     def purge(self):
         from . import store
 
@@ -578,6 +726,59 @@ class Charger(Entity):
         super().delete(*args, **kwargs)
 
 
+class ChargerConfiguration(models.Model):
+    """Persisted configuration package returned by a charge point."""
+
+    charger_identifier = models.CharField(_("Serial Number"), max_length=100)
+    connector_id = models.PositiveIntegerField(
+        _("Connector ID"),
+        null=True,
+        blank=True,
+        help_text=_("Connector that returned this configuration (if specified)."),
+    )
+    configuration_keys = models.JSONField(
+        default=list,
+        blank=True,
+        help_text=_("Entries from the configurationKey list."),
+    )
+    unknown_keys = models.JSONField(
+        default=list,
+        blank=True,
+        help_text=_("Keys returned in the unknownKey list."),
+    )
+    evcs_snapshot_at = models.DateTimeField(
+        _("EVCS snapshot at"),
+        null=True,
+        blank=True,
+        help_text=_(
+            "Timestamp when this configuration was received from the charge point."
+        ),
+    )
+    raw_payload = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text=_("Raw payload returned by the GetConfiguration call."),
+    )
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        ordering = ["-created_at"]
+        verbose_name = _("CP Configuration")
+        verbose_name_plural = _("CP Configurations")
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        connector = (
+            _("connector %(number)s") % {"number": self.connector_id}
+            if self.connector_id is not None
+            else _("all connectors")
+        )
+        return _("%(serial)s configuration (%(connector)s)") % {
+            "serial": self.charger_identifier,
+            "connector": connector,
+        }
+
+
 class Transaction(Entity):
     """Charging session data stored for each charger."""
 
@@ -592,7 +793,18 @@ class Transaction(Entity):
         blank=True,
         verbose_name=_("RFID"),
     )
-    vin = models.CharField(max_length=17, blank=True)
+    vid = models.CharField(
+        max_length=64,
+        blank=True,
+        default="",
+        verbose_name=_("VID"),
+        help_text=_("Vehicle identifier reported by the charger."),
+    )
+    vin = models.CharField(
+        max_length=17,
+        blank=True,
+        help_text=_("Deprecated. Use VID instead."),
+    )
     connector_id = models.PositiveIntegerField(null=True, blank=True)
     meter_start = models.IntegerField(null=True, blank=True)
     meter_stop = models.IntegerField(null=True, blank=True)
@@ -638,6 +850,26 @@ class Transaction(Entity):
         verbose_name = _("Transaction")
         verbose_name_plural = _("CP Transactions")
 
+    @property
+    def vehicle_identifier(self) -> str:
+        """Return the preferred vehicle identifier for this transaction."""
+
+        vid = (self.vid or "").strip()
+        if vid:
+            return vid
+
+        return (self.vin or "").strip()
+
+    @property
+    def vehicle_identifier_source(self) -> str:
+        """Return which field supplies :pyattr:`vehicle_identifier`."""
+
+        if (self.vid or "").strip():
+            return "vid"
+        if (self.vin or "").strip():
+            return "vin"
+        return ""
+
     @property
     def kw(self) -> float:
         """Return consumed energy in kW for this session."""
@@ -886,6 +1118,8 @@ class DataTransferMessage(models.Model):
 
     class Meta:
         ordering = ["-created_at"]
+        verbose_name = _("Data Message")
+        verbose_name_plural = _("Data Messages")
         indexes = [
             models.Index(
                 fields=["ocpp_message_id"],
@@ -900,6 +1134,257 @@ class DataTransferMessage(models.Model):
         return f"{self.get_direction_display()} {self.vendor_id or 'DataTransfer'}"
 
 
+class CPReservation(Entity):
+    """Track connector reservations dispatched to an EVCS."""
+
+    location = models.ForeignKey(
+        Location,
+        on_delete=models.PROTECT,
+        related_name="reservations",
+        verbose_name=_("Location"),
+    )
+    connector = models.ForeignKey(
+        Charger,
+        on_delete=models.PROTECT,
+        related_name="reservations",
+        verbose_name=_("Connector"),
+    )
+    account = models.ForeignKey(
+        EnergyAccount,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="cp_reservations",
+        verbose_name=_("Energy account"),
+    )
+    rfid = models.ForeignKey(
+        CoreRFID,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="cp_reservations",
+        verbose_name=_("RFID"),
+    )
+    id_tag = models.CharField(
+        _("Id Tag"),
+        max_length=255,
+        blank=True,
+        default="",
+        help_text=_("Identifier sent to the EVCS when reserving the connector."),
+    )
+    start_time = models.DateTimeField(verbose_name=_("Start time"))
+    duration_minutes = models.PositiveIntegerField(
+        verbose_name=_("Duration (minutes)"),
+        default=120,
+        help_text=_("Reservation window length in minutes."),
+    )
+    evcs_status = models.CharField(
+        max_length=32,
+        blank=True,
+        default="",
+        verbose_name=_("EVCS status"),
+    )
+    evcs_error = models.CharField(
+        max_length=255,
+        blank=True,
+        default="",
+        verbose_name=_("EVCS error"),
+    )
+    evcs_confirmed = models.BooleanField(
+        default=False,
+        verbose_name=_("Reservation confirmed"),
+    )
+    evcs_confirmed_at = models.DateTimeField(
+        null=True,
+        blank=True,
+        verbose_name=_("Confirmed at"),
+    )
+    ocpp_message_id = models.CharField(
+        max_length=36,
+        blank=True,
+        default="",
+        editable=False,
+        verbose_name=_("OCPP message id"),
+    )
+    created_on = models.DateTimeField(auto_now_add=True, verbose_name=_("Created on"))
+    updated_on = models.DateTimeField(auto_now=True, verbose_name=_("Updated on"))
+
+    class Meta:
+        ordering = ["-start_time"]
+        verbose_name = _("CP Reservation")
+        verbose_name_plural = _("CP Reservations")
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        start = timezone.localtime(self.start_time) if self.start_time else ""
+        return f"{self.location} @ {start}" if self.location else str(start)
+
+    @property
+    def end_time(self):
+        duration = max(int(self.duration_minutes or 0), 0)
+        return self.start_time + timedelta(minutes=duration)
+
+    @property
+    def connector_label(self) -> str:
+        if self.connector_id:
+            return self.connector.connector_label
+        return ""
+
+    @property
+    def id_tag_value(self) -> str:
+        if self.id_tag:
+            return self.id_tag.strip()
+        if self.rfid_id:
+            return (self.rfid.rfid or "").strip()
+        return ""
+
+    def allocate_connector(self, *, force: bool = False) -> Charger:
+        """Select an available connector for this reservation."""
+
+        if not self.location_id:
+            raise ValidationError({"location": _("Select a location for the reservation.")})
+        if not self.start_time:
+            raise ValidationError({"start_time": _("Provide a start time for the reservation.")})
+        if self.duration_minutes <= 0:
+            raise ValidationError(
+                {"duration_minutes": _("Reservation window must be at least one minute.")}
+            )
+
+        candidates = list(
+            Charger.objects.filter(
+                location=self.location, connector_id__isnull=False
+            ).order_by("connector_id")
+        )
+        if not candidates:
+            raise ValidationError(
+                {"location": _("No connectors are configured for the selected location.")}
+            )
+
+        def _priority(charger: Charger) -> tuple[int, int]:
+            connector_id = charger.connector_id or 0
+            if connector_id == 2:
+                return (0, connector_id)
+            if connector_id == 1:
+                return (1, connector_id)
+            return (2, connector_id)
+
+        def _is_available(charger: Charger) -> bool:
+            existing = type(self).objects.filter(connector=charger).exclude(pk=self.pk)
+            start = self.start_time
+            end = self.end_time
+            for entry in existing:
+                if entry.start_time < end and entry.end_time > start:
+                    return False
+            return True
+
+        if self.connector_id:
+            current = next((c for c in candidates if c.pk == self.connector_id), None)
+            if current and _is_available(current) and not force:
+                return current
+
+        for charger in sorted(candidates, key=_priority):
+            if _is_available(charger):
+                self.connector = charger
+                return charger
+
+        raise ValidationError(
+            _("All connectors at this location are reserved for the selected time window.")
+        )
+
+    def clean(self):
+        super().clean()
+        if self.start_time and timezone.is_naive(self.start_time):
+            self.start_time = timezone.make_aware(
+                self.start_time, timezone.get_current_timezone()
+            )
+        if self.duration_minutes <= 0:
+            raise ValidationError(
+                {"duration_minutes": _("Reservation window must be at least one minute.")}
+            )
+        try:
+            self.allocate_connector(force=bool(self.pk))
+        except ValidationError as exc:
+            raise ValidationError(exc) from exc
+
+    def save(self, *args, **kwargs):
+        if self.start_time and timezone.is_naive(self.start_time):
+            self.start_time = timezone.make_aware(
+                self.start_time, timezone.get_current_timezone()
+            )
+        update_fields = kwargs.get("update_fields")
+        relevant_fields = {"location", "start_time", "duration_minutes", "connector"}
+        should_allocate = True
+        if update_fields is not None and not relevant_fields.intersection(update_fields):
+            should_allocate = False
+        if should_allocate:
+            self.allocate_connector(force=bool(self.pk))
+        super().save(*args, **kwargs)
+
+    def send_reservation_request(self) -> str:
+        """Dispatch a ReserveNow request to the associated connector."""
+
+        if not self.pk:
+            raise ValidationError(_("Save the reservation before sending it to the EVCS."))
+        connector = self.connector
+        if connector is None or connector.connector_id is None:
+            raise ValidationError(_("Unable to determine which connector to reserve."))
+        id_tag = self.id_tag_value
+        if not id_tag:
+            raise ValidationError(
+                _("Provide an RFID or idTag before creating the reservation.")
+            )
+        connection = store.get_connection(connector.charger_id, connector.connector_id)
+        if connection is None:
+            raise ValidationError(
+                _("The selected charge point is not currently connected to the system.")
+            )
+
+        message_id = uuid.uuid4().hex
+        expiry = timezone.localtime(self.end_time)
+        payload = {
+            "connectorId": connector.connector_id,
+            "expiryDate": expiry.isoformat(),
+            "idTag": id_tag,
+            "reservationId": self.pk,
+        }
+        frame = json.dumps([2, message_id, "ReserveNow", payload])
+
+        log_key = store.identity_key(connector.charger_id, connector.connector_id)
+        store.add_log(
+            log_key,
+            f"ReserveNow request: reservation={self.pk}, expiry={expiry.isoformat()}",
+            log_type="charger",
+        )
+        async_to_sync(connection.send)(frame)
+
+        metadata = {
+            "action": "ReserveNow",
+            "charger_id": connector.charger_id,
+            "connector_id": connector.connector_id,
+            "log_key": log_key,
+            "reservation_pk": self.pk,
+            "requested_at": timezone.now(),
+        }
+        store.register_pending_call(message_id, metadata)
+        store.schedule_call_timeout(message_id, action="ReserveNow", log_key=log_key)
+
+        self.ocpp_message_id = message_id
+        self.evcs_status = ""
+        self.evcs_error = ""
+        self.evcs_confirmed = False
+        self.evcs_confirmed_at = None
+        super().save(
+            update_fields=[
+                "ocpp_message_id",
+                "evcs_status",
+                "evcs_error",
+                "evcs_confirmed",
+                "evcs_confirmed_at",
+                "updated_on",
+            ]
+        )
+        return message_id
+
+
 class RFID(CoreRFID):
     class Meta:
         proxy = True