arthexis 0.1.3__py3-none-any.whl

ocpp/models.py

@@ -0,0 +1,300 @@
+from django.db import models
+from core.entity import Entity
+from django.urls import reverse
+from django.contrib.sites.models import Site
+from django.conf import settings
+from django.utils.translation import gettext_lazy as _
+
+from core.models import (
+    EnergyAccount,
+    Reference,
+    RFID as CoreRFID,
+    ElectricVehicle as CoreElectricVehicle,
+)
+
+
+class Location(Entity):
+    """Physical location shared by chargers."""
+
+    name = models.CharField(max_length=200)
+    latitude = models.DecimalField(max_digits=9, decimal_places=6, null=True, blank=True)
+    longitude = models.DecimalField(max_digits=9, decimal_places=6, null=True, blank=True)
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return self.name
+
+    class Meta:
+        verbose_name = _("Charge Location")
+        verbose_name_plural = _("Charge Locations")
+
+
+class Charger(Entity):
+    """Known charge point."""
+
+    charger_id = models.CharField(
+        _("Serial Number"),
+        max_length=100,
+        unique=True,
+        help_text="Unique identifier reported by the charger.",
+    )
+    connector_id = models.CharField(
+        _("Connector ID"),
+        max_length=10,
+        blank=True,
+        null=True,
+        help_text="Optional connector identifier for multi-connector chargers.",
+    )
+    require_rfid = models.BooleanField(
+        _("Require RFID Authorization"),
+        default=False,
+        help_text="Require a valid RFID before starting a charging session.",
+    )
+    last_heartbeat = models.DateTimeField(null=True, blank=True)
+    last_meter_values = models.JSONField(default=dict, blank=True)
+    temperature = models.DecimalField(max_digits=5, decimal_places=1, null=True, blank=True)
+    temperature_unit = models.CharField(max_length=16, blank=True)
+    reference = models.OneToOneField(Reference, null=True, blank=True, on_delete=models.SET_NULL)
+    location = models.ForeignKey(
+        Location, null=True, blank=True, on_delete=models.SET_NULL, related_name="chargers"
+    )
+    last_path = models.CharField(max_length=255, blank=True)
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return self.charger_id
+
+    class Meta:
+        verbose_name = _("Charge Point")
+        verbose_name_plural = _("Charge Points")
+
+    def get_absolute_url(self):
+        return reverse("charger-page", args=[self.charger_id])
+
+    def _full_url(self) -> str:
+        """Return absolute URL for the charger landing page."""
+        domain = Site.objects.get_current().domain
+        scheme = getattr(settings, "DEFAULT_HTTP_PROTOCOL", "http")
+        return f"{scheme}://{domain}{self.get_absolute_url()}"
+
+    def save(self, *args, **kwargs):
+        super().save(*args, **kwargs)
+        ref_value = self._full_url()
+        if not self.reference or self.reference.value != ref_value:
+            ref, _ = Reference.objects.get_or_create(
+                value=ref_value, defaults={"alt_text": self.charger_id}
+            )
+            self.reference = ref
+            super().save(update_fields=["reference"])
+
+    @property
+    def name(self) -> str:
+        if self.location:
+            return (
+                f"{self.location.name} #{self.connector_id}"
+                if self.connector_id
+                else self.location.name
+            )
+        return ""
+
+    @property
+    def latitude(self):
+        return self.location.latitude if self.location else None
+
+    @property
+    def longitude(self):
+        return self.location.longitude if self.location else None
+
+    @property
+    def total_kw(self) -> float:
+        """Return total energy delivered by this charger in kW."""
+        from . import store
+
+        total = 0.0
+        tx_active = store.transactions.get(self.charger_id)
+        qs = self.transactions.all()
+        if tx_active and tx_active.pk is not None:
+            qs = qs.exclude(pk=tx_active.pk)
+        for tx in qs:
+            kw = tx.kw
+            if kw:
+                total += kw
+        if tx_active:
+            kw = tx_active.kw
+            if kw:
+                total += kw
+        return total
+
+    def purge(self):
+        from . import store
+
+        self.transactions.all().delete()
+        self.meter_readings.all().delete()
+        store.clear_log(self.charger_id, log_type="charger")
+        store.transactions.pop(self.charger_id, None)
+        store.history.pop(self.charger_id, None)
+
+    def delete(self, *args, **kwargs):
+        from django.db.models.deletion import ProtectedError
+        from . import store
+
+        if (
+            self.transactions.exists()
+            or self.meter_readings.exists()
+            or store.get_logs(self.charger_id, log_type="charger")
+            or store.transactions.get(self.charger_id)
+            or store.history.get(self.charger_id)
+        ):
+            raise ProtectedError("Purge data before deleting charger.", [])
+        super().delete(*args, **kwargs)
+
+
+class Transaction(Entity):
+    """Charging session data stored for each charger."""
+
+    charger = models.ForeignKey(
+        Charger, on_delete=models.CASCADE, related_name="transactions", null=True
+    )
+    account = models.ForeignKey(
+        EnergyAccount, on_delete=models.PROTECT, related_name="transactions", null=True
+    )
+    rfid = models.CharField(
+        max_length=20,
+        blank=True,
+        verbose_name=_("RFID"),
+    )
+    vin = models.CharField(max_length=17, blank=True)
+    meter_start = models.IntegerField(null=True, blank=True)
+    meter_stop = models.IntegerField(null=True, blank=True)
+    start_time = models.DateTimeField()
+    stop_time = models.DateTimeField(null=True, blank=True)
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return f"{self.charger}:{self.pk}"
+
+    class Meta:
+        verbose_name = _("Transaction")
+        verbose_name_plural = _("Transactions")
+
+    @property
+    def kw(self) -> float:
+        """Return consumed energy in kW for this session."""
+        total = 0.0
+        qs = self.meter_readings.filter(
+            measurand__in=["", "Energy.Active.Import.Register"]
+        ).order_by("timestamp")
+        first = True
+        for reading in qs:
+            try:
+                val = float(reading.value)
+            except (TypeError, ValueError):  # pragma: no cover - unexpected
+                continue
+            if reading.unit != "kW":
+                val = val / 1000.0
+            if first and self.meter_start is not None:
+                total += val - (self.meter_start / 1000.0)
+                first = False
+            else:
+                total += val
+                first = False
+        if total == 0 and self.meter_start is not None and self.meter_stop is not None:
+            total = (self.meter_stop - self.meter_start) / 1000.0
+        if total < 0:
+            return 0.0
+        return total
+
+
+class MeterReading(Entity):
+    """Parsed meter values reported by chargers."""
+
+    charger = models.ForeignKey(
+        Charger, on_delete=models.CASCADE, related_name="meter_readings"
+    )
+    connector_id = models.IntegerField(null=True, blank=True)
+    transaction = models.ForeignKey(
+        Transaction,
+        on_delete=models.CASCADE,
+        related_name="meter_readings",
+        null=True,
+        blank=True,
+    )
+    timestamp = models.DateTimeField()
+    measurand = models.CharField(max_length=100, blank=True)
+    value = models.DecimalField(max_digits=12, decimal_places=3)
+    unit = models.CharField(max_length=16, blank=True)
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return f"{self.charger} {self.measurand} {self.value}{self.unit}".strip()
+
+    class Meta:
+        verbose_name = _("Meter Reading")
+        verbose_name_plural = _("Meter Readings")
+
+
+class Simulator(Entity):
+    """Preconfigured simulator that can be started from the admin."""
+
+    name = models.CharField(max_length=100, unique=True)
+    cp_path = models.CharField(_("CP Path"), max_length=100)
+    host = models.CharField(max_length=100, default="127.0.0.1")
+    ws_port = models.IntegerField(_("WS Port"), default=8000)
+    rfid = models.CharField(
+        max_length=255,
+        default="FFFFFFFF",
+        verbose_name=_("RFID"),
+    )
+    vin = models.CharField(max_length=17, blank=True)
+    duration = models.IntegerField(default=600)
+    interval = models.FloatField(default=5.0)
+    pre_charge_delay = models.FloatField(_("Delay"), default=10.0)
+    kw_max = models.FloatField(default=60.0)
+    repeat = models.BooleanField(default=False)
+    username = models.CharField(max_length=100, blank=True)
+    password = models.CharField(max_length=100, blank=True)
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return self.name
+
+    class Meta:
+        verbose_name = _("CP Simulator")
+        verbose_name_plural = _("CP Simulators")
+
+    def as_config(self):
+        from .simulator import SimulatorConfig
+
+        return SimulatorConfig(
+            host=self.host,
+            ws_port=self.ws_port,
+            rfid=self.rfid,
+            vin=self.vin,
+            cp_path=self.cp_path,
+            duration=self.duration,
+            interval=self.interval,
+            pre_charge_delay=self.pre_charge_delay,
+            kw_max=self.kw_max,
+            repeat=self.repeat,
+            username=self.username or None,
+            password=self.password or None,
+        )
+
+    @property
+    def ws_url(self) -> str:  # pragma: no cover - simple helper
+        path = self.cp_path
+        if not path.endswith("/"):
+            path += "/"
+        return f"ws://{self.host}:{self.ws_port}/{path}"
+
+
+class RFID(CoreRFID):
+    class Meta:
+        proxy = True
+        app_label = "ocpp"
+        verbose_name = CoreRFID._meta.verbose_name
+        verbose_name_plural = CoreRFID._meta.verbose_name_plural
+
+
+class ElectricVehicle(CoreElectricVehicle):
+    class Meta:
+        proxy = True
+        app_label = "ocpp"
+        verbose_name = _("Electric Vehicle")
+        verbose_name_plural = _("Electric Vehicles")
+

