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

nodes/views.py

@@ -403,7 +403,20 @@ def node_info(request):
             advertised_port = host_port
     if host_domain:
         hostname = host_domain
-        address = advertised_address or host_domain
+        local_aliases = {
+            value
+            for value in (
+                node.hostname,
+                node.network_hostname,
+                node.address,
+                node.public_endpoint,
+            )
+            if value
+        }
+        if advertised_address and advertised_address not in local_aliases:
+            address = advertised_address
+        else:
+            address = host_domain
     else:
         hostname = node.hostname
         address = advertised_address or node.address or node.network_hostname or ""
@@ -526,7 +539,7 @@ def register_node(request):
     network_hostname = (data.get("network_hostname") or "").strip()
     ipv4_address = (data.get("ipv4_address") or "").strip()
     ipv6_address = (data.get("ipv6_address") or "").strip()
-    port = data.get("port", 8000)
+    port = data.get("port", 8888)
     mac_address = (data.get("mac_address") or "").strip()
     public_key = data.get("public_key")
     token = data.get("token")
@@ -562,7 +575,7 @@ def register_node(request):
     try:
         port = int(port)
     except (TypeError, ValueError):
-        port = 8000
+        port = 8888
 
     verified = False
     if public_key and token and signature:
@@ -1090,6 +1103,101 @@ def _toggle_rfid(
     return True, detail, {"require_rfid": enable_bool}
 
 
+def _send_local_rfid_list_remote(
+    charger: Charger, payload: Mapping | None = None
+) -> tuple[bool, str, dict[str, object]]:
+    connector_value = charger.connector_id
+    ws = store.get_connection(charger.charger_id, connector_value)
+    if ws is None:
+        return False, "no active connection", {}
+    authorization_list = []
+    if payload is not None:
+        authorization_list = payload.get("local_authorization_list", []) or []
+    if not isinstance(authorization_list, list):
+        return False, "local_authorization_list must be a list", {}
+    list_version = None
+    if payload is not None:
+        list_version = payload.get("list_version")
+    if list_version is None:
+        list_version_value = (charger.local_auth_list_version or 0) + 1
+    else:
+        try:
+            list_version_value = int(list_version)
+        except (TypeError, ValueError):
+            return False, "invalid list_version", {}
+        if list_version_value <= 0:
+            return False, "invalid list_version", {}
+    update_type = "Full"
+    if payload is not None and payload.get("update_type"):
+        update_type = str(payload.get("update_type") or "").strip() or "Full"
+    message_id = uuid.uuid4().hex
+    msg_payload = {
+        "listVersion": list_version_value,
+        "updateType": update_type,
+        "localAuthorizationList": authorization_list,
+    }
+    msg = json.dumps([2, message_id, "SendLocalList", msg_payload])
+    try:
+        async_to_sync(ws.send)(msg)
+    except Exception as exc:
+        return False, f"failed to send SendLocalList ({exc})", {}
+    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": "SendLocalList",
+            "charger_id": charger.charger_id,
+            "connector_id": connector_value,
+            "log_key": log_key,
+            "list_version": list_version_value,
+            "list_size": len(authorization_list),
+            "requested_at": timezone.now(),
+        },
+    )
+    store.schedule_call_timeout(
+        message_id,
+        action="SendLocalList",
+        log_key=log_key,
+        message="SendLocalList request timed out",
+    )
+    return True, "SendLocalList dispatched", {}
+
+
+def _get_local_list_version_remote(
+    charger: Charger, payload: Mapping | None = None
+) -> tuple[bool, str, dict[str, object]]:
+    connector_value = charger.connector_id
+    ws = store.get_connection(charger.charger_id, connector_value)
+    if ws is None:
+        return False, "no active connection", {}
+    message_id = uuid.uuid4().hex
+    msg = json.dumps([2, message_id, "GetLocalListVersion", {}])
+    try:
+        async_to_sync(ws.send)(msg)
+    except Exception as exc:
+        return False, f"failed to send GetLocalListVersion ({exc})", {}
+    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": "GetLocalListVersion",
+            "charger_id": charger.charger_id,
+            "connector_id": connector_value,
+            "log_key": log_key,
+            "requested_at": timezone.now(),
+        },
+    )
+    store.schedule_call_timeout(
+        message_id,
+        action="GetLocalListVersion",
+        log_key=log_key,
+        message="GetLocalListVersion request timed out",
+    )
+    return True, "GetLocalListVersion requested", {}
+
+
 def _change_availability_remote(
     charger: Charger, payload: Mapping | None = None
 ) -> tuple[bool, str, dict[str, object]]:
@@ -1143,6 +1251,40 @@ def _change_availability_remote(
     return True, f"requested ChangeAvailability {availability_label}", updates
 
 
+def _clear_cache_remote(
+    charger: Charger, payload: Mapping | None = None
+) -> tuple[bool, str, dict[str, object]]:
+    connector_value = charger.connector_id
+    ws = store.get_connection(charger.charger_id, connector_value)
+    if ws is None:
+        return False, "no active connection", {}
+    message_id = uuid.uuid4().hex
+    msg = json.dumps([2, message_id, "ClearCache", {}])
+    try:
+        async_to_sync(ws.send)(msg)
+    except Exception as exc:
+        return False, f"failed to send ClearCache ({exc})", {}
+    log_key = store.identity_key(charger.charger_id, connector_value)
+    store.add_log(log_key, f"< {msg}", log_type="charger")
+    requested_at = timezone.now()
+    store.register_pending_call(
+        message_id,
+        {
+            "action": "ClearCache",
+            "charger_id": charger.charger_id,
+            "connector_id": connector_value,
+            "log_key": log_key,
+            "requested_at": requested_at,
+        },
+    )
+    store.schedule_call_timeout(
+        message_id,
+        action="ClearCache",
+        log_key=log_key,
+    )
+    return True, "requested ClearCache", {}
+
+
 def _set_availability_state_remote(
     charger: Charger, payload: Mapping | None = None
 ) -> tuple[bool, str, dict[str, object]]:
@@ -1207,7 +1349,10 @@ REMOTE_ACTIONS = {
     "get-configuration": _send_get_configuration,
     "reset": _send_reset,
     "toggle-rfid": _toggle_rfid,
+    "send-local-rfid-list": _send_local_rfid_list_remote,
+    "get-local-list-version": _get_local_list_version_remote,
     "change-availability": _change_availability_remote,
+    "clear-cache": _clear_cache_remote,
     "set-availability-state": _set_availability_state_remote,
     "remote-stop": _remote_stop_transaction_remote,
 }