arthexis 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

ocpp/admin.py

@@ -11,12 +11,16 @@ from django.urls import path
 from django.http import HttpResponse, HttpResponseRedirect
 from django.template.response import TemplateResponse
 
+import uuid
+from asgiref.sync import async_to_sync
+
 from .models import (
     Charger,
     Simulator,
     MeterValue,
     Transaction,
     Location,
+    DataTransferMessage,
 )
 from .simulator import ChargePointSimulator
 from . import store
@@ -24,6 +28,8 @@ from .transactions_io import (
     export_transactions,
     import_transactions as import_transactions_data,
 )
+from .status_display import STATUS_BADGE_MAP, ERROR_OK_VALUES
+from core.admin import SaveBeforeChangeAction
 from core.user_data import EntityModelAdmin
 
 
@@ -108,6 +114,44 @@ class LocationAdmin(EntityModelAdmin):
     change_form_template = "admin/ocpp/location/change_form.html"
 
 
+@admin.register(DataTransferMessage)
+class DataTransferMessageAdmin(admin.ModelAdmin):
+    list_display = (
+        "charger",
+        "connector_id",
+        "direction",
+        "vendor_id",
+        "message_id",
+        "status",
+        "created_at",
+        "responded_at",
+    )
+    list_filter = ("direction", "status")
+    search_fields = (
+        "charger__charger_id",
+        "ocpp_message_id",
+        "vendor_id",
+        "message_id",
+    )
+    readonly_fields = (
+        "charger",
+        "connector_id",
+        "direction",
+        "ocpp_message_id",
+        "vendor_id",
+        "message_id",
+        "payload",
+        "status",
+        "response_data",
+        "error_code",
+        "error_description",
+        "error_details",
+        "responded_at",
+        "created_at",
+        "updated_at",
+    )
+
+
 @admin.register(Charger)
 class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
     fieldsets = (
@@ -122,6 +166,13 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
                     "last_path",
                     "last_heartbeat",
                     "last_meter_values",
+                )
+            },
+        ),
+        (
+            "Firmware",
+            {
+                "fields": (
                     "firmware_status",
                     "firmware_status_info",
                     "firmware_timestamp",
@@ -138,6 +189,20 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
                 )
             },
         ),
+        (
+            "Availability",
+            {
+                "fields": (
+                    "availability_state",
+                    "availability_state_updated_at",
+                    "availability_requested_state",
+                    "availability_requested_at",
+                    "availability_request_status",
+                    "availability_request_status_at",
+                    "availability_request_details",
+                )
+            },
+        ),
         (
             "Configuration",
             {"fields": ("public_display", "require_rfid")},
@@ -148,6 +213,13 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
                 "fields": ("reference",),
             },
         ),
+        (
+            "Owner",
+            {
+                "fields": ("owner_users", "owner_groups"),
+                "classes": ("collapse",),
+            },
+        ),
     )
     readonly_fields = (
         "last_heartbeat",
@@ -155,16 +227,21 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
         "firmware_status",
         "firmware_status_info",
         "firmware_timestamp",
+        "availability_state",
+        "availability_state_updated_at",
+        "availability_requested_state",
+        "availability_requested_at",
+        "availability_request_status",
+        "availability_request_status_at",
+        "availability_request_details",
     )
     list_display = (
         "charger_id",
-        "connector_id",
+        "connector_number",
         "location_name",
         "require_rfid_display",
         "public_display",
         "last_heartbeat",
-        "firmware_status",
-        "firmware_timestamp",
         "session_kw",
         "total_kw_display",
         "page_link",
@@ -172,7 +249,18 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
         "status_link",
     )
     search_fields = ("charger_id", "connector_id", "location__name")
-    actions = ["purge_data", "delete_selected"]
+    filter_horizontal = ("owner_users", "owner_groups")
+    actions = [
+        "purge_data",
+        "fetch_cp_configuration",
+        "change_availability_operative",
+        "change_availability_inoperative",
+        "set_availability_state_operative",
+        "set_availability_state_inoperative",
+        "remote_stop_transaction",
+        "reset_chargers",
+        "delete_selected",
+    ]
 
     def get_view_on_site_url(self, obj=None):
         return obj.get_absolute_url() if obj else None
@@ -215,6 +303,12 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
     def get_log_identifier(self, obj):
         return store.identity_key(obj.charger_id, obj.connector_id)
 
