arthexis 0.1.3__py3-none-any.whl

ocpp/store.py

@@ -0,0 +1,175 @@
+"""In-memory store for OCPP data with file backed logs."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from datetime import datetime
+import json
+import re
+
+connections = {}
+transactions = {}
+logs: dict[str, dict[str, list[str]]] = {"charger": {}, "simulator": {}}
+# store per charger session logs before they are flushed to disk
+history: dict[str, dict[str, object]] = {}
+simulators = {}
+
+# mapping of charger id / cp_path to friendly names used for log files
+log_names: dict[str, dict[str, str]] = {"charger": {}, "simulator": {}}
+
+LOG_DIR = Path(__file__).resolve().parent.parent / "logs"
+LOG_DIR.mkdir(exist_ok=True)
+SESSION_DIR = LOG_DIR / "sessions"
+SESSION_DIR.mkdir(exist_ok=True)
+
+
+def register_log_name(cid: str, name: str, log_type: str = "charger") -> None:
+    """Register a friendly name for the id used in log files."""
+
+    names = log_names[log_type]
+    # Ensure lookups are case-insensitive by overwriting any existing entry
+    # that matches the provided cid regardless of case.
+    for key in list(names.keys()):
+        if key.lower() == cid.lower():
+            cid = key
+            break
+    names[cid] = name
+
+
+def _safe_name(name: str) -> str:
+    return re.sub(r"[^\w.-]", "_", name)
+
+
+def _file_path(cid: str, log_type: str = "charger") -> Path:
+    name = log_names[log_type].get(cid, cid)
+    return LOG_DIR / f"{log_type}.{_safe_name(name)}.log"
+
+
+def add_log(cid: str, entry: str, log_type: str = "charger") -> None:
+    """Append a timestamped log entry for the given id and log type."""
+
+    timestamp = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
+    entry = f"{timestamp} {entry}"
+
+    store = logs[log_type]
+    # Store log entries under the cid as provided but allow retrieval using
+    # any casing by recording entries in a case-insensitive manner.
+    key = next((k for k in store.keys() if k.lower() == cid.lower()), cid)
+    store.setdefault(key, []).append(entry)
+    path = _file_path(key, log_type)
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write(entry + "\n")
+
+
+def _session_folder(cid: str) -> Path:
+    """Return the folder path for session logs for the given charger."""
+
+    name = log_names["charger"].get(cid, cid)
+    folder = SESSION_DIR / _safe_name(name)
+    folder.mkdir(parents=True, exist_ok=True)
+    return folder
+
+
+def start_session_log(cid: str, tx_id: int) -> None:
+    """Begin logging a session for the given charger and transaction id."""
+
+    history[cid] = {
+        "transaction": tx_id,
+        "start": datetime.utcnow(),
+        "messages": [],
+    }
+
+
+def add_session_message(cid: str, message: str) -> None:
+    """Record a raw message for the current session if one is active."""
+
+    sess = history.get(cid)
+    if not sess:
+        return
+    sess["messages"].append({
+        "timestamp": datetime.utcnow().isoformat() + "Z",
+        "message": message,
+    })
+
+
+def end_session_log(cid: str) -> None:
+    """Write any recorded session log to disk for the given charger."""
+
+    sess = history.pop(cid, None)
+    if not sess:
+        return
+    folder = _session_folder(cid)
+    date = sess["start"].strftime("%Y%m%d")
+    tx_id = sess.get("transaction")
+    filename = f"{date}_{tx_id}.json"
+    path = folder / filename
+    with path.open("w", encoding="utf-8") as handle:
+        json.dump(sess["messages"], handle, ensure_ascii=False, indent=2)
+
+
+def get_logs(cid: str, log_type: str = "charger") -> list[str]:
+    """Return all log entries for the given id and type."""
+
+    names = log_names[log_type]
+    # Try to find a matching log name case-insensitively
+    name = names.get(cid)
+    if name is None:
+        for key, value in names.items():
+            if key.lower() == cid.lower():
+                cid = key
+                name = value
+                break
+        else:
+            try:
+                if log_type == "simulator":
+                    from .models import Simulator
+
+                    sim = Simulator.objects.filter(cp_path__iexact=cid).first()
+                    if sim:
+                        cid = sim.cp_path
+                        name = sim.name
+                        names[cid] = name
+                else:
+                    from .models import Charger
+
+                    ch = Charger.objects.filter(charger_id__iexact=cid).first()
+                    if ch and ch.name:
+                        cid = ch.charger_id
+                        name = ch.name
+                        names[cid] = name
+            except Exception:  # pragma: no cover - best effort lookup
+                pass
+
+    path = _file_path(cid, log_type)
+    if not path.exists():
+        target = f"{log_type}.{_safe_name(name or cid).lower()}"
+        for file in LOG_DIR.glob(f"{log_type}.*.log"):
+            if file.stem.lower() == target:
+                path = file
+                break
+
+    if path.exists():
+        return path.read_text(encoding="utf-8").splitlines()
+
+    store = logs[log_type]
+    for key, entries in store.items():
+        if key.lower() == cid.lower():
+            return entries
+    return []
+
+
+def clear_log(cid: str, log_type: str = "charger") -> None:
+    """Remove any stored logs for the given id and type."""
+
+    store = logs[log_type]
+    key = next((k for k in list(store.keys()) if k.lower() == cid.lower()), cid)
+    store.pop(key, None)
+    path = _file_path(key, log_type)
+    if not path.exists():
+        target = f"{log_type}.{_safe_name(log_names[log_type].get(key, key)).lower()}"
+        for file in LOG_DIR.glob(f"{log_type}.*.log"):
+            if file.stem.lower() == target:
+                path = file
+                break
+    if path.exists():
+        path.unlink()

ocpp/tasks.py

@@ -0,0 +1,27 @@
+import logging
+from datetime import timedelta
+
+from celery import shared_task
+from django.utils import timezone
+from django.db.models import Q
+
+from .models import MeterReading
+
+logger = logging.getLogger(__name__)
+
+
+@shared_task
+def purge_meter_readings() -> int:
+    """Delete meter readings older than 7 days.
+
+    Readings tied to transactions without a recorded meter_stop are preserved so
+    that ongoing or incomplete sessions retain their energy data.
+    Returns the number of deleted readings.
+    """
+    cutoff = timezone.now() - timedelta(days=7)
+    qs = MeterReading.objects.filter(timestamp__lt=cutoff).filter(
+        Q(transaction__isnull=True) | Q(transaction__meter_stop__isnull=False)
+    )
+    deleted, _ = qs.delete()
+    logger.info("Purged %s meter readings", deleted)
+    return deleted

ocpp/test_export_import.py

@@ -0,0 +1,129 @@
+import json
+import os
+import tempfile
+from datetime import timedelta
+import io
+
+from django.core.management import call_command
+from django.test import TestCase
+from django.utils import timezone
+from django.urls import reverse
+from django.contrib.auth import get_user_model
+
+from ocpp.models import Charger, Transaction, MeterReading
+from core.models import EnergyAccount
+
+
+class TransactionExportImportTests(TestCase):
+    def setUp(self):
+        self.account = EnergyAccount.objects.create(name="ACC")
+        self.ch1 = Charger.objects.create(charger_id="C1")
+        self.ch2 = Charger.objects.create(charger_id="C2")
+        now = timezone.now()
+        self.tx_old = Transaction.objects.create(
+            charger=self.ch1,
+            account=self.account,
+            start_time=now - timedelta(days=5),
+        )
+        self.tx_new = Transaction.objects.create(
+            charger=self.ch2,
+            start_time=now,
+        )
+        MeterReading.objects.create(
+            charger=self.ch1,
+            transaction=self.tx_old,
+            timestamp=now - timedelta(days=5),
+            value=1,
+            unit="kW",
+        )
+
+    def test_export_filters_and_import_creates_chargers(self):
+        with tempfile.NamedTemporaryFile(delete=False) as tmp:
+            tmp_path = tmp.name
+
+        start = (timezone.now() - timedelta(days=1)).date().isoformat()
+        call_command(
+            "export_transactions",
+            tmp_path,
+            "--start",
+            start,
+            "--chargers",
+            self.ch2.charger_id,
+        )
+        with open(tmp_path, "r", encoding="utf-8") as fh:
+            data = json.load(fh)
+        self.assertEqual(len(data["transactions"]), 1)
+        self.assertEqual(data["transactions"][0]["charger"], "C2")
+
+        MeterReading.objects.all().delete()
+        Transaction.objects.all().delete()
+        Charger.objects.all().delete()
+
+        call_command("import_transactions", tmp_path)
+        os.remove(tmp_path)
+
+        self.assertTrue(Charger.objects.filter(charger_id="C2").exists())
+        self.assertEqual(Transaction.objects.count(), 1)
+        tx = Transaction.objects.first()
+        self.assertEqual(tx.charger.charger_id, "C2")
+
+
+class TransactionAdminExportImportTests(TestCase):
+    def setUp(self):
+        self.account = EnergyAccount.objects.create(name="ACC")
+        self.ch1 = Charger.objects.create(charger_id="C1")
+        self.ch2 = Charger.objects.create(charger_id="C2")
+        now = timezone.now()
+        Transaction.objects.create(
+            charger=self.ch1,
+            account=self.account,
+            start_time=now - timedelta(days=2),
+        )
+        Transaction.objects.create(
+            charger=self.ch2,
+            start_time=now,
+        )
+        User = get_user_model()
+        self.admin = User.objects.create_superuser(
+            username="txadmin", email="txadmin@example.com", password="pwd"
+        )
+        self.client.force_login(self.admin)
+
+    def test_admin_export_filters(self):
+        url = reverse("admin:ocpp_transaction_export")
+        start = (timezone.now() - timedelta(days=1)).isoformat()
+        response = self.client.post(
+            url,
+            {"start": start, "chargers": [self.ch2.pk]},
+        )
+        self.assertEqual(response.status_code, 200)
+        data = json.loads(response.content)
+        self.assertEqual(len(data["transactions"]), 1)
+        self.assertEqual(data["transactions"][0]["charger"], "C2")
+
+    def test_admin_import_creates_charger(self):
+        url = reverse("admin:ocpp_transaction_import")
+        payload = {
+            "chargers": [
+                {"charger_id": "C9", "connector_id": 1, "require_rfid": False}
+            ],
+            "transactions": [
+                {
+                    "charger": "C9",
+                    "account": None,
+                    "rfid": "",
+                    "vin": "",
+                    "meter_start": 0,
+                    "meter_stop": 0,
+                    "start_time": timezone.now().isoformat(),
+                    "stop_time": None,
+                    "meter_readings": [],
+                }
+            ],
+        }
+        json_file = io.StringIO(json.dumps(payload))
+        json_file.name = "tx.json"
+        response = self.client.post(url, {"file": json_file})
+        self.assertEqual(response.status_code, 302)
+        self.assertTrue(Charger.objects.filter(charger_id="C9").exists())
+        self.assertEqual(Transaction.objects.filter(charger__charger_id="C9").count(), 1)

ocpp/test_rfid.py

@@ -0,0 +1,345 @@
+import os
+from unittest.mock import patch, MagicMock, call
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+
+import django
+django.setup()
+
+from django.test import SimpleTestCase, TestCase
+from django.urls import reverse
+from django.contrib.auth import get_user_model
+from django.contrib.sites.models import Site
+
+from pages.models import Application, Module
+from nodes.models import Node, NodeRole
+
+from core.models import RFID
+from ocpp.rfid.reader import read_rfid, enable_deep_read
+
+
+class ScanNextViewTests(SimpleTestCase):
+    @patch("config.middleware.Node.get_local", return_value=None)
+    @patch("config.middleware.get_site")
+    @patch(
+        "ocpp.rfid.views.scan_sources",
+        return_value={
+            "rfid": "ABCD1234",
+            "label_id": 1,
+            "created": False,
+            "kind": RFID.CLASSIC,
+        },
+    )
+    def test_scan_next_success(self, mock_scan, mock_site, mock_node):
+        resp = self.client.get(reverse("rfid-scan-next"))
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(
+            resp.json(),
+            {
+                "rfid": "ABCD1234",
+                "label_id": 1,
+                "created": False,
+                "kind": RFID.CLASSIC,
+            },
+        )
+
+    @patch("config.middleware.Node.get_local", return_value=None)
+    @patch("config.middleware.get_site")
+    @patch("ocpp.rfid.views.scan_sources", return_value={"error": "boom"})
+    def test_scan_next_error(self, mock_scan, mock_site, mock_node):
+        resp = self.client.get(reverse("rfid-scan-next"))
+        self.assertEqual(resp.status_code, 500)
+        self.assertEqual(resp.json(), {"error": "boom"})
+
+
+class ReaderNotificationTests(TestCase):
+    def _mock_reader(self):
+        class MockReader:
+            MI_OK = 1
+            PICC_REQIDL = 0
+
+            def MFRC522_Request(self, _):
+                return (self.MI_OK, None)
+
+            def MFRC522_Anticoll(self):
+                return (self.MI_OK, [0xAB, 0xCD, 0x12, 0x34, 0x56])
+
+        return MockReader()
+
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("core.models.RFID.objects.get_or_create")
+    def test_notify_on_allowed_tag(self, mock_get, mock_notify):
+        reference = MagicMock(value="https://example.com")
+        tag = MagicMock(
+            label_id=1,
+            pk=1,
+            allowed=True,
+            color="B",
+            released=False,
+            reference=reference,
+        )
+        mock_get.return_value = (tag, False)
+
+        result = read_rfid(mfrc=self._mock_reader(), cleanup=False)
+        self.assertEqual(result["label_id"], 1)
+        self.assertEqual(result["kind"], RFID.CLASSIC)
+        self.assertEqual(result["reference"], "https://example.com")
+        self.assertEqual(mock_notify.call_count, 1)
+        mock_notify.assert_has_calls(
+            [call("RFID 1 OK", f"{result['rfid']} B")]
+        )
+
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("core.models.RFID.objects.get_or_create")
+    def test_notify_on_disallowed_tag(self, mock_get, mock_notify):
+        tag = MagicMock(
+            label_id=2,
+            pk=2,
+            allowed=False,
+            color="B",
+            released=False,
+            reference=None,
+        )
+        mock_get.return_value = (tag, False)
+
+        result = read_rfid(mfrc=self._mock_reader(), cleanup=False)
+        self.assertEqual(result["kind"], RFID.CLASSIC)
+        self.assertEqual(mock_notify.call_count, 1)
+        mock_notify.assert_has_calls(
+            [call("RFID 2 BAD", f"{result['rfid']} B")]
+        )
+
+
+class CardTypeDetectionTests(TestCase):
+    def _mock_ntag_reader(self):
+        class MockReader:
+            MI_OK = 1
+            PICC_REQIDL = 0
+
+            def MFRC522_Request(self, _):
+                return (self.MI_OK, None)
+
+            def MFRC522_Anticoll(self):
+                return (
+                    self.MI_OK,
+                    [0x04, 0xD3, 0x2A, 0x1B, 0x5F, 0x23, 0x19],
+                )
+
+        return MockReader()
+
+    @patch("ocpp.rfid.reader.notify_async")
+    def test_detects_ntag215(self, _mock_notify):
+        result = read_rfid(mfrc=self._mock_ntag_reader(), cleanup=False)
+        self.assertEqual(result["kind"], RFID.NTAG215)
+
+
+class RFIDLastSeenTests(TestCase):
+    def _mock_reader(self):
+        class MockReader:
+            MI_OK = 1
+            PICC_REQIDL = 0
+
+            def MFRC522_Request(self, _):
+                return (self.MI_OK, None)
+
+            def MFRC522_Anticoll(self):
+                return (self.MI_OK, [0xAB, 0xCD, 0x12, 0x34])
+
+        return MockReader()
+
+    @patch("ocpp.rfid.reader.notify_async")
+    def test_last_seen_updated_on_read(self, _mock_notify):
+        tag = RFID.objects.create(rfid="ABCD1234")
+        result = read_rfid(mfrc=self._mock_reader(), cleanup=False)
+        tag.refresh_from_db()
+        self.assertIsNotNone(tag.last_seen_on)
+        self.assertEqual(result["kind"], RFID.CLASSIC)
+
+
+class RestartViewTests(SimpleTestCase):
+    @patch("config.middleware.Node.get_local", return_value=None)
+    @patch("config.middleware.get_site")
+    @patch("ocpp.rfid.views.restart_sources", return_value={"status": "restarted"})
+    def test_restart_endpoint(self, mock_restart, mock_site, mock_node):
+        resp = self.client.post(reverse("rfid-scan-restart"))
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(resp.json(), {"status": "restarted"})
+        mock_restart.assert_called_once()
+
+
+class ScanTestViewTests(SimpleTestCase):
+    @patch("config.middleware.Node.get_local", return_value=None)
+    @patch("config.middleware.get_site")
+    @patch("ocpp.rfid.views.test_sources", return_value={"irq_pin": 7})
+    def test_scan_test_success(self, mock_test, mock_site, mock_node):
+        resp = self.client.get(reverse("rfid-scan-test"))
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(resp.json(), {"irq_pin": 7})
+
+    @patch("config.middleware.Node.get_local", return_value=None)
+    @patch("config.middleware.get_site")
+    @patch(
+        "ocpp.rfid.views.test_sources",
+        return_value={"error": "no scanner detected"},
+    )
+    def test_scan_test_error(self, mock_test, mock_site, mock_node):
+        resp = self.client.get(reverse("rfid-scan-test"))
+        self.assertEqual(resp.status_code, 500)
+        self.assertEqual(resp.json(), {"error": "no scanner detected"})
+
+
+class RFIDLandingTests(TestCase):
+    def test_scanner_view_registered_as_landing(self):
+        role, _ = NodeRole.objects.get_or_create(name="Terminal")
+        Node.objects.update_or_create(
+            mac_address=Node.get_current_mac(),
+            defaults={"hostname": "localhost", "address": "127.0.0.1", "role": role},
+        )
+        Site.objects.update_or_create(
+            id=1, defaults={"domain": "testserver", "name": ""}
+        )
+        app = Application.objects.create(name="Ocpp")
+        module = Module.objects.create(node_role=role, application=app, path="/ocpp/")
+        module.create_landings()
+        self.assertTrue(
+            module.landings.filter(path="/ocpp/rfid/").exists()
+        )
+
+class ScannerTemplateTests(TestCase):
+    def setUp(self):
+        self.url = reverse("rfid-reader")
+
+    def test_configure_link_for_staff(self):
+        User = get_user_model()
+        staff = User.objects.create_user("staff", password="pwd", is_staff=True)
+        self.client.force_login(staff)
+        resp = self.client.get(self.url)
+        self.assertContains(resp, 'id="rfid-configure"')
+
+    def test_no_link_for_anonymous(self):
+        resp = self.client.get(self.url)
+        self.assertNotContains(resp, 'id="rfid-configure"')
+
+    def test_advanced_fields_for_staff(self):
+        User = get_user_model()
+        staff = User.objects.create_user("staff2", password="pwd", is_staff=True)
+        self.client.force_login(staff)
+        resp = self.client.get(self.url)
+        self.assertContains(resp, 'id="rfid-kind"')
+        self.assertContains(resp, 'id="rfid-rfid"')
+        self.assertContains(resp, 'id="rfid-released"')
+        self.assertContains(resp, 'id="rfid-reference"')
+
+    def test_basic_fields_for_public(self):
+        resp = self.client.get(self.url)
+        self.assertContains(resp, 'id="rfid-kind"')
+        self.assertNotContains(resp, 'id="rfid-rfid"')
+        self.assertNotContains(resp, 'id="rfid-released"')
+        self.assertNotContains(resp, 'id="rfid-reference"')
+
+    def test_deep_read_button_for_staff(self):
+        User = get_user_model()
+        staff = User.objects.create_user("staff3", password="pwd", is_staff=True)
+        self.client.force_login(staff)
+        resp = self.client.get(self.url)
+        self.assertContains(resp, 'id="rfid-deep-read"')
+
+    def test_no_deep_read_button_for_public(self):
+        resp = self.client.get(self.url)
+        self.assertNotContains(resp, 'id="rfid-deep-read"')
+
+
+class ReaderPollingTests(SimpleTestCase):
+    def _mock_reader_no_tag(self):
+        class MockReader:
+            MI_OK = 1
+            PICC_REQIDL = 0
+
+            def MFRC522_Request(self, _):
+                return (0, None)
+
+        return MockReader()
+
+    @patch("ocpp.rfid.reader.time.sleep")
+    def test_poll_interval_used(self, mock_sleep):
+        read_rfid(
+            mfrc=self._mock_reader_no_tag(),
+            cleanup=False,
+            timeout=0.002,
+            poll_interval=0.001,
+        )
+        mock_sleep.assert_called_with(0.001)
+
+    @patch("ocpp.rfid.reader.time.sleep")
+    def test_use_irq_skips_sleep(self, mock_sleep):
+        read_rfid(
+            mfrc=self._mock_reader_no_tag(),
+            cleanup=False,
+            timeout=0.002,
+            use_irq=True,
+        )
+        mock_sleep.assert_not_called()
+
+
+class DeepReadViewTests(TestCase):
+    @patch("config.middleware.Node.get_local", return_value=None)
+    @patch("config.middleware.get_site")
+    @patch("ocpp.rfid.views.enable_deep_read_mode", return_value={"status": "deep", "timeout": 60})
+    def test_enable_deep_read(self, mock_enable, mock_site, mock_node):
+        User = get_user_model()
+        staff = User.objects.create_user("staff4", password="pwd", is_staff=True)
+        self.client.force_login(staff)
+        resp = self.client.post(reverse("rfid-scan-deep"))
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(resp.json(), {"status": "deep", "timeout": 60})
+        mock_enable.assert_called_once()
+
+    def test_forbidden_for_anonymous(self):
+        resp = self.client.post(reverse("rfid-scan-deep"))
+        self.assertNotEqual(resp.status_code, 200)
+
+
+class DeepReadAuthTests(TestCase):
+    class MockReader:
+        MI_OK = 1
+        MI_ERR = 2
+        PICC_REQIDL = 0
+        PICC_AUTHENT1A = 0x60
+        PICC_AUTHENT1B = 0x61
+
+        def __init__(self):
+            self.auth_calls = []
+
+        def MFRC522_Request(self, _):
+            return (self.MI_OK, None)
+
+        def MFRC522_Anticoll(self):
+            return (self.MI_OK, [0xAA, 0xBB, 0xCC, 0xDD, 0xEE])
+
+        def MFRC522_Auth(self, mode, block, key, uid):
+            self.auth_calls.append(mode)
+            return self.MI_ERR if mode == self.PICC_AUTHENT1A else self.MI_OK
+
+        def MFRC522_Read(self, block):
+            return (self.MI_OK, [0] * 16)
+
+    @patch("core.notifications.notify_async")
+    @patch("core.models.RFID.objects.get_or_create")
+    def test_auth_tries_key_a_then_b(self, mock_get, mock_notify):
+        tag = MagicMock(
+            label_id=1,
+            pk=1,
+            allowed=True,
+            color="B",
+            released=False,
+            reference=None,
+        )
+        mock_get.return_value = (tag, False)
+        reader = self.MockReader()
+        enable_deep_read(60)
+        read_rfid(mfrc=reader, cleanup=False)
+        self.assertGreaterEqual(len(reader.auth_calls), 2)
+        self.assertEqual(reader.auth_calls[0], reader.PICC_AUTHENT1A)
+        self.assertEqual(reader.auth_calls[1], reader.PICC_AUTHENT1B)
+
+