arthexis 0.1.22__py3-none-any.whl → 0.1.24__py3-none-any.whl

core/release.py

@@ -520,11 +520,6 @@ def build(
         if not version_path.exists():
             raise ReleaseError("VERSION file not found")
         version = version_path.read_text().strip()
-        if bump:
-            major, minor, patch = map(int, version.split("."))
-            patch += 1
-            version = f"{major}.{minor}.{patch}"
-            version_path.write_text(version + "\n")
     else:
         # Ensure the VERSION file reflects the provided release version
         if version_path.parent != Path("."):

core/tasks.py

@@ -405,3 +405,28 @@ def run_client_report_schedule(schedule_id: int) -> None:
     except Exception:
         logger.exception("ClientReportSchedule %s failed", schedule_id)
         raise
+
+
+@shared_task
+def ensure_recurring_client_reports() -> None:
+    """Ensure scheduled consumer reports run for the current period."""
+
+    from core.models import ClientReportSchedule
+
+    reference = timezone.localdate()
+    schedules = ClientReportSchedule.objects.filter(
+        periodicity__in=[
+            ClientReportSchedule.PERIODICITY_DAILY,
+            ClientReportSchedule.PERIODICITY_WEEKLY,
+            ClientReportSchedule.PERIODICITY_MONTHLY,
+        ]
+    ).prefetch_related("chargers")
+
+    for schedule in schedules:
+        try:
+            schedule.generate_missing_reports(reference=reference)
+        except Exception:
+            logger.exception(
+                "Automatic consumer report generation failed for schedule %s",
+                schedule.pk,
+            )

core/tests.py

@@ -2138,6 +2138,25 @@ class PackageReleaseCurrentTests(TestCase):
         self.package.save()
         self.assertFalse(self.release.is_current)
 
+    def test_is_current_false_when_version_has_plus(self):
+        self.version_path.write_text("1.0.0+")
+        self.assertFalse(self.release.is_current)
+
+
+class PackageReleaseRevisionTests(TestCase):
+    def setUp(self):
+        self.package = Package.objects.get(name="arthexis")
+        self.release = PackageRelease.objects.create(
+            package=self.package,
+            version="1.0.0",
+            revision="abcdef123456",
+        )
+
+    def test_matches_revision_ignores_plus_suffix(self):
+        self.assertTrue(
+            PackageRelease.matches_revision("1.0.0+", "abcdef123456")
+        )
+
     def test_is_current_false_when_version_differs(self):
         self.release.version = "2.0.0"
         self.release.save()
@@ -2188,13 +2207,22 @@ class PackageAdminPrepareNextReleaseTests(TestCase):
 
     def test_prepare_next_release_active_creates_release(self):
         PackageRelease.all_objects.filter(package=self.package).delete()
-        request = self.factory.get("/admin/core/package/prepare-next-release/")
+        request = self.factory.post("/admin/core/package/prepare-next-release/")
         response = self.admin.prepare_next_release_active(request)
         self.assertEqual(response.status_code, 302)
         self.assertEqual(
             PackageRelease.all_objects.filter(package=self.package).count(), 1
         )
 
+    def test_prepare_next_release_active_get_creates_release(self):
+        PackageRelease.all_objects.filter(package=self.package).delete()
+        request = self.factory.get("/admin/core/package/prepare-next-release/")
+        response = self.admin.prepare_next_release_active(request)
+        self.assertEqual(response.status_code, 302)
+        self.assertTrue(
+            PackageRelease.all_objects.filter(package=self.package).exists()
+        )
+
 
 class PackageAdminChangeViewTests(TestCase):
     def setUp(self):

core/user_data.py

@@ -201,9 +201,49 @@ def dump_user_fixture(instance, user=None) -> None:
 
 def delete_user_fixture(instance, user=None) -> None:
     target_user = user or _resolve_fixture_user(instance)
-    if target_user is None:
+    filename = (
+        f"{instance._meta.app_label}_{instance._meta.model_name}_{instance.pk}.json"
+    )
+
+    def _remove_for_user(candidate) -> None:
+        if candidate is None:
+            return
+        base_path = Path(
+            getattr(candidate, "data_path", "") or Path(settings.BASE_DIR) / "data"
+        )
+        username = _username_for(candidate)
+        if not username:
+            return
+        user_dir = base_path / username
+        if user_dir.exists():
+            (user_dir / filename).unlink(missing_ok=True)
+
+    if target_user is not None:
+        _remove_for_user(target_user)
         return
-    _fixture_path(target_user, instance).unlink(missing_ok=True)
+
+    root = Path(settings.BASE_DIR) / "data"
+    if root.exists():
+        (root / filename).unlink(missing_ok=True)
+        for path in root.iterdir():
+            if path.is_dir():
+                (path / filename).unlink(missing_ok=True)
+
+    UserModel = get_user_model()
+    manager = getattr(UserModel, "all_objects", UserModel._default_manager)
+    for candidate in manager.all():
+        data_path = getattr(candidate, "data_path", "")
+        if not data_path:
+            continue
+        base_path = Path(data_path)
+        if not base_path.exists():
+            continue
+        username = _username_for(candidate)
+        if not username:
+            continue
+        user_dir = base_path / username
+        if user_dir.exists():
+            (user_dir / filename).unlink(missing_ok=True)
 
 
 def _mark_fixture_user_data(path: Path) -> None:

core/views.py

@@ -690,16 +690,17 @@ def _ensure_origin_main_unchanged(log_path: Path) -> None:
 def _next_patch_version(version: str) -> str:
     from packaging.version import InvalidVersion, Version
 
+    cleaned = version.rstrip("+")
     try:
-        parsed = Version(version)
+        parsed = Version(cleaned)
     except InvalidVersion:
-        parts = version.split(".")
+        parts = cleaned.split(".") if cleaned else []
         for index in range(len(parts) - 1, -1, -1):
             segment = parts[index]
             if segment.isdigit():
                 parts[index] = str(int(segment) + 1)
                 return ".".join(parts)
-        return version
+        return cleaned or version
     return f"{parsed.major}.{parsed.minor}.{parsed.micro + 1}"
 
 
@@ -768,7 +769,9 @@ def _sync_release_with_revision(release: PackageRelease) -> tuple[bool, str]:
     version_path = Path("VERSION")
     if version_path.exists():
         try:
-            repo_version = Version(version_path.read_text(encoding="utf-8").strip())
+            raw_version = version_path.read_text(encoding="utf-8").strip()
+            cleaned_version = raw_version.rstrip("+") or "0.0.0"
+            repo_version = Version(cleaned_version)
         except InvalidVersion:
             repo_version = None
 
@@ -935,7 +938,7 @@ def _refresh_changelog_once(ctx, log_path: Path) -> None:
     ctx["changelog_refreshed"] = True
 
 
-def _step_check_todos(release, ctx, log_path: Path) -> None:
+def _step_check_todos(release, ctx, log_path: Path, *, user=None) -> None:
     _refresh_changelog_once(ctx, log_path)
 
     pending_qs = Todo.objects.filter(is_deleted=False, done_on__isnull=True)
@@ -975,7 +978,7 @@ def _step_check_todos(release, ctx, log_path: Path) -> None:
     ctx["todos_ack"] = True
 
 
-def _step_check_version(release, ctx, log_path: Path) -> None:
+def _step_check_version(release, ctx, log_path: Path, *, user=None) -> None:
     from . import release as release_utils
     from packaging.version import InvalidVersion, Version
 
@@ -1110,10 +1113,12 @@ def _step_check_version(release, ctx, log_path: Path) -> None:
     version_path = Path("VERSION")
     if version_path.exists():
         current = version_path.read_text(encoding="utf-8").strip()
-        if current and Version(release.version) < Version(current):
-            raise Exception(
-                f"Version {release.version} is older than existing {current}"
-            )
+        if current:
+            current_clean = current.rstrip("+") or "0.0.0"
+            if Version(release.version) < Version(current_clean):
+                raise Exception(
+                    f"Version {release.version} is older than existing {current}"
+                )
 
     _append_log(log_path, f"Checking if version {release.version} exists on PyPI")
     if release_utils.network_available():
@@ -1163,17 +1168,17 @@ def _step_check_version(release, ctx, log_path: Path) -> None:
         _append_log(log_path, "Network unavailable, skipping PyPI check")
 
 
-def _step_handle_migrations(release, ctx, log_path: Path) -> None:
+def _step_handle_migrations(release, ctx, log_path: Path, *, user=None) -> None:
     _append_log(log_path, "Freeze, squash and approve migrations")
     _append_log(log_path, "Migration review acknowledged (manual step)")
 
 
-def _step_changelog_docs(release, ctx, log_path: Path) -> None:
+def _step_changelog_docs(release, ctx, log_path: Path, *, user=None) -> None:
     _append_log(log_path, "Compose CHANGELOG and documentation")
     _append_log(log_path, "CHANGELOG and documentation review recorded")
 
 
-def _step_pre_release_actions(release, ctx, log_path: Path) -> None:
+def _step_pre_release_actions(release, ctx, log_path: Path, *, user=None) -> None:
     _append_log(log_path, "Execute pre-release actions")
     if ctx.get("dry_run"):
         _append_log(log_path, "Dry run: skipping pre-release actions")
@@ -1249,12 +1254,12 @@ def _step_pre_release_actions(release, ctx, log_path: Path) -> None:
     _append_log(log_path, "Pre-release actions complete")
 
 
-def _step_run_tests(release, ctx, log_path: Path) -> None:
+def _step_run_tests(release, ctx, log_path: Path, *, user=None) -> None:
     _append_log(log_path, "Complete test suite with --all flag")
     _append_log(log_path, "Test suite completion acknowledged")
 
 
-def _step_promote_build(release, ctx, log_path: Path) -> None:
+def _step_promote_build(release, ctx, log_path: Path, *, user=None) -> None:
     from . import release as release_utils
 
     _append_log(log_path, "Generating build files")
@@ -1266,7 +1271,7 @@ def _step_promote_build(release, ctx, log_path: Path) -> None:
         release_utils.promote(
             package=release.to_package(),
             version=release.version,
-            creds=release.to_credentials(),
+            creds=release.to_credentials(user=user),
         )
         _append_log(
             log_path,
@@ -1314,8 +1319,10 @@ def _step_promote_build(release, ctx, log_path: Path) -> None:
     _append_log(new_log, "Build complete")
 
 
-def _step_release_manager_approval(release, ctx, log_path: Path) -> None:
-    if release.to_credentials() is None:
+def _step_release_manager_approval(
+    release, ctx, log_path: Path, *, user=None
+) -> None:
+    if release.to_credentials(user=user) is None:
         ctx.pop("release_approval", None)
         if not ctx.get("approval_credentials_missing"):
             _append_log(log_path, "Release manager publishing credentials missing")
@@ -1349,14 +1356,14 @@ def _step_release_manager_approval(release, ctx, log_path: Path) -> None:
     raise ApprovalRequired()
 
 
-def _step_publish(release, ctx, log_path: Path) -> None:
+def _step_publish(release, ctx, log_path: Path, *, user=None) -> None:
     from . import release as release_utils
 
     if ctx.get("dry_run"):
         test_repository_url = os.environ.get(
             "PYPI_TEST_REPOSITORY_URL", "https://test.pypi.org/legacy/"
         )
-        test_creds = release.to_credentials()
+        test_creds = release.to_credentials(user=user)
         if not (test_creds and test_creds.has_auth()):
             test_creds = release_utils.Credentials(
                 token=os.environ.get("PYPI_TEST_API_TOKEN"),
@@ -1396,7 +1403,7 @@ def _step_publish(release, ctx, log_path: Path) -> None:
                 release_utils.build(
                     package=package,
                     version=release.version,
-                    creds=release.to_credentials(),
+                    creds=release.to_credentials(user=user),
                     dist=True,
                     tests=False,
                     twine=False,
@@ -1425,13 +1432,13 @@ def _step_publish(release, ctx, log_path: Path) -> None:
         release_utils.publish(
             package=release.to_package(),
             version=release.version,
-            creds=target.credentials or release.to_credentials(),
+            creds=target.credentials or release.to_credentials(user=user),
             repositories=[target],
         )
         _append_log(log_path, "Dry run: skipped release metadata updates")
         return
 
-    targets = release.build_publish_targets()
+    targets = release.build_publish_targets(user=user)
     repo_labels = []
     for target in targets:
         label = target.name
@@ -1450,7 +1457,7 @@ def _step_publish(release, ctx, log_path: Path) -> None:
         release_utils.publish(
             package=release.to_package(),
             version=release.version,
-            creds=release.to_credentials(),
+            creds=release.to_credentials(user=user),
             repositories=targets,
         )
     except release_utils.PostPublishWarning as warning:
@@ -1819,7 +1826,7 @@ def release_progress(request, pk: int, action: str):
         return redirect(request.path)
 
     manager = release.release_manager or release.package.release_manager
-    credentials_ready = bool(release.to_credentials())
+    credentials_ready = bool(release.to_credentials(user=request.user))
     if credentials_ready and ctx.get("approval_credentials_missing"):
         ctx.pop("approval_credentials_missing", None)
 
@@ -1990,7 +1997,7 @@ def release_progress(request, pk: int, action: str):
         if to_run == step_count:
             name, func = steps[to_run]
             try:
-                func(release, ctx, log_path)
+                func(release, ctx, log_path, user=request.user)
             except PendingTodos:
                 pass
             except ApprovalRequired:

nodes/admin.py

@@ -19,7 +19,7 @@ from django.utils.html import format_html, format_html_join
 from django.utils.translation import gettext_lazy as _
 from pathlib import Path
 from types import SimpleNamespace
-from urllib.parse import urlparse, urlsplit, urlunsplit
+from urllib.parse import urljoin, urlparse, urlsplit, urlunsplit
 import base64
 import ipaddress
 import json
@@ -60,6 +60,7 @@ from .models import (
 )
 from . import dns as dns_utils
 from core.models import RFID
+from ocpp.models import Charger, Location
 from core.user_data import EntityModelAdmin
 
 
@@ -237,7 +238,6 @@ class NodeAdmin(EntityModelAdmin):
         "relation",
         "last_seen",
         "visit_link",
-        "proxy_link",
     )
     search_fields = ("hostname", "address", "mac_address")
     change_list_template = "admin/nodes/node/change_list.html"
@@ -287,6 +287,7 @@ class NodeAdmin(EntityModelAdmin):
         "register_visitor",
         "run_task",
         "take_screenshots",
+        "discover_charge_points",
         "import_rfids_from_selected",
         "export_rfids_to_selected",
     ]
@@ -296,16 +297,6 @@ class NodeAdmin(EntityModelAdmin):
     def relation(self, obj):
         return obj.get_current_relation_display()
 
-    @admin.display(description=_("Proxy"))
-    def proxy_link(self, obj):
-        if not obj or obj.is_local:
-            return ""
-        try:
-            url = reverse("admin:nodes_node_proxy", args=[obj.pk])
-        except NoReverseMatch:
-            return ""
-        return format_html('<a class="button" href="{}">{}</a>', url, _("Proxy"))
-
     @admin.display(description=_("Visit"))
     def visit_link(self, obj):
         if not obj:
@@ -372,11 +363,6 @@ class NodeAdmin(EntityModelAdmin):
                 self.admin_site.admin_view(self.update_selected_progress),
                 name="nodes_node_update_selected_progress",
             ),
-            path(
-                "<int:node_id>/proxy/",
-                self.admin_site.admin_view(self.proxy_node),
-                name="nodes_node_proxy",
-            ),
         ]
         return custom + urls
 
