arthexis 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

ocpp/tasks.py

@@ -1,11 +1,17 @@
 import logging
-from datetime import timedelta
+from datetime import date, datetime, time, timedelta
+from pathlib import Path
 
 from celery import shared_task
+from django.conf import settings
+from django.contrib.auth import get_user_model
 from django.utils import timezone
 from django.db.models import Q
 
-from .models import MeterValue
+from core import mailer
+from nodes.models import Node
+
+from .models import MeterValue, Transaction
 
 logger = logging.getLogger(__name__)
 
@@ -29,3 +35,151 @@ def purge_meter_values() -> int:
 
 # Backwards compatibility alias
 purge_meter_readings = purge_meter_values
+
+
+def _resolve_report_window() -> tuple[datetime, datetime, date]:
+    """Return the start/end datetimes for today's reporting window."""
+
+    current_tz = timezone.get_current_timezone()
+    today = timezone.localdate()
+    start = timezone.make_aware(datetime.combine(today, time.min), current_tz)
+    end = start + timedelta(days=1)
+    return start, end, today
+
+
+def _session_report_recipients() -> list[str]:
+    """Return the list of recipients for the daily session report."""
+
+    User = get_user_model()
+    recipients = list(
+        User.objects.filter(is_superuser=True)
+        .exclude(email="")
+        .values_list("email", flat=True)
+    )
+    if recipients:
+        return recipients
+
+    fallback = getattr(settings, "DEFAULT_FROM_EMAIL", "").strip()
+    return [fallback] if fallback else []
+
+
+def _format_duration(delta: timedelta | None) -> str:
+    """Return a compact string for ``delta`` or ``"in progress"``."""
+
+    if delta is None:
+        return "in progress"
+    total_seconds = int(delta.total_seconds())
+    hours, remainder = divmod(total_seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    parts: list[str] = []
+    if hours:
+        parts.append(f"{hours}h")
+    if minutes:
+        parts.append(f"{minutes}m")
+    if seconds or not parts:
+        parts.append(f"{seconds}s")
+    return " ".join(parts)
+
+
+def _format_charger(transaction: Transaction) -> str:
+    """Return a human friendly label for ``transaction``'s charger."""
+
+    charger = transaction.charger
+    if charger is None:
+        return "Unknown charger"
+    for attr in ("display_name", "name", "charger_id"):
+        value = getattr(charger, attr, "")
+        if value:
+            return str(value)
+    return str(charger)
+
+
+@shared_task
+def send_daily_session_report() -> int:
+    """Send a summary of today's OCPP sessions when email is available."""
+
+    if not mailer.can_send_email():
+        logger.info("Skipping OCPP session report: email not configured")
+        return 0
+
+    celery_lock = Path(settings.BASE_DIR) / "locks" / "celery.lck"
+    if not celery_lock.exists():
+        logger.info("Skipping OCPP session report: celery feature disabled")
+        return 0
+
+    recipients = _session_report_recipients()
+    if not recipients:
+        logger.info("Skipping OCPP session report: no recipients found")
+        return 0
+
+    start, end, today = _resolve_report_window()
+    transactions = list(
+        Transaction.objects.filter(start_time__gte=start, start_time__lt=end)
+        .select_related("charger", "account")
+        .order_by("start_time")
+    )
+    if not transactions:
+        logger.info("No OCPP sessions recorded on %s", today.isoformat())
+        return 0
+
+    total_energy = sum(transaction.kw for transaction in transactions)
+    lines = [
+        f"OCPP session report for {today.isoformat()}",
+        "",
+        f"Total sessions: {len(transactions)}",
+        f"Total energy: {total_energy:.2f} kWh",
+        "",
+    ]
+
+    for index, transaction in enumerate(transactions, start=1):
+        start_local = timezone.localtime(transaction.start_time)
+        stop_local = (
+            timezone.localtime(transaction.stop_time)
+            if transaction.stop_time
+            else None
+        )
+        duration = _format_duration(
+            stop_local - start_local if stop_local else None
+        )
+        account = transaction.account.name if transaction.account else "N/A"
+        connector = (
+            f"Connector {transaction.connector_id}" if transaction.connector_id else None
+        )
+        lines.append(f"{index}. {_format_charger(transaction)}")
+        lines.append(f"   Account: {account}")
+        if transaction.rfid:
+            lines.append(f"   RFID: {transaction.rfid}")
+        if connector:
+            lines.append(f"   {connector}")
+        lines.append(
+            "   Start: "
+            f"{start_local.strftime('%H:%M:%S %Z')}"
+        )
+        if stop_local:
+            lines.append(
+                "   Stop: "
+                f"{stop_local.strftime('%H:%M:%S %Z')} ({duration})"
+            )
+        else:
+            lines.append("   Stop: in progress")
+        lines.append(f"   Energy: {transaction.kw:.2f} kWh")
+        lines.append("")
+
+    subject = f"OCPP session report for {today.isoformat()}"
+    body = "\n".join(lines).strip()
+
+    node = Node.get_local()
+    if node is not None:
+        node.send_mail(subject, body, recipients)
+    else:
+        mailer.send(
+            subject,
+            body,
+            recipients,
+            getattr(settings, "DEFAULT_FROM_EMAIL", None),
+        )
+
+    logger.info(
+        "Sent OCPP session report for %s to %s", today.isoformat(), ", ".join(recipients)
+    )
+    return len(transactions)

ocpp/test_rfid.py

@@ -1,6 +1,7 @@
 import io
 import json
 import os
+import subprocess
 import sys
 import types
 from datetime import datetime, timezone as dt_timezone
@@ -394,10 +395,11 @@ class ValidateRfidValueTests(SimpleTestCase):
 
     @patch("ocpp.rfid.reader.timezone.now")
     @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.subprocess.Popen")
     @patch("ocpp.rfid.reader.subprocess.run")
     @patch("ocpp.rfid.reader.RFID.register_scan")
     def test_external_command_success(
-        self, mock_register, mock_run, mock_notify, mock_now
+        self, mock_register, mock_run, mock_popen, mock_notify, mock_now
     ):
         fake_now = object()
         mock_now.return_value = fake_now
@@ -414,6 +416,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         mock_run.return_value = types.SimpleNamespace(
             returncode=0, stdout="ok\n", stderr=""
         )
+        mock_popen.return_value = object()
 
         result = validate_rfid_value("abcd1234")
 
@@ -424,6 +427,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         env = run_kwargs.get("env", {})
         self.assertEqual(env.get("RFID_VALUE"), "ABCD1234")
         self.assertEqual(env.get("RFID_LABEL_ID"), "1")
+        mock_popen.assert_not_called()
         mock_notify.assert_called_once_with("RFID 1 OK", "ABCD1234 B")
         tag.save.assert_called_once_with(update_fields=["last_seen_on"])
         self.assertTrue(result["allowed"])
@@ -436,10 +440,11 @@ class ValidateRfidValueTests(SimpleTestCase):
 
     @patch("ocpp.rfid.reader.timezone.now")
     @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.subprocess.Popen")
     @patch("ocpp.rfid.reader.subprocess.run")
     @patch("ocpp.rfid.reader.RFID.register_scan")
     def test_external_command_failure_blocks_tag(
-        self, mock_register, mock_run, mock_notify, mock_now
+        self, mock_register, mock_run, mock_popen, mock_notify, mock_now
     ):
         fake_now = object()
         mock_now.return_value = fake_now
@@ -456,6 +461,7 @@ class ValidateRfidValueTests(SimpleTestCase):
         mock_run.return_value = types.SimpleNamespace(
             returncode=1, stdout="", stderr="failure"
         )
+        mock_popen.return_value = object()
 
         result = validate_rfid_value("ffff")
 
@@ -469,6 +475,42 @@ class ValidateRfidValueTests(SimpleTestCase):
         self.assertEqual(output.get("stdout"), "")
         self.assertEqual(output.get("stderr"), "failure")
         self.assertEqual(output.get("error"), "")
+        mock_popen.assert_not_called()
+
+    @patch("ocpp.rfid.reader.timezone.now")
+    @patch("ocpp.rfid.reader.notify_async")
+    @patch("ocpp.rfid.reader.subprocess.Popen")
+    @patch("ocpp.rfid.reader.subprocess.run")
+    @patch("ocpp.rfid.reader.RFID.register_scan")
+    def test_post_command_runs_after_success(
+        self, mock_register, mock_run, mock_popen, mock_notify, mock_now
+    ):
+        fake_now = object()
+        mock_now.return_value = fake_now
+        tag = MagicMock()
+        tag.pk = 3
+        tag.label_id = 3
+        tag.allowed = True
+        tag.external_command = ""
+        tag.post_auth_command = "echo done"
+        tag.color = "B"
+        tag.released = False
+        tag.reference = None
+        tag.kind = RFID.CLASSIC
+        mock_register.return_value = (tag, False)
+        result = validate_rfid_value("abcdef")
+
+        mock_run.assert_not_called()
+        mock_popen.assert_called_once()
+        args, kwargs = mock_popen.call_args
+        self.assertEqual(args[0], "echo done")
+        env = kwargs.get("env", {})
+        self.assertEqual(env.get("RFID_VALUE"), "ABCDEF")
+        self.assertEqual(env.get("RFID_LABEL_ID"), "3")
+        self.assertIs(kwargs.get("stdout"), subprocess.DEVNULL)
+        self.assertIs(kwargs.get("stderr"), subprocess.DEVNULL)
+        self.assertTrue(result["allowed"])
+        mock_notify.assert_called_once_with("RFID 3 OK", "ABCDEF B")
 
 
 class CardTypeDetectionTests(TestCase):

ocpp/tests.py

@@ -40,6 +40,7 @@ from django.test import (
     TestCase,
     override_settings,
 )
+from django.conf import settings
 from unittest import skip
 from contextlib import suppress
 from types import SimpleNamespace
@@ -79,7 +80,7 @@ from .simulator import SimulatorConfig, ChargePointSimulator
 from .evcs import simulate, SimulatorState, _simulators
 import re
 from datetime import datetime, timedelta, timezone as dt_timezone
-from .tasks import purge_meter_readings
+from .tasks import purge_meter_readings, send_daily_session_report
 from django.db import close_old_connections
 from django.db.utils import OperationalError
 from urllib.parse import unquote, urlparse
@@ -2981,6 +2982,46 @@ class SimulatorAdminTests(TransactionTestCase):
 
         await communicator.disconnect()
 
+    async def test_heartbeat_refreshes_aggregate_after_connector_status(self):
+        store.ip_connections.clear()
+        store.connections.clear()
+        await database_sync_to_async(Charger.objects.create)(charger_id="HBAGG")
+        communicator = WebsocketCommunicator(application, "/HBAGG/")
+        connect_result = await communicator.connect()
+        self.assertTrue(connect_result[0], connect_result)
+
+        status_payload = {
+            "connectorId": 2,
+            "status": "Faulted",
+            "errorCode": "ReaderFailure",
+        }
+        await communicator.send_json_to(
+            [2, "1", "StatusNotification", status_payload]
+        )
+        await communicator.receive_json_from()
+
+        aggregate = await database_sync_to_async(Charger.objects.get)(
+            charger_id="HBAGG", connector_id=None
+        )
+        connector = await database_sync_to_async(Charger.objects.get)(
+            charger_id="HBAGG", connector_id=2
+        )
+        previous_heartbeat = aggregate.last_heartbeat
+
+        await communicator.send_json_to([2, "2", "Heartbeat", {}])
+        await communicator.receive_json_from()
+
+        await database_sync_to_async(aggregate.refresh_from_db)()
+        await database_sync_to_async(connector.refresh_from_db)()
+
+        self.assertIsNotNone(aggregate.last_heartbeat)
+        if previous_heartbeat:
+            self.assertNotEqual(aggregate.last_heartbeat, previous_heartbeat)
+        if connector.last_heartbeat:
+            self.assertNotEqual(aggregate.last_heartbeat, connector.last_heartbeat)
+
+        await communicator.disconnect()
+
 
 class ChargerLocationTests(TestCase):
     def test_lat_lon_fields_saved(self):
@@ -3676,6 +3717,75 @@ class PurgeMeterReadingsTaskTests(TestCase):
         self.assertTrue(MeterReading.objects.filter(pk=reading.pk).exists())
 
 
+class DailySessionReportTaskTests(TestCase):
+    def setUp(self):
+        super().setUp()
+        self.locks_dir = Path(settings.BASE_DIR) / "locks"
+        self.locks_dir.mkdir(parents=True, exist_ok=True)
+        self.celery_lock = self.locks_dir / "celery.lck"
+        self.celery_lock.write_text("")
+        self.addCleanup(self._cleanup_lock)
+
+    def _cleanup_lock(self):
+        try:
+            self.celery_lock.unlink()
+        except FileNotFoundError:
+            pass
+
+    def test_report_sends_email_when_sessions_exist(self):
+        User = get_user_model()
+        User.objects.create_superuser(
+            username="report-admin",
+            email="report-admin@example.com",
+            password="pw",
+        )
+        charger = Charger.objects.create(charger_id="RPT1", display_name="Pod 1")
+        start = timezone.now().replace(hour=10, minute=0, second=0, microsecond=0)
+        Transaction.objects.create(
+            charger=charger,
+            start_time=start,
+            stop_time=start + timedelta(hours=1),
+            meter_start=0,
+            meter_stop=2500,
+            connector_id=2,
+            rfid="AA11",
+        )
+
+        with patch("core.mailer.can_send_email", return_value=True), patch(
+            "core.mailer.send"
+        ) as mock_send:
+            count = send_daily_session_report()
+
+        self.assertEqual(count, 1)
+        self.assertTrue(mock_send.called)
+        args, _kwargs = mock_send.call_args
+        self.assertIn("OCPP session report", args[0])
+        self.assertIn("Pod 1", args[1])
+        self.assertIn("report-admin@example.com", args[2])
+        self.assertGreaterEqual(len(args[2]), 1)
+
+    def test_report_skips_when_no_sessions(self):
+        with patch("core.mailer.can_send_email", return_value=True), patch(
+            "core.mailer.send"
+        ) as mock_send:
+            count = send_daily_session_report()
+
+        self.assertEqual(count, 0)
+        mock_send.assert_not_called()
+
+    def test_report_skips_without_celery_feature(self):
+        if self.celery_lock.exists():
+            self.celery_lock.unlink()
+
+        with patch("core.mailer.can_send_email", return_value=True), patch(
+            "core.mailer.send"
+        ) as mock_send:
+            count = send_daily_session_report()
+
+        self.assertEqual(count, 0)
+        mock_send.assert_not_called()
+
+
 class TransactionKwTests(TestCase):
     def test_kw_sums_meter_readings(self):
         charger = Charger.objects.create(charger_id="SUM1")

pages/admin.py

@@ -18,11 +18,14 @@ import ipaddress
 from django.apps import apps as django_apps
 from django.conf import settings
 from django.utils.translation import gettext_lazy as _, ngettext
+from django.core.management import CommandError, call_command
 
-from nodes.models import Node
+from nodes.models import Node, NodeRole
 from nodes.utils import capture_screenshot, save_screenshot
 
 from .forms import UserManualAdminForm
+from .module_defaults import reload_default_modules as restore_default_modules
+from .utils import landing_leads_supported
 
 from .models import (
     SiteBadge,
@@ -107,6 +110,49 @@ class SiteAdmin(DjangoSiteAdmin):
                     messages.INFO,
                 )
 
+    def _reload_site_fixtures(self, request):
+        fixtures_dir = Path(settings.BASE_DIR) / "core" / "fixtures"
+        fixture_paths = sorted(fixtures_dir.glob("references__00_site_*.json"))
+        sigil_fixture = fixtures_dir / "sigil_roots__site.json"
+        if sigil_fixture.exists():
+            fixture_paths.append(sigil_fixture)
+
+        if not fixture_paths:
+            self.message_user(request, _("No site fixtures found."), messages.WARNING)
+            return None
+
+        loaded = 0
+        for path in fixture_paths:
+            try:
+                call_command("loaddata", str(path), verbosity=0)
+            except CommandError as exc:
+                self.message_user(
+                    request,
+                    _("%(fixture)s: %(error)s")
+                    % {"fixture": path.name, "error": exc},
+                    messages.ERROR,
+                )
+            else:
+                loaded += 1
+
+        if loaded:
+            message = ngettext(
+                "Reloaded %(count)d site fixture.",
+                "Reloaded %(count)d site fixtures.",
+                loaded,
+            ) % {"count": loaded}
+            self.message_user(request, message, messages.SUCCESS)
+
+        return None
+
+    def reload_site_fixtures(self, request):
+        if request.method != "POST":
+            return redirect("..")
+
+        self._reload_site_fixtures(request)
+
+        return redirect("..")
+
     def get_urls(self):
         urls = super().get_urls()
         custom = [
@@ -114,7 +160,12 @@ class SiteAdmin(DjangoSiteAdmin):
                 "register-current/",
                 self.admin_site.admin_view(self.register_current),
                 name="pages_siteproxy_register_current",
-            )
+            ),
+            path(
+                "reload-site-fixtures/",
+                self.admin_site.admin_view(self.reload_site_fixtures),
+                name="pages_siteproxy_reload_site_fixtures",
+            ),
         ]
         return custom + urls
 