+    def connector_number(self, obj):
+        return obj.connector_id if obj.connector_id is not None else ""
+
+    connector_number.short_description = "#"
+    connector_number.admin_order_field = "connector_id"
+
     def status_link(self, obj):
         from django.utils.html import format_html
         from django.urls import reverse
@@ -223,10 +317,36 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
             "charger-status-connector",
             args=[obj.charger_id, obj.connector_slug],
         )
-        return format_html('<a href="{}" target="_blank">status</a>', url)
+        label = (obj.last_status or "status").strip() or "status"
+        status_key = label.lower()
+        error_code = (obj.last_error_code or "").strip().lower()
+        if (
+            self._has_active_session(obj)
+            and error_code in ERROR_OK_VALUES
+            and (status_key not in STATUS_BADGE_MAP or status_key == "available")
+        ):
+            label = STATUS_BADGE_MAP["charging"][0]
+        return format_html('<a href="{}" target="_blank">{}</a>', url, label)
 
     status_link.short_description = "Status"
 
+    def _has_active_session(self, charger: Charger) -> bool:
+        """Return whether ``charger`` currently has an active session."""
+
+        if store.get_transaction(charger.charger_id, charger.connector_id):
+            return True
+        if charger.connector_id is not None:
+            return False
+        sibling_connectors = (
+            Charger.objects.filter(charger_id=charger.charger_id)
+            .exclude(pk=charger.pk)
+            .values_list("connector_id", flat=True)
+        )
+        for connector_id in sibling_connectors:
+            if store.get_transaction(charger.charger_id, connector_id):
+                return True
+        return False
+
     def location_name(self, obj):
         return obj.location.name if obj.location else ""
 
@@ -239,6 +359,257 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
 
     purge_data.short_description = "Purge data"
 
