arthexis 0.1.15__py3-none-any.whl → 0.1.17__py3-none-any.whl

ocpp/views.py

@@ -370,10 +370,6 @@ def _aggregate_dashboard_state(charger: Charger) -> tuple[str, str] | None:
     )
     statuses: list[str] = []
     for sibling in siblings:
-        status_value = (sibling.last_status or "").strip()
-        if status_value:
-            statuses.append(status_value.casefold())
-            continue
         tx_obj = store.get_transaction(sibling.charger_id, sibling.connector_id)
         if not tx_obj:
             tx_obj = (
@@ -381,9 +377,22 @@ def _aggregate_dashboard_state(charger: Charger) -> tuple[str, str] | None:
                 .order_by("-start_time")
                 .first()
             )
-        if _has_active_session(tx_obj):
+        has_session = _has_active_session(tx_obj)
+        status_value = (sibling.last_status or "").strip()
+        normalized_status = status_value.casefold() if status_value else ""
+        error_code_lower = (sibling.last_error_code or "").strip().lower()
+        if has_session:
             statuses.append("charging")
             continue
+        if (
+            normalized_status in {"charging", "finishing"}
+            and error_code_lower in ERROR_OK_VALUES
+        ):
+            statuses.append("available")
+            continue
+        if normalized_status:
+            statuses.append(normalized_status)
+            continue
         if store.is_connected(sibling.charger_id, sibling.connector_id):
             statuses.append("available")
 
@@ -424,6 +433,15 @@ def _charger_state(charger: Charger, tx_obj: Transaction | list | None):
             # while a session is active. Override the badge so the user can see
             # the charger is actually busy.
             label, color = STATUS_BADGE_MAP.get("charging", (_("Charging"), "#198754"))