@@ -179,16 +230,118 @@ class ApplicationAdmin(EntityModelAdmin):
 class LandingInline(admin.TabularInline):
     model = Landing
     extra = 0
-    fields = ("path", "label", "enabled", "description")
+    fields = ("path", "label", "enabled")
+    show_change_link = True
+
+
+@admin.register(Landing)
+class LandingAdmin(EntityModelAdmin):
+    list_display = ("label", "path", "module", "enabled")
+    list_filter = ("enabled", "module__node_role", "module__application")
+    search_fields = (
+        "label",
+        "path",
+        "description",
+        "module__path",
+        "module__application__name",
+        "module__node_role__name",
+    )
+    fields = ("module", "path", "label", "enabled", "description")
+    list_select_related = ("module", "module__application", "module__node_role")
 
 
 @admin.register(Module)
 class ModuleAdmin(EntityModelAdmin):
+    change_list_template = "admin/pages/module/change_list.html"
     list_display = ("application", "node_role", "path", "menu", "is_default")
     list_filter = ("node_role", "application")
     fields = ("node_role", "application", "path", "menu", "is_default", "favicon")
     inlines = [LandingInline]
 
+    def get_urls(self):
+        urls = super().get_urls()
+        custom = [
+            path(
+                "reload-default-modules/",
+                self.admin_site.admin_view(self.reload_default_modules_view),
+                name="pages_module_reload_default_modules",
+            ),
+        ]
+        return custom + urls
+
+    def reload_default_modules_view(self, request):
+        if request.method != "POST":
+            return redirect("..")
+
+        summary = restore_default_modules(Application, Module, Landing, NodeRole)
+
+        if summary.roles_processed == 0:
+            self.message_user(
+                request,
+                _("No default modules were reloaded because the required node roles are missing."),
+                messages.WARNING,
+            )
+        elif summary.has_changes:
+            parts: list[str] = []
+            if summary.modules_created:
+                parts.append(
+                    ngettext(
+                        "%(count)d module created",
+                        "%(count)d modules created",
+                        summary.modules_created,
+                    )
+                    % {"count": summary.modules_created}
+                )
+            if summary.modules_updated:
+                parts.append(
+                    ngettext(
+                        "%(count)d module updated",
+                        "%(count)d modules updated",
+                        summary.modules_updated,
+                    )
+                    % {"count": summary.modules_updated}
+                )
+            if summary.landings_created:
+                parts.append(
+                    ngettext(
+                        "%(count)d landing created",
+                        "%(count)d landings created",
+                        summary.landings_created,
+                    )
+                    % {"count": summary.landings_created}
+                )
+            if summary.landings_updated:
+                parts.append(
+                    ngettext(
+                        "%(count)d landing updated",
+                        "%(count)d landings updated",
+                        summary.landings_updated,
+                    )
+                    % {"count": summary.landings_updated}
+                )
+
+            details = "; ".join(parts)
+            if details:
+                message = _(
+                    "Reloaded default modules for %(roles)d role(s). %(details)s."
+                ) % {"roles": summary.roles_processed, "details": details}
+            else:
+                message = _(
+                    "Reloaded default modules for %(roles)d role(s)."
+                ) % {"roles": summary.roles_processed}
+            self.message_user(request, message, messages.SUCCESS)
+        else:
+            self.message_user(
+                request,
+                _(
+                    "Default modules are already up to date for %(roles)d role(s)."
+                )
+                % {"roles": summary.roles_processed},
+                messages.INFO,
+            )
+
+        return redirect("..")
+
 
 @admin.register(LandingLead)
 class LandingLeadAdmin(EntityModelAdmin):