+    @admin.action(description="Fetch CP configuration")
+    def fetch_cp_configuration(self, request, queryset):
+        fetched = 0
+        for charger in queryset:
+            connector_value = charger.connector_id
+            ws = store.get_connection(charger.charger_id, connector_value)
+            if ws is None:
+                self.message_user(
+                    request,
+                    f"{charger}: no active connection",
+                    level=messages.ERROR,
+                )
+                continue
+            message_id = uuid.uuid4().hex
+            payload = {}
+            msg = json.dumps([2, message_id, "GetConfiguration", payload])
+            try:
+                async_to_sync(ws.send)(msg)
+            except Exception as exc:  # pragma: no cover - network error
+                self.message_user(
+                    request,
+                    f"{charger}: failed to send GetConfiguration ({exc})",
+                    level=messages.ERROR,
+                )
+                continue
+            log_key = store.identity_key(charger.charger_id, connector_value)
+            store.add_log(log_key, f"< {msg}", log_type="charger")
+            store.register_pending_call(
+                message_id,
+                {
+                    "action": "GetConfiguration",
+                    "charger_id": charger.charger_id,
+                    "connector_id": connector_value,
+                    "log_key": log_key,
+                    "requested_at": timezone.now(),
+                },
+            )
+            store.schedule_call_timeout(
+                message_id,
+                timeout=5.0,
+                action="GetConfiguration",
+                log_key=log_key,
+                message=(
+                    "GetConfiguration timed out: charger did not respond"
+                    " (operation may not be supported)"
+                ),
+            )
+            fetched += 1
+        if fetched:
+            self.message_user(
+                request,
+                f"Requested configuration from {fetched} charger(s)",
+            )
+
+    def _dispatch_change_availability(self, request, queryset, availability_type: str):
+        sent = 0
+        for charger in queryset:
+            connector_value = charger.connector_id
+            ws = store.get_connection(charger.charger_id, connector_value)
+            if ws is None:
+                self.message_user(
+                    request,
+                    f"{charger}: no active connection",
+                    level=messages.ERROR,
+                )
+                continue
+            connector_id = connector_value if connector_value is not None else 0
+            message_id = uuid.uuid4().hex
+            payload = {"connectorId": connector_id, "type": availability_type}
+            msg = json.dumps([2, message_id, "ChangeAvailability", payload])
+            try:
+                async_to_sync(ws.send)(msg)
+            except Exception as exc:  # pragma: no cover - network error
+                self.message_user(
+                    request,
+                    f"{charger}: failed to send ChangeAvailability ({exc})",
+                    level=messages.ERROR,
+                )
+                continue
+            log_key = store.identity_key(charger.charger_id, connector_value)
+            store.add_log(log_key, f"< {msg}", log_type="charger")
+            timestamp = timezone.now()
+            store.register_pending_call(
+                message_id,
+                {
+                    "action": "ChangeAvailability",
+                    "charger_id": charger.charger_id,
+                    "connector_id": connector_value,
+                    "availability_type": availability_type,
+                    "requested_at": timestamp,
+                },
+            )
+            updates = {
+                "availability_requested_state": availability_type,
+                "availability_requested_at": timestamp,
+                "availability_request_status": "",
+                "availability_request_status_at": None,
+                "availability_request_details": "",
+            }
+            Charger.objects.filter(pk=charger.pk).update(**updates)
+            for field, value in updates.items():
+                setattr(charger, field, value)
+            sent += 1
+        if sent:
+            self.message_user(
+                request,
+                f"Sent ChangeAvailability ({availability_type}) to {sent} charger(s)",
+            )
+
+    @admin.action(description="Set availability to Operative")
+    def change_availability_operative(self, request, queryset):
+        self._dispatch_change_availability(request, queryset, "Operative")
+
+    @admin.action(description="Set availability to Inoperative")
+    def change_availability_inoperative(self, request, queryset):
+        self._dispatch_change_availability(request, queryset, "Inoperative")
+
+    def _set_availability_state(
+        self, request, queryset, availability_state: str
+    ) -> None:
+        timestamp = timezone.now()
+        updated = 0
+        for charger in queryset:
+            updates = {
+                "availability_state": availability_state,
+                "availability_state_updated_at": timestamp,
+            }
+            Charger.objects.filter(pk=charger.pk).update(**updates)
+            for field, value in updates.items():
+                setattr(charger, field, value)
+            updated += 1
+        if updated:
+            self.message_user(
+                request,
+                f"Updated availability to {availability_state} for {updated} charger(s)",
+            )
+
+    @admin.action(description="Mark availability as Operative")
+    def set_availability_state_operative(self, request, queryset):
+        self._set_availability_state(request, queryset, "Operative")
+
+    @admin.action(description="Mark availability as Inoperative")
+    def set_availability_state_inoperative(self, request, queryset):
+        self._set_availability_state(request, queryset, "Inoperative")
+
+    @admin.action(description="Remote stop active transaction")
+    def remote_stop_transaction(self, request, queryset):
+        stopped = 0
+        for charger in queryset:
+            connector_value = charger.connector_id
+            ws = store.get_connection(charger.charger_id, connector_value)
+            if ws is None:
+                self.message_user(
+                    request,
+                    f"{charger}: no active connection",
+                    level=messages.ERROR,
+                )
+                continue
+            tx_obj = store.get_transaction(charger.charger_id, connector_value)
+            if tx_obj is None:
+                self.message_user(
+                    request,
+                    f"{charger}: no active transaction",
+                    level=messages.ERROR,
+                )
+                continue
+            message_id = uuid.uuid4().hex
+            payload = {"transactionId": tx_obj.pk}
+            msg = json.dumps([
+                2,
+                message_id,
+                "RemoteStopTransaction",
+                payload,
+            ])
+            try:
+                async_to_sync(ws.send)(msg)
+            except Exception as exc:  # pragma: no cover - network error
+                self.message_user(
+                    request,
+                    f"{charger}: failed to send RemoteStopTransaction ({exc})",
+                    level=messages.ERROR,
+                )
+                continue
+            log_key = store.identity_key(charger.charger_id, connector_value)
+            store.add_log(log_key, f"< {msg}", log_type="charger")
+            store.register_pending_call(
+                message_id,
+                {
+                    "action": "RemoteStopTransaction",
+                    "charger_id": charger.charger_id,
+                    "connector_id": connector_value,
+                    "transaction_id": tx_obj.pk,
+                    "log_key": log_key,
+                    "requested_at": timezone.now(),
+                },
+            )
+            stopped += 1
+        if stopped:
+            self.message_user(
+                request,
+                f"Sent RemoteStopTransaction to {stopped} charger(s)",
+            )
+
+    @admin.action(description="Reset charger (soft)")
+    def reset_chargers(self, request, queryset):
+        reset = 0
+        for charger in queryset:
+            connector_value = charger.connector_id
+            ws = store.get_connection(charger.charger_id, connector_value)
+            if ws is None:
+                self.message_user(
+                    request,
+                    f"{charger}: no active connection",
+                    level=messages.ERROR,
+                )
+                continue
+            message_id = uuid.uuid4().hex
+            msg = json.dumps([
+                2,
+                message_id,
+                "Reset",
+                {"type": "Soft"},
+            ])
+            try:
+                async_to_sync(ws.send)(msg)
+            except Exception as exc:  # pragma: no cover - network error
+                self.message_user(
+                    request,
+                    f"{charger}: failed to send Reset ({exc})",
+                    level=messages.ERROR,
+                )
+                continue
+            log_key = store.identity_key(charger.charger_id, connector_value)
+            store.add_log(log_key, f"< {msg}", log_type="charger")
+            store.register_pending_call(
+                message_id,
+                {
+                    "action": "Reset",
+                    "charger_id": charger.charger_id,
+                    "connector_id": connector_value,
+                    "log_key": log_key,
+                    "requested_at": timezone.now(),
+                },
+            )
+            reset += 1
+        if reset:
+            self.message_user(
+                request,
+                f"Sent Reset to {reset} charger(s)",
+            )
+
     def delete_queryset(self, request, queryset):
         for obj in queryset:
             obj.delete()