+        elif (
+            not has_session
+            and key in {"charging", "finishing"}
+            and error_code_lower in ERROR_OK_VALUES
+        ):
+            # Some chargers continue reporting "Charging" after a session ends.
+            # When no active transaction exists, surface the state as available
+            # so the UI reflects the actual behaviour at the site.
+            label, color = STATUS_BADGE_MAP.get("available", (_("Available"), "#0d6efd"))
         elif error_code and error_code_lower not in ERROR_OK_VALUES:
             label = _("%(status)s (%(error)s)") % {
                 "status": label,

pages/admin.py

@@ -20,10 +20,11 @@ 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 (
@@ -229,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):
@@ -522,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",
@@ -537,6 +649,10 @@ class UserStoryAdmin(EntityModelAdmin):
         "path",
         "user",
         "owner",
+        "referer",
+        "user_agent",
+        "ip_address",
+        "created_on",
         "submitted_at",
         "github_issue_number",
         "github_issue_url",
@@ -550,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",

pages/context_processors.py

@@ -50,6 +50,13 @@ def nav_links(request):
     valid_modules = []
     datasette_enabled = False
     current_module = None
+    user = getattr(request, "user", None)
+    user_is_authenticated = getattr(user, "is_authenticated", False)
+    user_is_superuser = getattr(user, "is_superuser", False)
+    if user_is_authenticated:
+        user_group_names = set(user.groups.values_list("name", flat=True))
+    else:
+        user_group_names = set()
     for module in modules:
         landings = []
         for landing in module.landings.filter(enabled=True):
@@ -62,7 +69,19 @@ def nav_links(request):
             if not requires_login and hasattr(view_func, "login_url"):
                 requires_login = True
             staff_only = getattr(view_func, "staff_required", False)
-            if requires_login and not request.user.is_authenticated:
+            required_groups = getattr(
+                view_func, "required_security_groups", frozenset()
+            )
+            if required_groups:
+                requires_login = True
+                setattr(landing, "requires_login", True)
+                if not user_is_authenticated:
+                    continue
+                if not user_is_superuser and not (
+                    user_group_names & set(required_groups)
+                ):
+                    continue
+            elif requires_login and not user_is_authenticated:
                 setattr(landing, "requires_login", True)
             if staff_only and not request.user.is_staff:
                 continue

pages/models.py

@@ -470,7 +470,7 @@ class Favorite(Entity):
         unique_together = ("user", "content_type")
 
 
-class UserStory(Entity):
+class UserStory(Lead):
     path = models.CharField(max_length=500)
     name = models.CharField(max_length=40, blank=True)
     rating = models.PositiveSmallIntegerField(
@@ -624,6 +624,8 @@ def _queue_low_rating_user_story_issue(
         return
     if instance.github_issue_url:
         return
+    if not instance.user_id:
+        return
     if not _is_celery_enabled():
         return
 

pages/module_defaults.py

@@ -0,0 +1,156 @@
+"""Utilities to restore default navigation modules."""
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
+
+
+ModuleDefinition = Mapping[str, object]
+LandingDefinition = tuple[str, str]
+
+
+ROLE_MODULE_DEFAULTS: Mapping[str, tuple[ModuleDefinition, ...]] = {
+    "Constellation": (
+        {
+            "application": "ocpp",
+            "path": "/ocpp/",
+            "menu": "Chargers",
+            "landings": (
+                ("/ocpp/", "CPMS Online Dashboard"),
+                ("/ocpp/simulator/", "Charge Point Simulator"),
+                ("/ocpp/rfid/", "RFID Tag Validator"),
+            ),
+        },
+        {
+            "application": "awg",
+            "path": "/awg/",
+            "menu": "",
+            "landings": (
+                ("/awg/", "AWG Calculator"),
+                ("/awg/energy-tariff/", "Energy Tariff Calculator"),
+            ),
+        },
+    ),
+}
+
+
+@dataclass
+class ReloadSummary:
+    """Report about the changes performed while restoring defaults."""
+
+    roles_processed: int = 0
+    modules_created: int = 0
+    modules_updated: int = 0
+    landings_created: int = 0
+    landings_updated: int = 0
+
+    @property
+    def has_changes(self) -> bool:
+        return any(
+            (
+                self.modules_created,
+                self.modules_updated,
+                self.landings_created,
+                self.landings_updated,
+            )
+        )
+
+
+def _manager(model, name: str):
+    manager = getattr(model, name, None)
+    if manager is not None:
+        return manager
+    return model.objects
+
+
+def reload_default_modules(Application, Module, Landing, NodeRole) -> ReloadSummary:
+    """Ensure default navigation modules exist for the configured roles."""
+
+    summary = ReloadSummary()
+    application_manager = _manager(Application, "all_objects")
+    module_manager = _manager(Module, "all_objects")
+    landing_manager = _manager(Landing, "all_objects")
+    role_manager = _manager(NodeRole, "all_objects")
+
+    for role_name, module_definitions in ROLE_MODULE_DEFAULTS.items():
+        try:
+            role = role_manager.get(name=role_name)
+        except NodeRole.DoesNotExist:
+            continue
+
+        summary.roles_processed += 1
+
+        for definition in module_definitions:
+            app_name: str = definition["application"]  # type: ignore[assignment]
+            try:
+                application = application_manager.get(name=app_name)
+            except Application.DoesNotExist:
+                continue
+
+            module, created = module_manager.get_or_create(
+                node_role=role,
+                path=definition["path"],
+                defaults={
+                    "application": application,
+                    "menu": definition["menu"],
+                    "is_seed_data": True,
+                    "is_deleted": False,
+                },
+            )
+            if created:
+                summary.modules_created += 1
+
+            module_updates: list[str] = []
+            if module.application_id != application.id:
+                module.application = application
+                module_updates.append("application")
+            if module.menu != definition["menu"]:
+                module.menu = definition["menu"]  # type: ignore[index]
+                module_updates.append("menu")
+            if getattr(module, "is_deleted", False):
+                module.is_deleted = False
+                module_updates.append("is_deleted")
+            if not getattr(module, "is_seed_data", False):
+                module.is_seed_data = True
+                module_updates.append("is_seed_data")
+            if module_updates:
+                module.save(update_fields=module_updates)
+                if not created:
+                    summary.modules_updated += 1
+
+            landings: Iterable[tuple[str, str]] = definition["landings"]  # type: ignore[index]
+            for path, label in landings:
+                landing, landing_created = landing_manager.get_or_create(
+                    module=module,
+                    path=path,
+                    defaults={
+                        "label": label,
+                        "description": "",
+                        "enabled": True,
+                    },
+                )
+                if landing_created:
+                    summary.landings_created += 1
+
+                landing_updates: list[str] = []
+                if landing.label != label:
+                    landing.label = label
+                    landing_updates.append("label")
+                if landing.description:
+                    landing.description = ""
+                    landing_updates.append("description")
+                if not landing.enabled:
+                    landing.enabled = True
+                    landing_updates.append("enabled")
+                if getattr(landing, "is_deleted", False):
+                    landing.is_deleted = False
+                    landing_updates.append("is_deleted")
+                if not getattr(landing, "is_seed_data", False):
+                    landing.is_seed_data = True
+                    landing_updates.append("is_seed_data")
+                if landing_updates:
+                    landing.save(update_fields=landing_updates)
+                    if not landing_created:
+                        summary.landings_updated += 1
+
+    return summary