ocpp/routing.py

@@ -0,0 +1,9 @@
+from django.urls import re_path
+
+from . import consumers
+
+websocket_urlpatterns = [
+    re_path(r"^ws/sink/$", consumers.SinkConsumer.as_asgi()),
+    # Accept connections at any path; the last segment is the charger ID
+    re_path(r"^(?:.*/)?(?P<cid>[^/]+)/?$", consumers.CSMSConsumer.as_asgi()),
+]

ocpp/simulator.py

@@ -0,0 +1,357 @@
+import asyncio
+import base64
+import json
+import random
+import time
+from dataclasses import dataclass
+from typing import Optional
+import threading
+
+import websockets
+from config.offline import requires_network
+
+from . import store
+
+
+@dataclass
+class SimulatorConfig:
+    """Configuration for a simulated charge point."""
+
+    host: str = "127.0.0.1"
+    ws_port: int = 8000
+    rfid: str = "FFFFFFFF"
+    vin: str = ""
+    # WebSocket path for the charge point. Defaults to just the charger ID at the root.
+    cp_path: str = "CPX/"
+    duration: int = 600
+    kw_min: float = 30.0
+    kw_max: float = 60.0
+    interval: float = 5.0
+    pre_charge_delay: float = 10.0
+    repeat: bool = False
+    username: Optional[str] = None
+    password: Optional[str] = None
+
+
+class ChargePointSimulator:
+    """Lightweight simulator for a single OCPP 1.6 charge point."""
+
+    def __init__(self, config: SimulatorConfig) -> None:
+        self.config = config
+        self._thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+        self.status = "stopped"
+        self._connected = threading.Event()
+        self._connect_error = ""
+
+    @requires_network
+    async def _run_session(self) -> None:
+        cfg = self.config
+        uri = f"ws://{cfg.host}:{cfg.ws_port}/{cfg.cp_path}"
+        headers = {}
+        if cfg.username and cfg.password:
+            userpass = f"{cfg.username}:{cfg.password}"
+            b64 = base64.b64encode(userpass.encode()).decode()
+            headers["Authorization"] = f"Basic {b64}"
+
+        ws = None
+        try:
+            try:
+                ws = await websockets.connect(
+                    uri, subprotocols=["ocpp1.6"], extra_headers=headers
+                )
+            except Exception as exc:
+                store.add_log(
+                    cfg.cp_path,
+                    f"Connection with subprotocol failed: {exc}",
+                    log_type="simulator",
+                )
+                ws = await websockets.connect(uri, extra_headers=headers)
+
+            store.add_log(
+                cfg.cp_path,
+                f"Connected (subprotocol={ws.subprotocol or 'none'})",
+                log_type="simulator",
+            )
+
+            async def send(msg: str) -> None:
+                try:
+                    await ws.send(msg)
+                except Exception:
+                    self.status = "error"
+                    raise
+                store.add_log(cfg.cp_path, f"> {msg}", log_type="simulator")
+
+            async def recv() -> str:
+                try:
+                    raw = await asyncio.wait_for(ws.recv(), timeout=60)
+                except asyncio.TimeoutError:
+                    self.status = "stopped"
+                    self._stop_event.set()
+                    store.add_log(
+                        cfg.cp_path,
+                        "Timeout waiting for response from charger",
+                        log_type="simulator",
+                    )
+                    raise
+                except Exception:
+                    self.status = "error"
+                    raise
+                store.add_log(cfg.cp_path, f"< {raw}", log_type="simulator")
+                return raw
+
+            # handshake
+            boot = json.dumps(
+                [
+                    2,
+                    "boot",
+                    "BootNotification",
+                    {
+                        "chargePointModel": "Simulator",
+                        "chargePointVendor": "SimVendor",
+                    },
+                ]
+            )
+            await send(boot)
+            try:
+                resp = json.loads(await recv())
+            except Exception:
+                self.status = "error"
+                raise
+            status = resp[2].get("status")
+            if status != "Accepted":
+                if not self._connected.is_set():
+                    self._connect_error = f"Boot status {status}"
+                    self._connected.set()
+                return
+
+            await send(json.dumps([2, "auth", "Authorize", {"idTag": cfg.rfid}]))
+            await recv()
+            if not self._connected.is_set():
+                self.status = "running"
+                self._connect_error = "accepted"
+                self._connected.set()
+            if cfg.pre_charge_delay > 0:
+                idle_start = time.monotonic()
+                while time.monotonic() - idle_start < cfg.pre_charge_delay:
+                    await send(
+                        json.dumps(
+                            [
+                                2,
+                                "status",
+                                "StatusNotification",
+                                {
+                                    "connectorId": 1,
+                                    "errorCode": "NoError",
+                                    "status": "Available",
+                                },
+                            ]
+                        )
+                    )
+                    await recv()
+                    await send(json.dumps([2, "hb", "Heartbeat", {}]))
+                    await recv()
+                    await send(
+                        json.dumps(
+                            [
+                                2,
+                                "meter",
+                                "MeterValues",
+                                {
+                                    "connectorId": 1,
+                                    "meterValue": [
+                                        {
+                                            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+                                            "sampledValue": [
+                                                {
+                                                    "value": "0",
+                                                    "measurand": "Energy.Active.Import.Register",
+                                                    "unit": "kW",
+                                                }
+                                            ],
+                                        }
+                                    ],
+                                },
+                            ]
+                        )
+                    )
+                    await recv()
+                    await asyncio.sleep(cfg.interval)
+
+            meter_start = random.randint(1000, 2000)
+            await send(
+                json.dumps(
+                    [
+                        2,
+                        "start",
+                        "StartTransaction",
+                        {
+                            "connectorId": 1,
+                            "idTag": cfg.rfid,
+                            "meterStart": meter_start,
+                            "vin": cfg.vin,
+                        },
+                    ]
+                )
+            )
+            try:
+                resp = json.loads(await recv())
+            except Exception:
+                self.status = "error"
+                raise
+            tx_id = resp[2].get("transactionId")
+
+            meter = meter_start
+            steps = max(1, int(cfg.duration / cfg.interval))
+            target_kwh = cfg.kw_max * random.uniform(0.9, 1.1)
+            step_avg = (target_kwh * 1000) / steps
+
+            start_time = time.monotonic()
+            while time.monotonic() - start_time < cfg.duration:
+                if self._stop_event.is_set():
+                    break
+                inc = random.gauss(step_avg, step_avg * 0.05)
+                meter += max(1, int(inc))
+                meter_kw = meter / 1000.0
+                await send(
+                    json.dumps(
+                        [
+                            2,
+                            "meter",
+                            "MeterValues",
+                            {
+                                "connectorId": 1,
+                                "transactionId": tx_id,
+                                "meterValue": [
+                                    {
+                                        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
+                                        "sampledValue": [
+                                            {
+                                                "value": f"{meter_kw:.3f}",
+                                                "measurand": "Energy.Active.Import.Register",
+                                                "unit": "kW",
+                                            }
+                                        ],
+                                    }
+                                ],
+                            },
+                        ]
+                    )
+                )
+                await recv()
+                await asyncio.sleep(cfg.interval)
+
+            await send(
+                json.dumps(
+                    [
+                        2,
+                        "stop",
+                        "StopTransaction",
+                        {
+                            "transactionId": tx_id,
+                            "idTag": cfg.rfid,
+                            "meterStop": meter,
+                        },
+                    ]
+                )
+            )
+            await recv()
+        except asyncio.TimeoutError:
+            if not self._connected.is_set():
+                self._connect_error = "Timeout waiting for response"
+                self._connected.set()
+            self.status = "stopped"
+            self._stop_event.set()
+            return
+        except websockets.exceptions.ConnectionClosed as exc:
+            if not self._connected.is_set():
+                self._connect_error = str(exc)
+                self._connected.set()
+            # The charger closed the connection; mark the simulator as
+            # terminated rather than erroring so the status reflects that it
+            # was stopped remotely.
+            self.status = "stopped"
+            self._stop_event.set()
+            store.add_log(
+                cfg.cp_path,
+                f"Disconnected by charger (code={getattr(exc, 'code', '')})",
+                log_type="simulator",
+            )
+            return
+        except Exception as exc:
+            if not self._connected.is_set():
+                self._connect_error = str(exc)
+                self._connected.set()
+            self.status = "error"
+            self._stop_event.set()
+            raise
+        finally:
+            if ws is not None:
+                await ws.close()
+                store.add_log(
+                    cfg.cp_path,
+                    f"Closed (code={ws.close_code}, reason={getattr(ws, 'close_reason', '')})",
+                    log_type="simulator",
+                )
+
+    async def _run(self) -> None:
+        try:
+            while not self._stop_event.is_set():
+                try:
+                    await self._run_session()
+                except asyncio.CancelledError:
+                    break
+                except Exception:
+                    # wait briefly then retry
+                    await asyncio.sleep(1)
+                    continue
+                if not self.config.repeat:
+                    break
+        finally:
+            for key, sim in list(store.simulators.items()):
+                if sim is self:
+                    store.simulators.pop(key, None)
+                    break
+
+    def start(self) -> tuple[bool, str, str]:
+        if self._thread and self._thread.is_alive():
+            return (
+                False,
+                "already running",
+                str(store._file_path(self.config.cp_path, log_type="simulator")),
+            )
+
+        self._stop_event.clear()
+        self.status = "starting"
+        self._connected.clear()
+        self._connect_error = ""
+
+        def _runner() -> None:
+            asyncio.run(self._run())
+
+        self._thread = threading.Thread(target=_runner, daemon=True)
+        self._thread.start()
+
+        log_file = str(store._file_path(self.config.cp_path, log_type="simulator"))
+        if not self._connected.wait(15):
+            self.status = "error"
+            return False, "Connection timeout", log_file
+        if self._connect_error == "accepted":
+            self.status = "running"
+            return True, "Connection accepted", log_file
+        if "Timeout" in self._connect_error:
+            self.status = "stopped"
+        else:
+            self.status = "error"
+        return False, f"Connection failed: {self._connect_error}", log_file
+
+    async def stop(self) -> None:
+        if self._thread and self._thread.is_alive():
+            self._stop_event.set()
+            await asyncio.to_thread(self._thread.join)
+            self._thread = None
+            self._stop_event = threading.Event()
+        self.status = "stopped"
+
+
+__all__ = ["SimulatorConfig", "ChargePointSimulator"]