@@ -258,7 +629,7 @@ class ChargerAdmin(LogViewAdminMixin, EntityModelAdmin):
 
 
 @admin.register(Simulator)
-class SimulatorAdmin(LogViewAdminMixin, EntityModelAdmin):
+class SimulatorAdmin(SaveBeforeChangeAction, LogViewAdminMixin, EntityModelAdmin):
     list_display = (
         "name",
         "cp_path",
@@ -270,17 +641,39 @@ class SimulatorAdmin(LogViewAdminMixin, EntityModelAdmin):
         "running",
         "log_link",
     )
-    fields = (
-        "name",
-        "cp_path",
-        ("host", "ws_port"),
-        "rfid",
-        ("duration", "interval", "pre_charge_delay"),
-        "kw_max",
-        ("repeat", "door_open"),
-        ("username", "password"),
+    fieldsets = (
+        (
+            None,
+            {
+                "fields": (
+                    "name",
+                    "cp_path",
+                    ("host", "ws_port"),
+                    "rfid",
+                    ("duration", "interval", "pre_charge_delay"),
+                    "kw_max",
+                    ("repeat", "door_open"),
+                    ("username", "password"),
+                )
+            },
+        ),
+        (
+            "Configuration",
+            {
+                "fields": (
+                    "configuration_keys",
+                    "configuration_unknown_keys",
+                ),
+                "classes": ("collapse",),
+                "description": (
+                    "Provide JSON lists for configurationKey entries and "
+                    "unknownKey values returned by GetConfiguration."
+                ),
+            },
+        ),
     )
     actions = ("start_simulator", "stop_simulator", "send_open_door")
+    change_actions = ["start_simulator_action", "stop_simulator_action"]
 
     log_type = "simulator"
 
@@ -382,11 +775,25 @@ class SimulatorAdmin(LogViewAdminMixin, EntityModelAdmin):
                 if sim:
                     await sim.stop()
 
-        asyncio.get_event_loop().create_task(_stop(list(queryset)))
+        objs = list(queryset)
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            asyncio.run(_stop(objs))
+        else:
+            loop.create_task(_stop(objs))
         self.message_user(request, "Stopping simulators")
 
     stop_simulator.short_description = "Stop selected simulators"
 
+    def start_simulator_action(self, request, obj):
+        queryset = type(obj).objects.filter(pk=obj.pk)
+        self.start_simulator(request, queryset)
+
+    def stop_simulator_action(self, request, obj):
+        queryset = type(obj).objects.filter(pk=obj.pk)
+        self.stop_simulator(request, queryset)
+
     def log_link(self, obj):
         from django.utils.html import format_html
         from django.urls import reverse
@@ -431,7 +838,7 @@ class TransactionAdmin(EntityModelAdmin):
         "stop_time",
         "kw",
     )
-    readonly_fields = ("kw",)
+    readonly_fields = ("kw", "received_start_time", "received_stop_time")
     list_filter = ("charger", "account")
     date_hierarchy = "start_time"
     inlines = [MeterValueInline]