@@ -409,121 +395,6 @@ class NodeAdmin(EntityModelAdmin):
         )
         return response
 
-    def _load_local_private_key(self, node):
-        security_dir = Path(node.base_path or settings.BASE_DIR) / "security"
-        priv_path = security_dir / f"{node.public_endpoint}"
-        if not priv_path.exists():
-            return None, _("Local node private key not found.")
-        try:
-            return (
-                serialization.load_pem_private_key(
-                    priv_path.read_bytes(), password=None
-                ),
-                "",
-            )
-        except Exception as exc:  # pragma: no cover - unexpected errors
-            return None, str(exc)
-
-    def _build_proxy_payload(self, request, local_node):
-        user = request.user
-        payload = {
-            "requester": str(local_node.uuid),
-            "user": {
-                "username": user.get_username(),
-                "email": user.email or "",
-                "first_name": user.first_name or "",
-                "last_name": user.last_name or "",
-                "is_staff": user.is_staff,
-                "is_superuser": user.is_superuser,
-                "groups": list(user.groups.values_list("name", flat=True)),
-                "permissions": sorted(user.get_all_permissions()),
-            },
-            "target": reverse("admin:index"),
-        }
-        return payload
-
-    def _start_proxy_session(self, request, node):
-        if node.is_local:
-            return {"ok": False, "message": _("Local node cannot be proxied.")}
-
-        local_node = Node.get_local()
-        if local_node is None:
-            try:
-                local_node, _ = Node.register_current()
-            except Exception as exc:  # pragma: no cover - unexpected errors
-                return {"ok": False, "message": str(exc)}
-
-        private_key, error = self._load_local_private_key(local_node)
-        if private_key is None:
-            return {"ok": False, "message": error}
-
-        payload = self._build_proxy_payload(request, local_node)
-        body = json.dumps(payload, separators=(",", ":"), sort_keys=True)
-        try:
-            signature = private_key.sign(
-                body.encode(),
-                padding.PKCS1v15(),
-                hashes.SHA256(),
-            )
-        except Exception as exc:  # pragma: no cover - unexpected errors
-            return {"ok": False, "message": str(exc)}
-
-        headers = {
-            "Content-Type": "application/json",
-            "X-Signature": base64.b64encode(signature).decode(),
-        }
-
-        last_error = ""
-        for url in self._iter_remote_urls(node, "/nodes/proxy/session/"):
-            try:
-                response = requests.post(url, data=body, headers=headers, timeout=5)
-            except RequestException as exc:
-                last_error = str(exc)
-                continue
-            if not response.ok:
-                last_error = f"{response.status_code} {response.text}"
-                continue
-            try:
-                data = response.json()
-            except ValueError:
-                last_error = "Invalid JSON response"
-                continue
-            login_url = data.get("login_url")
-            if not login_url:
-                last_error = "login_url missing"
-                continue
-            return {
-                "ok": True,
-                "login_url": login_url,
-                "expires": data.get("expires"),
-            }
-
-        return {
-            "ok": False,
-            "message": last_error or "Unable to initiate proxy.",
-        }
-
-    def proxy_node(self, request, node_id):
-        node = self.get_queryset(request).filter(pk=node_id).first()
-        if not node:
-            raise Http404
-        if not self.has_view_permission(request):
-            raise PermissionDenied
-        result = self._start_proxy_session(request, node)
-        if not result.get("ok"):
-            message = result.get("message") or _("Unable to proxy node.")
-            self.message_user(request, message, messages.ERROR)
-            return redirect("admin:nodes_node_changelist")
-
-        context = {
-            **self.admin_site.each_context(request),
-            "opts": self.model._meta,
-            "node": node,
-            "frame_url": result.get("login_url"),
-            "expires": result.get("expires"),
-        }
-        return TemplateResponse(request, "admin/nodes/node/proxy.html", context)
-
     @admin.action(description="Register Visitor")
     def register_visitor(self, request, queryset=None):
         return self.register_visitor_view(request)