@@ -237,6 +390,17 @@ class LandingLeadAdmin(EntityModelAdmin):
     ordering = ("-created_on",)
     date_hierarchy = "created_on"
 
+    def changelist_view(self, request, extra_context=None):
+        if not landing_leads_supported():
+            self.message_user(
+                request,
+                _(
+                    "Landing leads are not being recorded because Celery is not running on this node."
+                ),
+                messages.WARNING,
+            )
+        return super().changelist_view(request, extra_context=extra_context)
+
     @admin.display(description=_("Landing"), ordering="landing__label")
     def landing_label(self, obj):
         return obj.landing.label
@@ -461,13 +625,22 @@ class UserStoryAdmin(EntityModelAdmin):
         "name",
         "rating",
         "path",
+        "status",
         "submitted_at",
         "github_issue_display",
         "take_screenshot",
         "owner",
+        "assign_to",
+    )
+    list_filter = ("rating", "status", "submitted_at", "take_screenshot")
+    search_fields = (
+        "name",
+        "comments",
+        "path",
+        "referer",
+        "github_issue_url",
+        "ip_address",
     )
-    list_filter = ("rating", "submitted_at", "take_screenshot")
-    search_fields = ("name", "comments", "path", "github_issue_url")
     readonly_fields = (
         "name",
         "rating",
@@ -476,6 +649,10 @@ class UserStoryAdmin(EntityModelAdmin):
         "path",
         "user",
         "owner",
+        "referer",
+        "user_agent",
+        "ip_address",
+        "created_on",
         "submitted_at",
         "github_issue_number",
         "github_issue_url",
@@ -489,6 +666,12 @@ class UserStoryAdmin(EntityModelAdmin):
         "path",
         "user",
         "owner",
+        "status",
+        "assign_to",
+        "referer",
+        "user_agent",
+        "ip_address",
+        "created_on",
         "submitted_at",
         "github_issue_number",
         "github_issue_url",