arthexis 0.1.3__py3-none-any.whl

ocpp/admin.py

@@ -0,0 +1,392 @@
+from django.contrib import admin
+from django import forms
+
+import asyncio
+from datetime import timedelta
+import json
+
+from django.utils import timezone
+from django.urls import path
+from django.http import HttpResponse, HttpResponseRedirect
+from django.template.response import TemplateResponse
+
+from .models import (
+    Charger,
+    Simulator,
+    MeterReading,
+    Transaction,
+    Location,
+    ElectricVehicle,
+)
+from .simulator import ChargePointSimulator
+from . import store
+from .transactions_io import (
+    export_transactions,
+    import_transactions as import_transactions_data,
+)
+from core.admin import RFIDAdmin
+from .models import RFID
+
+
+class LocationAdminForm(forms.ModelForm):
+    class Meta:
+        model = Location
+        fields = "__all__"
+
+        widgets = {
+            "latitude": forms.NumberInput(attrs={"step": "any"}),
+            "longitude": forms.NumberInput(attrs={"step": "any"}),
+        }
+
+    class Media:
+        css = {
+            "all": ("https://unpkg.com/leaflet@1.9.4/dist/leaflet.css",)
+        }
+        js = (
+            "https://unpkg.com/leaflet@1.9.4/dist/leaflet.js",
+            "ocpp/charger_map.js",
+        )
+
+
+class TransactionExportForm(forms.Form):
+    start = forms.DateTimeField(required=False)
+    end = forms.DateTimeField(required=False)
+    chargers = forms.ModelMultipleChoiceField(
+        queryset=Charger.objects.all(), required=False
+    )
+
+
+class TransactionImportForm(forms.Form):
+    file = forms.FileField()
+
+
+@admin.register(Location)
+class LocationAdmin(admin.ModelAdmin):
+    form = LocationAdminForm
+    list_display = ("name", "latitude", "longitude")
+
+
+@admin.register(Charger)
+class ChargerAdmin(admin.ModelAdmin):
+    fieldsets = (
+        (
+            "General",
+            {
+                "fields": (
+                    "charger_id",
+                    "connector_id",
+                    "require_rfid",
+                    "last_heartbeat",
+                    "last_meter_values",
+                    "last_path",
+                    "location",
+                )
+            },
+        ),
+        (
+            "References",
+            {
+                "fields": ("reference",),
+            },
+        ),
+    )
+    readonly_fields = ("last_heartbeat", "last_meter_values")
+    list_display = (
+        "charger_id",
+        "connector_id",
+        "location_name",
+        "require_rfid",
+        "last_heartbeat",
+        "session_kw",
+        "total_kw_display",
+        "page_link",
+        "log_link",
+        "status_link",
+    )
+    search_fields = ("charger_id", "connector_id", "location__name")
+    actions = ["purge_data", "delete_selected"]
+
+    def get_view_on_site_url(self, obj=None):
+        return obj.get_absolute_url() if obj else None
+
+    def page_link(self, obj):
+        from django.utils.html import format_html
+
+        return format_html(
+            '<a href="{}" target="_blank">open</a>', obj.get_absolute_url()
+        )
+
+    page_link.short_description = "Landing Page"
+
+    def qr_link(self, obj):
+        from django.utils.html import format_html
+
+        if obj.reference and obj.reference.image:
+            return format_html(
+                '<a href="{}" target="_blank">qr</a>', obj.reference.image.url
+            )
+        return ""
+
+    qr_link.short_description = "QR Code"
+
+    def log_link(self, obj):
+        from django.utils.html import format_html
+        from django.urls import reverse
+
+        url = reverse("charger-log", args=[obj.charger_id]) + "?type=charger"
+        return format_html('<a href="{}" target="_blank">view</a>', url)
+
+    log_link.short_description = "Log"
+    
+    def status_link(self, obj):
+        from django.utils.html import format_html
+        from django.urls import reverse
+
+        url = reverse("charger-status", args=[obj.charger_id])
+        return format_html('<a href="{}" target="_blank">status</a>', url)
+
+    status_link.short_description = "Status Page"
+
+    def location_name(self, obj):
+        return obj.location.name if obj.location else ""
+
+    location_name.short_description = "Location"
+
+    def purge_data(self, request, queryset):
+        for charger in queryset:
+            charger.purge()
+        self.message_user(request, "Data purged for selected chargers")
+
+    purge_data.short_description = "Purge data"
+
+    def delete_queryset(self, request, queryset):
+        for obj in queryset:
+            obj.delete()
+
+    def total_kw_display(self, obj):
+        return round(obj.total_kw, 2)
+
+    total_kw_display.short_description = "Total kW"
+
+    def session_kw(self, obj):
+        tx = store.transactions.get(obj.charger_id)
+        if tx:
+            return round(tx.kw, 2)
+        return 0.0
+
+    session_kw.short_description = "Session kW"
+
+
+@admin.register(Simulator)
+class SimulatorAdmin(admin.ModelAdmin):
+    list_display = (
+        "name",
+        "cp_path",
+        "host",
+        "ws_port",
+        "ws_url",
+        "interval",
+        "kw_max",
+        "running",
+        "log_link",
+    )
+    fields = (
+        "name",
+        "cp_path",
+        ("host", "ws_port"),
+        "rfid",
+        ("duration", "interval", "pre_charge_delay"),
+        "kw_max",
+        "repeat",
+        ("username", "password"),
+    )
+    actions = ("start_simulator", "stop_simulator")
+
+    def running(self, obj):
+        return obj.pk in store.simulators
+
+    running.boolean = True
+
+    def start_simulator(self, request, queryset):
+        for obj in queryset:
+            if obj.pk in store.simulators:
+                self.message_user(request, f"{obj.name}: already running")
+                continue
+            store.register_log_name(obj.cp_path, obj.name, log_type="simulator")
+            sim = ChargePointSimulator(obj.as_config())
+            started, status, log_file = sim.start()
+            if started:
+                store.simulators[obj.pk] = sim
+            self.message_user(
+                request, f"{obj.name}: {status}. Log: {log_file}"
+            )
+
+    start_simulator.short_description = "Start selected simulators"
+
+    def stop_simulator(self, request, queryset):
+        async def _stop(objs):
+            for obj in objs:
+                sim = store.simulators.pop(obj.pk, None)
+                if sim:
+                    await sim.stop()
+
+        asyncio.get_event_loop().create_task(_stop(list(queryset)))
+        self.message_user(request, "Stopping simulators")
+
+    stop_simulator.short_description = "Stop selected simulators"
+
+    def log_link(self, obj):
+        from django.utils.html import format_html
+        from django.urls import reverse
+
+        url = reverse("charger-log", args=[obj.cp_path]) + "?type=simulator"
+        return format_html('<a href="{}" target="_blank">view</a>', url)
+
+    log_link.short_description = "Log"
+
+
+class MeterReadingInline(admin.TabularInline):
+    model = MeterReading
+    extra = 0
+    fields = ("timestamp", "value", "unit", "measurand", "connector_id")
+    readonly_fields = fields
+    can_delete = False
+
+
+@admin.register(Transaction)
+class TransactionAdmin(admin.ModelAdmin):
+    change_list_template = "admin/ocpp/transaction/change_list.html"
+    list_display = (
+        "charger",
+        "account",
+        "rfid",
+        "meter_start",
+        "meter_stop",
+        "start_time",
+        "stop_time",
+        "kw",
+    )
+    readonly_fields = ("kw",)
+    list_filter = ("charger", "account")
+    date_hierarchy = "start_time"
+    inlines = [MeterReadingInline]
+
+    def get_urls(self):
+        urls = super().get_urls()
+        custom = [
+            path(
+                "export/",
+                self.admin_site.admin_view(self.export_view),
+                name="ocpp_transaction_export",
+            ),
+            path(
+                "import/",
+                self.admin_site.admin_view(self.import_view),
+                name="ocpp_transaction_import",
+            ),
+        ]
+        return custom + urls
+
+    def export_view(self, request):
+        if request.method == "POST":
+            form = TransactionExportForm(request.POST)
+            if form.is_valid():
+                chargers = form.cleaned_data["chargers"]
+                data = export_transactions(
+                    start=form.cleaned_data["start"],
+                    end=form.cleaned_data["end"],
+                    chargers=[c.charger_id for c in chargers] if chargers else None,
+                )
+                response = HttpResponse(
+                    json.dumps(data, indent=2, ensure_ascii=False),
+                    content_type="application/json",
+                )
+                response[
+                    "Content-Disposition"
+                ] = "attachment; filename=transactions.json"
+                return response
+        else:
+            form = TransactionExportForm()
+        context = self.admin_site.each_context(request)
+        context["form"] = form
+        return TemplateResponse(
+            request, "admin/ocpp/transaction/export.html", context
+        )
+
+    def import_view(self, request):
+        if request.method == "POST":
+            form = TransactionImportForm(request.POST, request.FILES)
+            if form.is_valid():
+                data = json.load(form.cleaned_data["file"])
+                imported = import_transactions_data(data)
+                self.message_user(request, f"Imported {imported} transactions")
+                return HttpResponseRedirect("../")
+        else:
+            form = TransactionImportForm()
+        context = self.admin_site.each_context(request)
+        context["form"] = form
+        return TemplateResponse(
+            request, "admin/ocpp/transaction/import.html", context
+        )
+
+
+class MeterReadingDateFilter(admin.SimpleListFilter):
+    title = "Timestamp"
+    parameter_name = "timestamp_range"
+
+    def lookups(self, request, model_admin):
+        return [
+            ("today", "Today"),
+            ("7days", "Last 7 days"),
+            ("30days", "Last 30 days"),
+            ("older", "Older than 30 days"),
+        ]
+
+    def queryset(self, request, queryset):
+        value = self.value()
+        now = timezone.now()
+        if value == "today":
+            start = now.replace(hour=0, minute=0, second=0, microsecond=0)
+            end = start + timedelta(days=1)
+            return queryset.filter(timestamp__gte=start, timestamp__lt=end)
+        if value == "7days":
+            start = now - timedelta(days=7)
+            return queryset.filter(timestamp__gte=start)
+        if value == "30days":
+            start = now - timedelta(days=30)
+            return queryset.filter(timestamp__gte=start)
+        if value == "older":
+            cutoff = now - timedelta(days=30)
+            return queryset.filter(timestamp__lt=cutoff)
+        return queryset
+
+
+@admin.register(MeterReading)
+class MeterReadingAdmin(admin.ModelAdmin):
+    list_display = (
+        "charger",
+        "timestamp",
+        "value",
+        "unit",
+        "connector_id",
+        "transaction",
+    )
+    date_hierarchy = "timestamp"
+    list_filter = ("charger", MeterReadingDateFilter)
+
+
+@admin.register(ElectricVehicle)
+class ElectricVehicleAdmin(admin.ModelAdmin):
+    list_display = ("vin", "license_plate", "brand", "model", "account")
+    search_fields = (
+        "vin",
+        "license_plate",
+        "brand__name",
+        "model__name",
+        "account__name",
+    )
+    fields = ("account", "vin", "license_plate", "brand", "model")
+
+
+admin.site.register(RFID, RFIDAdmin)
+

ocpp/apps.py

@@ -0,0 +1,24 @@
+from django.apps import AppConfig
+from pathlib import Path
+from django.conf import settings
+
+
+class OcppConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "ocpp"
+    verbose_name = "OCPP"
+
+    def ready(self):  # pragma: no cover - startup side effects
+        lock = Path(settings.BASE_DIR) / "locks" / "control.lck"
+        if not lock.exists():
+            return
+        from .rfid.background_reader import start
+        from .rfid.signals import tag_scanned
+        from core.notifications import notify
+
+        def _notify(_sender, rfid=None, **_kwargs):
+            if rfid:
+                notify("RFID", str(rfid))
+
+        tag_scanned.connect(_notify, weak=False)
+        start()

ocpp/consumers.py

@@ -0,0 +1,267 @@
+import asyncio
+import json
+import base64
+from datetime import datetime
+from django.utils import timezone
+from core.models import EnergyAccount
+
+from channels.generic.websocket import AsyncWebsocketConsumer
+from channels.db import database_sync_to_async
+from asgiref.sync import sync_to_async
+from config.offline import requires_network
+
+from . import store
+from decimal import Decimal
+from django.utils.dateparse import parse_datetime
+from .models import Transaction, Charger, MeterReading
+
+
+class SinkConsumer(AsyncWebsocketConsumer):
+    """Accept any message without validation."""
+
+    @requires_network
+    async def connect(self) -> None:
+        await self.accept()
+
+    async def receive(self, text_data: str | None = None, bytes_data: bytes | None = None) -> None:
+        if text_data is None:
+            return
+        try:
+            msg = json.loads(text_data)
+            if isinstance(msg, list) and msg and msg[0] == 2:
+                await self.send(json.dumps([3, msg[1], {}]))
+        except Exception:
+            pass
+
+
+class CSMSConsumer(AsyncWebsocketConsumer):
+    """Very small subset of OCPP 1.6 CSMS behaviour."""
+
+    @requires_network
+    async def connect(self):
+        self.charger_id = self.scope["url_route"]["kwargs"].get("cid", "")
+        subprotocol = None
+        offered = self.scope.get("subprotocols", [])
+        if "ocpp1.6" in offered:
+            subprotocol = "ocpp1.6"
+        # If a connection for this charger already exists, close it so a new
+        # simulator session can start immediately.
+        existing = store.connections.get(self.charger_id)
+        if existing is not None:
+            await existing.close()
+        await self.accept(subprotocol=subprotocol)
+        store.add_log(
+            self.charger_id,
+            f"Connected (subprotocol={subprotocol or 'none'})",
+            log_type="charger",
+        )
+        store.connections[self.charger_id] = self
+        store.logs["charger"].setdefault(self.charger_id, [])
+        self.charger, _ = await database_sync_to_async(
+            Charger.objects.update_or_create
+        )(
+            charger_id=self.charger_id,
+            defaults={"last_path": self.scope.get("path", "")},
+        )
+        location_name = await sync_to_async(
+            lambda: self.charger.location.name if self.charger.location else ""
+        )()
+        store.register_log_name(
+            self.charger_id, location_name or self.charger_id, log_type="charger"
+        )
+
+    async def _get_account(self, id_tag: str) -> EnergyAccount | None:
+        """Return the energy account for the provided RFID if valid."""
+        if not id_tag:
+            return None
+        return await database_sync_to_async(
+            EnergyAccount.objects.filter(
+                rfids__rfid=id_tag.upper(), rfids__allowed=True
+            ).first
+        )()
+
+    async def _store_meter_values(self, payload: dict, raw_message: str) -> None:
+        """Parse a MeterValues payload into MeterReading rows."""
+        connector = payload.get("connectorId")
+        tx_id = payload.get("transactionId")
+        tx_obj = None
+        if tx_id is not None:
+            # Look up an existing transaction, first in the in-memory store
+            # then in the database.  If none exists create one so that meter
+            # readings can be linked to it.
+            tx_obj = store.transactions.get(self.charger_id)
+            if not tx_obj or tx_obj.pk != int(tx_id):
+                tx_obj = await database_sync_to_async(
+                    Transaction.objects.filter(pk=tx_id, charger=self.charger).first
+                )()
+            if tx_obj is None:
+                tx_obj = await database_sync_to_async(Transaction.objects.create)(
+                    pk=tx_id, charger=self.charger, start_time=timezone.now()
+                )
+                store.start_session_log(self.charger_id, tx_obj.pk)
+                store.add_session_message(self.charger_id, raw_message)
+            store.transactions[self.charger_id] = tx_obj
+        else:
+            tx_obj = store.transactions.get(self.charger_id)
+
+        readings = []
+        start_updated = False
+        temperature = None
+        temp_unit = ""
+        for mv in payload.get("meterValue", []):
+            ts = parse_datetime(mv.get("timestamp"))
+            for sv in mv.get("sampledValue", []):
+                try:
+                    val = Decimal(str(sv.get("value")))
+                except Exception:
+                    continue
+                if (
+                    tx_obj
+                    and tx_obj.meter_start is None
+                    and sv.get("measurand", "") in ("", "Energy.Active.Import.Register")
+                ):
+                    try:
+                        mult = 1000 if sv.get("unit") == "kW" else 1
+                        tx_obj.meter_start = int(val * mult)
+                        start_updated = True
+                    except Exception:
+                        pass
+                measurand = sv.get("measurand", "")
+                unit = sv.get("unit", "")
+                if measurand == "Temperature":
+                    temperature = val
+                    temp_unit = unit
+                readings.append(
+                    MeterReading(
+                        charger=self.charger,
+                        connector_id=connector,
+                        transaction=tx_obj,
+                        timestamp=ts,
+                        measurand=measurand,
+                        value=val,
+                        unit=unit,
+                    )
+                )
+        if readings:
+            await database_sync_to_async(MeterReading.objects.bulk_create)(readings)
+            if tx_obj and start_updated:
+                await database_sync_to_async(tx_obj.save)(update_fields=["meter_start"])
+        if connector is not None and not self.charger.connector_id:
+            self.charger.connector_id = str(connector)
+            await database_sync_to_async(self.charger.save)(update_fields=["connector_id"])
+        if temperature is not None:
+            self.charger.temperature = temperature
+            self.charger.temperature_unit = temp_unit
+            await database_sync_to_async(self.charger.save)(
+                update_fields=["temperature", "temperature_unit"]
+            )
+
+    async def disconnect(self, close_code):
+        store.connections.pop(self.charger_id, None)
+        store.end_session_log(self.charger_id)
+        store.add_log(
+            self.charger_id, f"Closed (code={close_code})", log_type="charger"
+        )
+
+    async def receive(self, text_data=None, bytes_data=None):
+        raw = text_data
+        if raw is None and bytes_data is not None:
+            raw = base64.b64encode(bytes_data).decode("ascii")
+        if raw is None:
+            return
+        store.add_log(self.charger_id, raw, log_type="charger")
+        store.add_session_message(self.charger_id, raw)
+        try:
+            msg = json.loads(raw)
+        except json.JSONDecodeError:
+            return
+        if isinstance(msg, list) and msg and msg[0] == 2:
+            msg_id, action = msg[1], msg[2]
+            payload = msg[3] if len(msg) > 3 else {}
+            reply_payload = {}
+            if action == "BootNotification":
+                reply_payload = {
+                    "currentTime": datetime.utcnow().isoformat() + "Z",
+                    "interval": 300,
+                    "status": "Accepted",
+                }
+            elif action == "Heartbeat":
+                reply_payload = {
+                    "currentTime": datetime.utcnow().isoformat() + "Z"
+                }
+                now = timezone.now()
+                self.charger.last_heartbeat = now
+                await database_sync_to_async(
+                    Charger.objects.filter(charger_id=self.charger_id).update
+                )(last_heartbeat=now)
+            elif action == "Authorize":
+                account = await self._get_account(payload.get("idTag"))
+                if self.charger.require_rfid:
+                    status = (
+                        "Accepted"
+                        if account and await database_sync_to_async(account.can_authorize)()
+                        else "Invalid"
+                    )
+                else:
+                    status = "Accepted"
+                reply_payload = {"idTagInfo": {"status": status}}
+            elif action == "MeterValues":
+                await self._store_meter_values(payload, text_data)
+                self.charger.last_meter_values = payload
+                await database_sync_to_async(
+                    Charger.objects.filter(charger_id=self.charger_id).update
+                )(last_meter_values=payload)
+                reply_payload = {}
+            elif action == "StartTransaction":
+                account = await self._get_account(payload.get("idTag"))
+                if self.charger.require_rfid:
+                    authorized = (
+                        account is not None
+                        and await database_sync_to_async(account.can_authorize)()
+                    )
+                else:
+                    authorized = True
+                if authorized:
+                    tx_obj = await database_sync_to_async(Transaction.objects.create)(
+                        charger=self.charger,
+                        account=account,
+                        rfid=(payload.get("idTag") or ""),
+                        vin=(payload.get("vin") or ""),
+                        meter_start=payload.get("meterStart"),
+                        start_time=timezone.now(),
+                    )
+                    store.transactions[self.charger_id] = tx_obj
+                    store.start_session_log(self.charger_id, tx_obj.pk)
+                    store.add_session_message(self.charger_id, text_data)
+                    reply_payload = {
+                        "transactionId": tx_obj.pk,
+                        "idTagInfo": {"status": "Accepted"},
+                    }
+                else:
+                    reply_payload = {"idTagInfo": {"status": "Invalid"}}
+            elif action == "StopTransaction":
+                tx_id = payload.get("transactionId")
+                tx_obj = store.transactions.pop(self.charger_id, None)
+                if not tx_obj and tx_id is not None:
+                    tx_obj = await database_sync_to_async(
+                        Transaction.objects.filter(pk=tx_id, charger=self.charger).first
+                    )()
+                if not tx_obj and tx_id is not None:
+                    tx_obj = await database_sync_to_async(Transaction.objects.create)(
+                        pk=tx_id,
+                        charger=self.charger,
+                        start_time=timezone.now(),
+                        meter_start=payload.get("meterStart") or payload.get("meterStop"),
+                        vin=(payload.get("vin") or ""),
+                    )
+                if tx_obj:
+                    tx_obj.meter_stop = payload.get("meterStop")
+                    tx_obj.stop_time = timezone.now()
+                    await database_sync_to_async(tx_obj.save)()
+                reply_payload = {"idTagInfo": {"status": "Accepted"}}
+                store.end_session_log(self.charger_id)
+            response = [3, msg_id, reply_payload]
+            await self.send(json.dumps(response))
+            store.add_log(
+                self.charger_id, f"< {json.dumps(response)}", log_type="charger"
+            )