@@ -1189,6 +1060,156 @@ class NodeAdmin(EntityModelAdmin):
 
         return self._render_rfid_sync(request, "export", results)
 
+    @admin.action(description=_("Discover Charge Points"))
+    def discover_charge_points(self, request, queryset):
+        local_node, private_key, error = self._load_local_node_credentials()
+        if error:
+            self.message_user(request, error, level=messages.ERROR)
+            return
+
+        nodes = [node for node in queryset if not local_node.pk or node.pk != local_node.pk]
+        if not nodes:
+            self.message_user(request, _("No remote nodes selected."), level=messages.WARNING)
+            return
+
+        payload = json.dumps(
+            {"requester": str(local_node.uuid)},
+            separators=(",", ":"),
+            sort_keys=True,
+        )
+        signature = self._sign_payload(private_key, payload)
+        headers = {
+            "Content-Type": "application/json",
+            "X-Signature": signature,
+        }
+
+        created = 0
+        updated = 0
+        errors: list[str] = []
+
+        for node in nodes:
+            url = f"http://{node.address}:{node.port}/nodes/network/chargers/"
+            try:
+                response = requests.post(url, data=payload, headers=headers, timeout=5)
+            except RequestException as exc:
+                errors.append(f"{node}: {exc}")
+                continue
+
+            if response.status_code != 200:
+                errors.append(f"{node}: {response.status_code} {response.text}")
+                continue
+
+            try:
+                data = response.json()
+            except ValueError:
+                errors.append(f"{node}: invalid JSON response")
+                continue
+
+            for entry in data.get("chargers", []):
+                applied = self._apply_remote_charger_payload(node, entry)
+                if applied == "created":
+                    created += 1
+                elif applied == "updated":
+                    updated += 1
+
+        if created or updated:
+            summary = _("Imported %(created)s new and %(updated)s existing charge point(s).") % {
+                "created": created,
+                "updated": updated,
+            }
+            self.message_user(request, summary, level=messages.SUCCESS)
+        if errors:
+            for error in errors:
+                self.message_user(request, error, level=messages.ERROR)
+
+    def _apply_remote_charger_payload(self, node, payload: Mapping) -> str | None:
+        serial = Charger.normalize_serial(payload.get("charger_id"))
+        if not serial or Charger.is_placeholder_serial(serial):
+            return None
+
+        connector_value = payload.get("connector_id")
+        if connector_value in ("", None):
+            connector_value = None
+        elif isinstance(connector_value, str):
+            try:
+                connector_value = int(connector_value)
+            except ValueError:
+                connector_value = None
+
+        charger, created = Charger.objects.get_or_create(
+            charger_id=serial,
+            connector_id=connector_value,
+        )
+
+        location_obj = None
+        location_payload = payload.get("location")
+        if isinstance(location_payload, Mapping):
+            name = location_payload.get("name")
+            if name:
+                location_obj, _ = Location.objects.get_or_create(name=name)
+                simple_fields = [
+                    "latitude",
+                    "longitude",
+                    "zone",
+                    "contract_type",
+                ]
+                for field in simple_fields:
+                    value = location_payload.get(field)
+                    setattr(location_obj, field, value)
+                location_obj.save()
+
+        datetime_fields = [
+            "firmware_timestamp",
+            "last_heartbeat",
+            "availability_state_updated_at",
+            "availability_requested_at",
+            "availability_request_status_at",
+            "diagnostics_timestamp",
+            "last_status_timestamp",
+        ]
+
+        updates: dict[str, object] = {
+            "node_origin": node,
+            "allow_remote": bool(payload.get("allow_remote", False)),
+            "export_transactions": bool(payload.get("export_transactions", False)),
+            "last_online_at": timezone.now(),
+        }
+
+        simple_fields = [
+            "display_name",
+            "language",
+            "public_display",
+            "require_rfid",
+            "firmware_status",
+            "firmware_status_info",
+            "last_status",
+            "last_error_code",
+            "last_status_vendor_info",
+            "availability_state",
+            "availability_requested_state",
+            "availability_request_status",
+            "availability_request_details",
+            "temperature",
+            "temperature_unit",
+            "diagnostics_status",
+            "diagnostics_location",
+        ]
+        for field in simple_fields:
+            updates[field] = payload.get(field)
+
+        if location_obj is not None:
+            updates["location"] = location_obj
+
+        for field in datetime_fields:
+            value = payload.get(field)
+            updates[field] = parse_datetime(value) if value else None
+
+        for field in ("last_meter_values",):
+            updates[field] = payload.get(field) or {}
+
+        Charger.objects.filter(pk=charger.pk).update(**updates)
+        return "created" if created else "updated"
+
     def changeform_view(self, request, object_id=None, form_url="", extra_context=None):
         extra_context = extra_context or {}
         if object_id: