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

core/admin.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 from io import BytesIO
 import os
 
@@ -8,10 +9,13 @@ from django.urls import NoReverseMatch, path, reverse
 from urllib.parse import urlencode, urlparse
 from django.shortcuts import get_object_or_404, redirect, render
 from django.http import (
+    FileResponse,
+    Http404,
     HttpResponse,
     JsonResponse,
     HttpResponseBase,
     HttpResponseRedirect,
+    HttpResponseNotAllowed,
 )
 from django.template.response import TemplateResponse
 from django.conf import settings
@@ -39,6 +43,7 @@ from django.utils import timezone, translation
 from django.utils.formats import date_format
 from django.utils.dateparse import parse_datetime
 from django.utils.html import format_html
+from django.utils.text import slugify
 from django.utils.translation import gettext_lazy as _, ngettext
 from django.forms.models import BaseInlineFormSet
 import json
@@ -46,6 +51,7 @@ import uuid
 import requests
 import datetime
 from django.db import IntegrityError, transaction
+from django.db.models import Q
 import calendar
 import re
 from django_object_actions import DjangoObjectActions
@@ -59,7 +65,7 @@ from reportlab.graphics.barcode import qr
 from reportlab.graphics.shapes import Drawing
 from reportlab.lib.styles import getSampleStyleSheet
 from reportlab.platypus import Paragraph, SimpleDocTemplate, Spacer, Table, TableStyle
-from ocpp.models import Transaction
+from ocpp.models import Charger, Transaction
 from ocpp.rfid.utils import build_mode_toggle
 from nodes.models import EmailOutbox
 from .github_helper import GitHubRepositoryError, create_repository_for_package
@@ -82,6 +88,7 @@ from .models import (
     OdooProfile,
     OpenPayProfile,
     EmailInbox,
+    GoogleCalendarProfile,
     SocialProfile,
     EmailCollector,
     Package,
@@ -90,9 +97,7 @@ from .models import (
     SecurityGroup,
     InviteLead,
     PublicWifiAccess,
-    AssistantProfile,
     Todo,
-    hash_key,
 )
 from .user_data import (
     EntityModelAdmin,
@@ -109,8 +114,6 @@ from .rfid_import_export import (
     parse_accounts,
     serialize_accounts,
 )
-from .mcp import process as mcp_process
-from .mcp.server import resolve_base_urls
 from . import release as release_utils
 
 logger = logging.getLogger(__name__)
@@ -608,15 +611,18 @@ class PackageAdmin(SaveBeforeChangeAction, EntityModelAdmin):
     change_actions = ["create_repository_action", "prepare_next_release_action"]
 
     def _prepare(self, request, package):
+        if request.method not in {"POST", "GET"}:
+            return HttpResponseNotAllowed(["GET", "POST"])
         from pathlib import Path
         from packaging.version import Version
 
         ver_file = Path("VERSION")
-        repo_version = (
-            Version(ver_file.read_text().strip())
-            if ver_file.exists()
-            else Version("0.0.0")
-        )
+        if ver_file.exists():
+            raw_version = ver_file.read_text().strip()
+            cleaned_version = raw_version.rstrip("+") or "0.0.0"
+            repo_version = Version(cleaned_version)
+        else:
+            repo_version = Version("0.0.0")
 
         pypi_latest = Version("0.0.0")
         try:
@@ -808,6 +814,7 @@ class SecurityGroupAdmin(DjangoGroupAdmin):
     form = SecurityGroupAdminForm
     fieldsets = ((None, {"fields": ("name", "parent", "users", "permissions")}),)
     filter_horizontal = ("permissions",)
+    search_fields = ("name", "parent__name")
 
 
 class InviteLeadAdmin(EntityModelAdmin):
@@ -876,6 +883,82 @@ class EnergyAccountRFIDInline(admin.TabularInline):
     verbose_name_plural = "RFIDs"
 
 
+class UserChangeRFIDForm(forms.ModelForm):
+    """Admin change form exposing login RFID assignment."""
+
+    login_rfid = forms.ModelChoiceField(
+        label=_("Login RFID"),
+        queryset=RFID.objects.none(),
+        required=False,
+        help_text=_("Assign an RFID card to this user for RFID logins."),
+    )
+
+    class Meta:
+        model = User
+        fields = "__all__"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        user = self.instance
+        field = self.fields["login_rfid"]
+        account = getattr(user, "energy_account", None)
+        if account is not None:
+            queryset = RFID.objects.filter(
+                Q(energy_accounts__isnull=True) | Q(energy_accounts=account)
+            )
+            current = account.rfids.order_by("label_id").first()
+            if current:
+                field.initial = current.pk
+        else:
+            queryset = RFID.objects.filter(energy_accounts__isnull=True)
+        field.queryset = queryset.order_by("label_id")
+        field.empty_label = _("Keep current assignment")
+
+    def _ensure_energy_account(self, user):
+        account = getattr(user, "energy_account", None)
+        if account is not None:
+            if account.user_id != user.pk:
+                account.user = user
+                account.save(update_fields=["user"])
+            return account
+        account = EnergyAccount.objects.filter(user=user).first()
+        if account is not None:
+            if account.user_id != user.pk:
+                account.user = user
+                account.save(update_fields=["user"])
+            return account
+        base_slug = slugify(
+            user.username
+            or user.get_full_name()
+            or user.email
+            or (str(user.pk) if user.pk is not None else "")
+        )
+        if not base_slug:
+            base_slug = f"user-{uuid.uuid4().hex[:8]}"
+        base_name = base_slug.upper()
+        candidate = base_name
+        suffix = 1
+        while EnergyAccount.objects.filter(name=candidate).exists():
+            suffix += 1
+            candidate = f"{base_name}-{suffix}"
+        return EnergyAccount.objects.create(user=user, name=candidate)
+
+    def save(self, commit=True):
+        user = super().save(commit)
+        rfid = self.cleaned_data.get("login_rfid")
+        if not rfid:
+            return user
+        account = self._ensure_energy_account(user)
+        if account.pk is None:
+            account.save()
+        other_accounts = list(rfid.energy_accounts.exclude(pk=account.pk))
+        if other_accounts:
+            rfid.energy_accounts.remove(*other_accounts)
+        if not account.rfids.filter(pk=rfid.pk).exists():
+            account.rfids.add(rfid)
+        return user
+
+
 def _raw_instance_value(instance, field_name):
     """Return the stored value for ``field_name`` without resolving sigils."""
 
@@ -973,6 +1056,15 @@ class OpenPayProfileAdminForm(forms.ModelForm):
         required=False,
         help_text="Leave blank to keep the current secret.",
     )
+    paypal_client_secret = forms.CharField(
+        widget=forms.PasswordInput(render_value=True),
+        required=False,
+        help_text="Leave blank to keep the current secret.",
+    )
+    paypal_webhook_id = forms.CharField(
+        required=False,
+        help_text="Leave blank to keep the current webhook identifier.",
+    )
 
     class Meta:
         model = OpenPayProfile
@@ -980,13 +1072,43 @@ class OpenPayProfileAdminForm(forms.ModelForm):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
+        openpay_help = _(
+            "Provide merchant ID, public and private keys, and webhook secret from OpenPay."
+        )
+        self.fields["merchant_id"].help_text = openpay_help
+        self.fields["public_key"].help_text = _(
+            "OpenPay public key used for browser integrations."
+        )
+        self.fields["private_key"].help_text = _(
+            "OpenPay private key used for server-side requests. Leave blank to keep the current key."
+        )
+        self.fields["webhook_secret"].help_text = _(
+            "Secret used to sign OpenPay webhooks. Leave blank to keep the current secret."
+        )
+        self.fields["is_production"].help_text = _(
+            "Enable to send requests to OpenPay's live environment."
+        )
+        self.fields["default_processor"].help_text = _(
+            "Select which configured processor to try first when charging."
+        )
+        self.fields["paypal_client_id"].help_text = _(
+            "PayPal REST client ID for your application."
+        )
+        self.fields["paypal_client_secret"].help_text = _(
+            "PayPal REST client secret. Leave blank to keep the current secret."
+        )
+        self.fields["paypal_webhook_id"].help_text = _(
+            "PayPal webhook ID used to validate notifications. Leave blank to keep the current webhook identifier."
+        )
+        self.fields["paypal_is_production"].help_text = _(
+            "Enable to send requests to PayPal's live environment."
+        )
+
         if self.instance.pk:
-            for field in ("private_key", "webhook_secret"):
+            for field in ("private_key", "webhook_secret", "paypal_client_secret", "paypal_webhook_id"):
                 if field in self.fields:
                     self.fields[field].initial = ""
                     self.initial[field] = ""
-        else:
-            self.fields["private_key"].required = True
 
     def clean_private_key(self):
         key = self.cleaned_data.get("private_key")
@@ -1000,11 +1122,66 @@ class OpenPayProfileAdminForm(forms.ModelForm):
             return keep_existing("webhook_secret")
         return secret
 
+    def clean_paypal_client_secret(self):
+        secret = self.cleaned_data.get("paypal_client_secret")
+        if not secret and self.instance.pk:
+            return keep_existing("paypal_client_secret")
+        return secret
+
+    def clean_paypal_webhook_id(self):
+        identifier = self.cleaned_data.get("paypal_webhook_id")
+        if identifier == "" and self.instance.pk:
+            return keep_existing("paypal_webhook_id")
+        return identifier
+
     def _post_clean(self):
         super()._post_clean()
         _restore_sigil_values(
             self,
-            ["merchant_id", "private_key", "public_key", "webhook_secret"],
+            [
+                "merchant_id",
+                "private_key",
+                "public_key",
+                "webhook_secret",
+                "paypal_client_id",
+                "paypal_client_secret",
+                "paypal_webhook_id",
+            ],
+        )
+
+
+class GoogleCalendarProfileAdminForm(forms.ModelForm):
+    """Admin form for :class:`core.models.GoogleCalendarProfile`."""
+
+    api_key = forms.CharField(
+        widget=forms.PasswordInput(render_value=True),
+        required=False,
+        help_text="Leave blank to keep the current key.",
+    )
+
+    class Meta:
+        model = GoogleCalendarProfile
+        fields = "__all__"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if self.instance.pk:
+            self.fields["api_key"].initial = ""
+            self.initial["api_key"] = ""
+        else:
+            self.fields["api_key"].required = True
+
+    def clean_api_key(self):
+        key = self.cleaned_data.get("api_key")
+        if not key and self.instance.pk:
+            return keep_existing("api_key")
+        return key
+
+    def _post_clean(self):
+        super()._post_clean()
+        _restore_sigil_values(
+            self,
+            ["calendar_id", "api_key", "display_name", "timezone"],
         )
 
 
@@ -1192,7 +1369,7 @@ class OdooProfileInlineForm(ProfileFormMixin, OdooProfileAdminForm):
         ]
         if provided and missing:
             raise forms.ValidationError(
-                "Provide host, database, username, and password to create an Odoo employee.",
+                "Provide host, database, username, and password to create a CRM employee.",
             )
 
         return cleaned
@@ -1209,22 +1386,63 @@ class OpenPayProfileInlineForm(ProfileFormMixin, OpenPayProfileAdminForm):
         if cleaned.get("DELETE") or self.errors:
             return cleaned
 
-        required = ("merchant_id", "private_key", "public_key")
-        provided = [
-            name for name in required if not self._is_empty_value(cleaned.get(name))
-        ]
-        missing = [
-            name for name in required if self._is_empty_value(cleaned.get(name))
-        ]
-        if provided and missing:
+        def _has_value(name: str) -> bool:
+            value = cleaned.get(name)
+            if isinstance(value, KeepExistingValue):
+                return bool(getattr(self.instance, name))
+            return not self._is_empty_value(value)
+
+        openpay_fields = ("merchant_id", "private_key", "public_key")
+        openpay_provided = [name for name in openpay_fields if _has_value(name)]
+        openpay_missing = [name for name in openpay_fields if not _has_value(name)]
+        if openpay_provided and openpay_missing:
             raise forms.ValidationError(
                 _(
                     "Provide merchant ID, private key, and public key to configure OpenPay."
                 )
             )
+
+        paypal_fields = ("paypal_client_id", "paypal_client_secret")
+        paypal_provided = [name for name in paypal_fields if _has_value(name)]
+        paypal_missing = [name for name in paypal_fields if not _has_value(name)]
+        if paypal_provided and paypal_missing:
+            raise forms.ValidationError(
+                _("Provide PayPal client ID and client secret to configure PayPal.")
+            )
+
+        has_openpay = len(openpay_provided) == len(openpay_fields)
+        has_paypal = len(paypal_provided) == len(paypal_fields)
+
+        if not has_openpay and not has_paypal:
+            raise forms.ValidationError(
+                _("Provide OpenPay or PayPal credentials to configure a payment processor.")
+            )
+
+        default_processor = cleaned.get("default_processor") or OpenPayProfile.PROCESSOR_OPENPAY
+        if default_processor == OpenPayProfile.PROCESSOR_OPENPAY and not has_openpay:
+            raise forms.ValidationError(
+                _(
+                    "OpenPay must be fully configured or select PayPal as the default processor."
+                )
+            )
+        if default_processor == OpenPayProfile.PROCESSOR_PAYPAL and not has_paypal:
+            raise forms.ValidationError(
+                _(
+                    "PayPal must be fully configured or select OpenPay as the default processor."
+                )
+            )
         return cleaned
 
 
+class GoogleCalendarProfileInlineForm(
+    ProfileFormMixin, GoogleCalendarProfileAdminForm
+):
+    profile_fields = GoogleCalendarProfile.profile_fields
+
+    class Meta(GoogleCalendarProfileAdminForm.Meta):
+        exclude = ("user", "group")
+
+
 class EmailInboxInlineForm(ProfileFormMixin, EmailInboxAdminForm):
     profile_fields = EmailInbox.profile_fields
 
@@ -1303,46 +1521,6 @@ class ReleaseManagerInlineForm(ProfileFormMixin, forms.ModelForm):
         }
 
 
-class AssistantProfileInlineForm(ProfileFormMixin, forms.ModelForm):
-    user_key = forms.CharField(
-        required=False,
-        widget=forms.PasswordInput(render_value=True),
-        help_text="Provide a plain key to create or rotate credentials.",
-    )
-    profile_fields = ("user_key", "scopes", "is_active")
-
-    class Meta:
-        model = AssistantProfile
-        fields = ("scopes", "is_active")
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        if not self.instance.pk and "is_active" in self.fields:
-            self.fields["is_active"].initial = False
-
-    def clean(self):
-        cleaned = super().clean()
-        if cleaned.get("DELETE"):
-            return cleaned
-        if not self.instance.pk and not cleaned.get("user_key"):
-            if cleaned.get("scopes") or cleaned.get("is_active"):
-                raise forms.ValidationError(
-                    "Provide a user key to create an assistant profile."
-                )
-        return cleaned
-
-    def save(self, commit=True):
-        instance = super().save(commit=False)
-        user_key = self.cleaned_data.get("user_key")
-        if user_key:
-            instance.user_key_hash = hash_key(user_key)
-            instance.last_used_at = None
-        if commit:
-            instance.save()
-            self.save_m2m()
-        return instance
-
-
 PROFILE_INLINE_CONFIG = {
     OdooProfile: {
         "form": OdooProfileInlineForm,
@@ -1351,6 +1529,7 @@ PROFILE_INLINE_CONFIG = {
                 None,
                 {
                     "fields": (
+                        "crm",
                         "host",
                         "database",
                         "username",
@@ -1359,7 +1538,7 @@ PROFILE_INLINE_CONFIG = {
                 },
             ),
             (
-                "Odoo Employee",
+                "CRM Employee",
                 {
                     "fields": ("verified_on", "odoo_uid", "name", "email"),
                 },
@@ -1389,6 +1568,16 @@ PROFILE_INLINE_CONFIG = {
         ),
         "readonly_fields": ("verified_on", "verification_reference"),
     },
+    GoogleCalendarProfile: {
+        "form": GoogleCalendarProfileInlineForm,
+        "fields": (
+            "display_name",
+            "calendar_id",
+            "api_key",
+            "max_events",
+            "timezone",
+        ),
+    },
     EmailInbox: {
         "form": EmailInboxInlineForm,
         "fields": (
@@ -1473,12 +1662,6 @@ PROFILE_INLINE_CONFIG = {
             "secondary_pypi_url",
         ),
     },
-    AssistantProfile: {
-        "form": AssistantProfileInlineForm,
-        "fields": ("user_key", "scopes", "is_active"),
-        "readonly_fields": ("user_key_hash", "created_at", "last_used_at"),
-        "template": "admin/edit_inline/profile_stacked.html",
-    },
 }
 
 
@@ -1525,7 +1708,6 @@ PROFILE_MODELS = (
     EmailOutbox,
     SocialProfile,
     ReleaseManager,
-    AssistantProfile,
 )
 USER_PROFILE_INLINES = [
     _build_profile_inline(model, "user") for model in PROFILE_MODELS
@@ -1544,12 +1726,25 @@ class UserPhoneNumberInline(admin.TabularInline):
 
 
 class UserAdmin(UserDatumAdminMixin, DjangoUserAdmin):
+    form = UserChangeRFIDForm
     fieldsets = _append_operate_as(DjangoUserAdmin.fieldsets)
     add_fieldsets = _append_operate_as(DjangoUserAdmin.add_fieldsets)
     inlines = USER_PROFILE_INLINES + [UserPhoneNumberInline]
     change_form_template = "admin/user_profile_change_form.html"
     _skip_entity_user_datum = True
 
+    def get_fieldsets(self, request, obj=None):
+        fieldsets = list(super().get_fieldsets(request, obj))
+        if obj is not None and fieldsets:
+            name, options = fieldsets[0]
+            fields = list(options.get("fields", ()))
+            if "login_rfid" not in fields:
+                fields.append("login_rfid")
+                options = options.copy()
+                options["fields"] = tuple(fields)
+                fieldsets[0] = (name, options)
+        return fieldsets
+
     def _get_operate_as_profile_template(self):
         opts = self.model._meta
         try:
@@ -1757,17 +1952,18 @@ class SocialProfileAdmin(
 class OdooProfileAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmin):
     change_form_template = "django_object_actions/change_form.html"
     form = OdooProfileAdminForm
-    list_display = ("owner", "host", "database", "verified_on")
+    list_display = ("owner", "host", "database", "credentials_ok", "verified_on")
+    list_filter = ("crm",)
     readonly_fields = ("verified_on", "odoo_uid", "name", "email")
     actions = ["verify_credentials"]
     change_actions = ["verify_credentials_action", "my_profile_action"]
     changelist_actions = ["my_profile", "generate_quote_report"]
     fieldsets = (
         ("Owner", {"fields": ("user", "group")}),
-        ("Configuration", {"fields": ("host", "database")}),
+        ("Configuration", {"fields": ("crm", "host", "database")}),
         ("Credentials", {"fields": ("username", "password")}),
         (
-            "Odoo Employee",
+            "CRM Employee",
             {"fields": ("verified_on", "odoo_uid", "name", "email")},
         ),
     )
@@ -1777,6 +1973,10 @@ class OdooProfileAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdm
 
     owner.short_description = "Owner"
 
+    @admin.display(description=_("Credentials OK"), boolean=True)
+    def credentials_ok(self, obj):
+        return bool(obj.password) and obj.is_verified
+
     def _verify_credentials(self, request, profile):
         try:
             profile.verify()
@@ -1808,15 +2008,47 @@ class OdooProfileAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdm
 class OpenPayProfileAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmin):
     change_form_template = "django_object_actions/change_form.html"
     form = OpenPayProfileAdminForm
-    list_display = ("owner", "merchant_id", "environment", "verified_on")
+    list_display = ("owner", "default_processor_display", "environment", "verified_on")
     readonly_fields = ("verified_on", "verification_reference")
     actions = ["verify_credentials"]
     change_actions = ["verify_credentials_action", "my_profile_action"]
     changelist_actions = ["my_profile"]
     fieldsets = (
         (_("Owner"), {"fields": ("user", "group")}),
-        (_("Gateway"), {"fields": ("merchant_id", "public_key", "is_production")}),
-        (_("Credentials"), {"fields": ("private_key", "webhook_secret")}),
+        (
+            _("Default Processor"),
+            {
+                "fields": ("default_processor",),
+                "description": _(
+                    "Choose which configured processor to contact first when processing payments."
+                ),
+            },
+        ),
+        (
+            _("OpenPay"),
+            {
+                "fields": (
+                    "merchant_id",
+                    "public_key",
+                    "private_key",
+                    "webhook_secret",
+                    "is_production",
+                ),
+                "description": _("Configure OpenPay merchant access."),
+            },
+        ),
+        (
+            _("PayPal"),
+            {
+                "fields": (
+                    "paypal_client_id",
+                    "paypal_client_secret",
+                    "paypal_webhook_id",
+                    "paypal_is_production",
+                ),
+                "description": _("Configure PayPal REST API access."),
+            },
+        ),
         (
             _("Verification"),
             {"fields": ("verified_on", "verification_reference")},
@@ -1827,12 +2059,23 @@ class OpenPayProfileAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModel
     def owner(self, obj):
         return obj.owner_display()
 
+    @admin.display(description=_("Default Processor"))
+    def default_processor_display(self, obj):
+        return obj.get_default_processor_display()
+
     @admin.display(description=_("Environment"))
     def environment(self, obj):
-        return _("Production") if obj.is_production else _("Sandbox")
+        if obj.default_processor == obj.PROCESSOR_PAYPAL:
+            return _("PayPal Production") if obj.paypal_is_production else _("PayPal Sandbox")
+        return _("OpenPay Production") if obj.is_production else _("OpenPay Sandbox")
 
     def _verify_credentials(self, request, profile):
-        owner = profile.owner_display() or profile.merchant_id
+        owner = (
+            profile.owner_display()
+            or profile.merchant_id
+            or profile.paypal_client_id
+            or _("Payment Processor")
+        )
         try:
             profile.verify()
         except ValidationError as exc:
@@ -1867,6 +2110,44 @@ class OpenPayProfileAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModel
     verify_credentials_action.short_description = _("Test credentials")
 
 
+class GoogleCalendarProfileAdmin(
+    ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmin
+):
+    form = GoogleCalendarProfileAdminForm
+    list_display = ("owner", "calendar_identifier", "max_events")
+    search_fields = (
+        "display_name",
+        "calendar_id",
+        "user__username",
+        "group__name",
+    )
+    changelist_actions = ["my_profile"]
+    change_actions = ["my_profile_action"]
+    fieldsets = (
+        (_("Owner"), {"fields": ("user", "group")}),
+        (
+            _("Calendar"),
+            {
+                "fields": (
+                    "display_name",
+                    "calendar_id",
+                    "api_key",
+                    "max_events",
+                    "timezone",
+                )
+            },
+        ),
+    )
+
+    @admin.display(description=_("Owner"))
+    def owner(self, obj):
+        return obj.owner_display()
+
+    @admin.display(description=_("Calendar"))
+    def calendar_identifier(self, obj):
+        display = obj.get_display_name()
+        return display or obj.resolved_calendar_id()
+
 class EmailSearchForm(forms.Form):
     subject = forms.CharField(
         required=False, widget=forms.TextInput(attrs={"style": "width: 40em;"})
@@ -2012,180 +2293,6 @@ class EmailInboxAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmi
         return TemplateResponse(request, "admin/core/emailinbox/search.html", context)
 
 
-@admin.register(AssistantProfile)
-class AssistantProfileAdmin(
-    ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmin
-):
-    list_display = ("owner", "created_at", "last_used_at", "is_active")
-    readonly_fields = ("user_key_hash", "created_at", "last_used_at")
-
-    change_form_template = "admin/workgroupassistantprofile_change_form.html"
-    change_list_template = "admin/assistantprofile_change_list.html"
-    change_actions = ["my_profile_action"]
-    changelist_actions = ["my_profile"]
-    fieldsets = (
-        ("Owner", {"fields": ("user", "group")}),
-        ("Credentials", {"fields": ("user_key_hash",)}),
-        (
-            "Configuration",
-            {"fields": ("scopes", "is_active", "created_at", "last_used_at")},
-        ),
-    )
-
-    def owner(self, obj):
-        return obj.owner_display()
-
-    owner.short_description = "Owner"
-
-    def get_urls(self):
-        urls = super().get_urls()
-        opts = self.model._meta
-        app_label = opts.app_label
-        model_name = opts.model_name
-        custom = [
-            path(
-                "<path:object_id>/generate-key/",
-                self.admin_site.admin_view(self.generate_key),
-                name=f"{app_label}_{model_name}_generate_key",
-            ),
-            path(
-                "server/start/",
-                self.admin_site.admin_view(self.start_server),
-                name=f"{app_label}_{model_name}_start_server",
-            ),
-            path(
-                "server/stop/",
-                self.admin_site.admin_view(self.stop_server),
-                name=f"{app_label}_{model_name}_stop_server",
-            ),
-            path(
-                "server/status/",
-                self.admin_site.admin_view(self.server_status),
-                name=f"{app_label}_{model_name}_status",
-            ),
-        ]
-        return custom + urls
-
-    def changelist_view(self, request, extra_context=None):
-        extra_context = extra_context or {}
-        status = mcp_process.get_status()
-        opts = self.model._meta
-        app_label = opts.app_label
-        model_name = opts.model_name
-        extra_context.update(
-            {
-                "mcp_status": status,
-                "mcp_server_actions": {
-                    "start": reverse(f"admin:{app_label}_{model_name}_start_server"),
-                    "stop": reverse(f"admin:{app_label}_{model_name}_stop_server"),
-                    "status": reverse(f"admin:{app_label}_{model_name}_status"),
-                },
-            }
-        )
-        return super().changelist_view(request, extra_context=extra_context)
-
-    def _redirect_to_changelist(self):
-        opts = self.model._meta
-        return HttpResponseRedirect(
-            reverse(f"admin:{opts.app_label}_{opts.model_name}_changelist")
-        )
-
-    def generate_key(self, request, object_id, *args, **kwargs):
-        profile = self.get_object(request, object_id)
-        if profile is None:
-            return HttpResponseRedirect("../")
-        if profile.user is None:
-            self.message_user(
-                request,
-                "Assign a user before generating a key.",
-                level=messages.ERROR,
-            )
-            return HttpResponseRedirect("../")
-        profile, key = AssistantProfile.issue_key(profile.user)
-        context = {
-            **self.admin_site.each_context(request),
-            "opts": self.model._meta,
-            "original": profile,
-            "user_key": key,
-        }
-        return TemplateResponse(request, "admin/assistantprofile_key.html", context)
-
-    def render_change_form(
-        self, request, context, add=False, change=False, form_url="", obj=None
-    ):
-        response = super().render_change_form(
-            request, context, add=add, change=change, form_url=form_url, obj=obj
-        )
-        config = dict(getattr(settings, "MCP_SIGIL_SERVER", {}))
-        host = config.get("host") or "127.0.0.1"
-        port = config.get("port", 8800)
-        base_url, issuer_url = resolve_base_urls(config)
-        mount_path = config.get("mount_path") or "/"
-        display_base_url = base_url or f"http://{host}:{port}"
-        display_issuer_url = issuer_url or display_base_url
-        chat_endpoint = f"{display_base_url.rstrip('/')}/api/chat/"
-        if isinstance(response, dict):
-            response.setdefault("mcp_server_host", host)
-            response.setdefault("mcp_server_port", port)
-            response.setdefault("mcp_server_base_url", display_base_url)
-            response.setdefault("mcp_server_issuer_url", display_issuer_url)
-            response.setdefault("mcp_server_mount_path", mount_path)
-            response.setdefault("mcp_server_chat_endpoint", chat_endpoint)
-        else:
-            context_data = getattr(response, "context_data", None)
-            if context_data is not None:
-                context_data.setdefault("mcp_server_host", host)
-                context_data.setdefault("mcp_server_port", port)
-                context_data.setdefault("mcp_server_base_url", display_base_url)
-                context_data.setdefault("mcp_server_issuer_url", display_issuer_url)
-                context_data.setdefault("mcp_server_mount_path", mount_path)
-                context_data.setdefault("mcp_server_chat_endpoint", chat_endpoint)
-        return response
-
-    def start_server(self, request):
-        try:
-            pid = mcp_process.start_server()
-        except mcp_process.ServerAlreadyRunningError as exc:
-            self.message_user(request, str(exc), level=messages.WARNING)
-        except mcp_process.ServerStartError as exc:
-            self.message_user(request, str(exc), level=messages.ERROR)
-        else:
-            self.message_user(
-                request,
-                f"Started MCP server (PID {pid}).",
-                level=messages.SUCCESS,
-            )
-        return self._redirect_to_changelist()
-
-    def stop_server(self, request):
-        try:
-            pid = mcp_process.stop_server()
-        except mcp_process.ServerNotRunningError as exc:
-            self.message_user(request, str(exc), level=messages.WARNING)
-        except mcp_process.ServerStopError as exc:
-            self.message_user(request, str(exc), level=messages.ERROR)
-        else:
-            self.message_user(
-                request,
-                f"Stopped MCP server (PID {pid}).",
-                level=messages.SUCCESS,
-            )
-        return self._redirect_to_changelist()
-
-    def server_status(self, request):
-        status = mcp_process.get_status()
-        if status["running"]:
-            msg = f"MCP server is running (PID {status['pid']})."
-            level = messages.INFO
-        else:
-            msg = "MCP server is not running."
-            level = messages.WARNING
-        if status.get("last_error"):
-            msg = f"{msg} {status['last_error']}"
-        self.message_user(request, msg, level=level)
-        return self._redirect_to_changelist()
-
-
 class EnergyCreditInline(admin.TabularInline):
     model = EnergyCredit
     fields = ("amount_kw", "created_by", "created_on")
@@ -2390,199 +2497,15 @@ class ProductAdminForm(forms.ModelForm):
         widgets = {"odoo_product": OdooProductWidget}
 
 
-class ProductFetchWizardForm(forms.Form):
-    name = forms.CharField(label="Name", required=False)
-    default_code = forms.CharField(label="Internal reference", required=False)
-    barcode = forms.CharField(label="Barcode", required=False)
-    renewal_period = forms.IntegerField(
-        label="Renewal period (days)", min_value=1, initial=30
-    )
-
-    def __init__(self, *args, require_search_terms=True, **kwargs):
-        self.require_search_terms = require_search_terms
-        super().__init__(*args, **kwargs)
-
-    def clean(self):
-        cleaned = super().clean()
-        if self.require_search_terms:
-            if not any(
-                cleaned.get(field) for field in ("name", "default_code", "barcode")
-            ):
-                raise forms.ValidationError(
-                    _("Enter at least one field to search for a product.")
-                )
-        return cleaned
-
-    def build_domain(self):
-        domain = []
-        if self.cleaned_data.get("name"):
-            domain.append(("name", "ilike", self.cleaned_data["name"]))
-        if self.cleaned_data.get("default_code"):
-            domain.append(("default_code", "ilike", self.cleaned_data["default_code"]))
-        if self.cleaned_data.get("barcode"):
-            domain.append(("barcode", "ilike", self.cleaned_data["barcode"]))
-        return domain
-
-
 @admin.register(Product)
 class ProductAdmin(EntityModelAdmin):
     form = ProductAdminForm
-    actions = ["fetch_odoo_product", "register_from_odoo"]
+    actions = ["register_from_odoo"]
     change_list_template = "admin/core/product/change_list.html"
 
     def _odoo_profile_admin(self):
         return self.admin_site._registry.get(OdooProfile)
 
-    def _search_odoo_products(self, profile, form):
-        domain = form.build_domain()
-        return profile.execute(
-            "product.product",
-            "search_read",
-            [domain],
-            fields=[
-                "name",
-                "default_code",
-                "barcode",
-                "description_sale",
-            ],
-            limit=50,
-        )
-
-    @admin.action(description="Fetch Odoo Product")
-    def fetch_odoo_product(self, request, queryset):
-        profile = getattr(request.user, "odoo_profile", None)
-        has_credentials = bool(profile and profile.is_verified)
-        profile_admin = self._odoo_profile_admin()
-        profile_url = None
-        if profile_admin is not None:
-            profile_url = profile_admin.get_my_profile_url(request)
-
-        context = {
-            "opts": self.model._meta,
-            "queryset": queryset,
-            "action": "fetch_odoo_product",
-            "has_credentials": has_credentials,
-            "profile_url": profile_url,
-        }
-
-        if not has_credentials:
-            context["credential_error"] = _(
-                "Configure your Odoo employee credentials before fetching products."
-            )
-            return TemplateResponse(
-                request, "admin/core/product/fetch_odoo.html", context
-            )
-
-        is_import = "import" in request.POST
-        form_kwargs = {"require_search_terms": not is_import}
-        if request.method == "POST":
-            form = ProductFetchWizardForm(request.POST, **form_kwargs)
-        else:
-            form = ProductFetchWizardForm()
-
-        results = None
-        selected_product_id = request.POST.get("product_id", "")
-
-        if request.method == "POST" and form.is_valid():
-            try:
-                results = self._search_odoo_products(profile, form)
-            except Exception:
-                logger.exception(
-                    "Failed to fetch Odoo products for user %s (profile_id=%s, host=%s, database=%s)",
-                    getattr(getattr(request, "user", None), "pk", None),
-                    getattr(profile, "pk", None),
-                    getattr(profile, "host", None),
-                    getattr(profile, "database", None),
-                )
-                form.add_error(None, _("Unable to fetch products from Odoo."))
-                results = []
-            else:
-                if is_import:
-                    if not self.has_add_permission(request):
-                        form.add_error(
-                            None, _("You do not have permission to add products.")
-                        )
-                    else:
-                        product_id = request.POST.get("product_id")
-                        if not product_id:
-                            form.add_error(None, _("Select a product to import."))
-                        else:
-                            try:
-                                odoo_id = int(product_id)
-                            except (TypeError, ValueError):
-                                form.add_error(None, _("Invalid product selection."))
-                            else:
-                                match = next(
-                                    (item for item in results if item.get("id") == odoo_id),
-                                    None,
-                                )
-                                if not match:
-                                    form.add_error(
-                                        None,
-                                        _(
-                                            "The selected product was not found. Run the search again."
-                                        ),
-                                    )
-                                else:
-                                    existing = self.model.objects.filter(
-                                        odoo_product__id=odoo_id
-                                    ).first()
-                                    if existing:
-                                        self.message_user(
-                                            request,
-                                            _(
-                                                "Product %(name)s already imported; opening existing record."
-                                            )
-                                            % {"name": existing.name},
-                                            level=messages.WARNING,
-                                        )
-                                        return HttpResponseRedirect(
-                                            reverse(
-                                                "admin:%s_%s_change"
-                                                % (
-                                                    existing._meta.app_label,
-                                                    existing._meta.model_name,
-                                                ),
-                                                args=[existing.pk],
-                                            )
-                                        )
-                                    product = self.model.objects.create(
-                                        name=match.get("name") or f"Odoo Product {odoo_id}",
-                                        description=match.get("description_sale", "") or "",
-                                        renewal_period=form.cleaned_data["renewal_period"],
-                                        odoo_product={
-                                            "id": odoo_id,
-                                            "name": match.get("name", ""),
-                                        },
-                                    )
-                                    self.log_addition(
-                                        request, product, "Imported product from Odoo"
-                                    )
-                                    self.message_user(
-                                        request,
-                                        _("Imported %(name)s from Odoo.")
-                                        % {"name": product.name},
-                                    )
-                                    return HttpResponseRedirect(
-                                        reverse(
-                                            "admin:%s_%s_change"
-                                            % (
-                                                product._meta.app_label,
-                                                product._meta.model_name,
-                                            ),
-                                            args=[product.pk],
-                                        )
-                                    )
-        context.update(
-            {
-                "form": form,
-                "results": results,
-                "selected_product_id": selected_product_id,
-            }
-        )
-        context["media"] = self.media + form.media
-        return TemplateResponse(request, "admin/core/product/fetch_odoo.html", context)
-
     def get_urls(self):
         urls = super().get_urls()
         custom = [
@@ -2623,7 +2546,7 @@ class ProductAdmin(EntityModelAdmin):
         profile = getattr(request.user, "odoo_profile", None)
         if not profile or not profile.is_verified:
             context["credential_error"] = _(
-                "Configure your Odoo employee credentials before registering products."
+                "Configure your CRM employee credentials before registering products."
             )
             return context, None
 
@@ -2631,7 +2554,6 @@ class ProductAdmin(EntityModelAdmin):
             products = profile.execute(
                 "product.product",
                 "search_read",
-                [[]],
                 fields=[
                     "name",
                     "description_sale",
@@ -2640,8 +2562,30 @@ class ProductAdmin(EntityModelAdmin):
                 ],
                 limit=0,
             )
-        except Exception:
+        except Exception as exc:
+            logger.exception(
+                "Failed to fetch Odoo products for user %s (profile_id=%s, host=%s, database=%s)",
+                getattr(getattr(request, "user", None), "pk", None),
+                getattr(profile, "pk", None),
+                getattr(profile, "host", None),
+                getattr(profile, "database", None),
+            )
             context["error"] = _("Unable to fetch products from Odoo.")
+            if getattr(request.user, "is_superuser", False):
+                fault = getattr(exc, "faultString", "")
+                message = str(exc)
+                details = [
+                    f"Host: {getattr(profile, 'host', '')}",
+                    f"Database: {getattr(profile, 'database', '')}",
+                    f"User ID: {getattr(profile, 'odoo_uid', '')}",
+                ]
+                if fault and fault != message:
+                    details.append(f"Fault: {fault}")
+                if message:
+                    details.append(f"Exception: {type(exc).__name__}: {message}")
+                else:
+                    details.append(f"Exception type: {type(exc).__name__}")
+                context["debug_error"] = "\n".join(details)
             return context, []
 
         context["has_credentials"] = True
@@ -2810,6 +2754,12 @@ class RFIDResource(resources.ModelResource):
         account_column = account_column_for_field(account_field)
         self.fields["energy_accounts"].column_name = account_column
 
+    def get_queryset(self):
+        manager = getattr(self._meta.model, "all_objects", None)
+        if manager is not None:
+            return manager.all()
+        return super().get_queryset()
+
     def dehydrate_energy_accounts(self, obj):
         return serialize_accounts(obj, self.account_field)
 
@@ -2823,6 +2773,11 @@ class RFIDResource(resources.ModelResource):
         else:
             instance.energy_accounts.clear()
 
+    def before_save_instance(self, instance, row, **kwargs):
+        if getattr(instance, "is_deleted", False):
+            instance.is_deleted = False
+        super().before_save_instance(instance, row, **kwargs)
+
     class Meta:
         model = RFID
         fields = (
@@ -2835,6 +2790,7 @@ class RFIDResource(resources.ModelResource):
             "post_auth_command",
             "allowed",
             "color",
+            "endianness",
             "kind",
             "released",
             "last_seen_on",
@@ -2849,6 +2805,7 @@ class RFIDResource(resources.ModelResource):
             "post_auth_command",
             "allowed",
             "color",
+            "endianness",
             "kind",
             "released",
             "last_seen_on",
@@ -2899,7 +2856,7 @@ class CopyRFIDForm(forms.Form):
         normalized = (cleaned or "").strip().upper()
         if not normalized:
             raise forms.ValidationError(_("RFID value is required."))
-        if RFID.objects.filter(rfid=normalized).exists():
+        if RFID.matching_queryset(normalized).exists():
             raise forms.ValidationError(
                 _("An RFID with this value already exists.")
             )
@@ -2919,11 +2876,12 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
         "user_data_flag",
         "color",
         "kind",
+        "endianness_short",
         "released",
         "allowed",
         "last_seen_on",
     )
-    list_filter = ("color", "released", "allowed")
+    list_filter = ("color", "endianness", "released", "allowed")
     search_fields = ("label_id", "rfid", "custom_label")
     autocomplete_fields = ["energy_accounts"]
     raw_id_fields = ["reference"]
@@ -2932,9 +2890,12 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
         "print_card_labels",
         "print_release_form",
         "copy_rfids",
+        "merge_rfids",
         "toggle_selected_user_data",
+        "toggle_selected_released",
+        "toggle_selected_allowed",
     ]
-    readonly_fields = ("added_on", "last_seen_on")
+    readonly_fields = ("added_on", "last_seen_on", "reversed_uid")
     form = RFIDForm
 
     def get_import_resource_kwargs(self, request, form=None, **kwargs):
@@ -2980,6 +2941,14 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
     def user_data_flag(self, obj):
         return getattr(obj, "is_user_data", False)
 
+    @admin.display(description=_("End"), ordering="endianness")
+    def endianness_short(self, obj):
+        labels = {
+            RFID.BIG_ENDIAN: _("Big"),
+            RFID.LITTLE_ENDIAN: _("Little"),
+        }
+        return labels.get(obj.endianness, obj.get_endianness_display())
+
     def scan_rfids(self, request, queryset):
         return redirect("admin:core_rfid_scan")
 
@@ -3030,6 +2999,50 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
                 level=messages.WARNING,
             )
 
+    @admin.action(description=_("Toggle Released flag"))
+    def toggle_selected_released(self, request, queryset):
+        manager = getattr(self.model, "all_objects", self.model.objects)
+        toggled = 0
+        for tag in queryset:
+            new_state = not tag.released
+            manager.filter(pk=tag.pk).update(released=new_state)
+            tag.released = new_state
+            toggled += 1
+
+        if toggled:
+            self.message_user(
+                request,
+                ngettext(
+                    "Toggled released flag for %(count)d RFID.",
+                    "Toggled released flag for %(count)d RFIDs.",
+                    toggled,
+                )
+                % {"count": toggled},
+                level=messages.SUCCESS,
+            )
+
+    @admin.action(description=_("Toggle Allowed flag"))
+    def toggle_selected_allowed(self, request, queryset):
+        manager = getattr(self.model, "all_objects", self.model.objects)
+        toggled = 0
+        for tag in queryset:
+            new_state = not tag.allowed
+            manager.filter(pk=tag.pk).update(allowed=new_state)
+            tag.allowed = new_state
+            toggled += 1
+
+        if toggled:
+            self.message_user(
+                request,
+                ngettext(
+                    "Toggled allowed flag for %(count)d RFID.",
+                    "Toggled allowed flag for %(count)d RFIDs.",
+                    toggled,
+                )
+                % {"count": toggled},
+                level=messages.SUCCESS,
+            )
+
     @admin.action(description=_("Copy RFID"))
     def copy_rfids(self, request, queryset):
         if queryset.count() != 1:
@@ -3120,6 +3133,145 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
         context["media"] = self.media + form.media
         return TemplateResponse(request, "admin/core/rfid/copy.html", context)
 
+    @admin.action(description=_("Merge RFID cards"))
+    def merge_rfids(self, request, queryset):
+        tags = list(queryset.prefetch_related("energy_accounts"))
+        if len(tags) < 2:
+            self.message_user(
+                request,
+                _("Select at least two RFIDs to merge."),
+                level=messages.WARNING,
+            )
+            return None
+
+        normalized_map: dict[int, str] = {}
+        groups: defaultdict[str, list[RFID]] = defaultdict(list)
+        unmatched = 0
+        for tag in tags:
+            normalized = RFID.normalize_code(tag.rfid)
+            normalized_map[tag.pk] = normalized
+            if not normalized:
+                unmatched += 1
+                continue
+            prefix = normalized[: RFID.MATCH_PREFIX_LENGTH]
+            groups[prefix].append(tag)
+
+        merge_groups: list[list[RFID]] = []
+        skipped = unmatched
+        for prefix, group in groups.items():
+            if len(group) < 2:
+                skipped += len(group)
+                continue
+            group.sort(
+                key=lambda item: (
+                    len(normalized_map.get(item.pk, "")),
+                    normalized_map.get(item.pk, ""),
+                    item.pk,
+                )
+            )
+            merge_groups.append(group)
+
+        if not merge_groups:
+            self.message_user(
+                request,
+                _("No matching RFIDs were found to merge."),
+                level=messages.WARNING,
+            )
+            return None
+
+        merged_tags = 0
+        merged_groups = 0
+        conflicting_accounts = 0
+        with transaction.atomic():
+            for group in merge_groups:
+                canonical = group[0]
+                update_fields: set[str] = set()
+                existing_account_ids = set(
+                    canonical.energy_accounts.values_list("pk", flat=True)
+                )
+                for tag in group[1:]:
+                    other_value = normalized_map.get(tag.pk, "")
+                    if canonical.adopt_rfid(other_value):
+                        update_fields.add("rfid")
+                        normalized_map[canonical.pk] = RFID.normalize_code(
+                            canonical.rfid
+                        )
+                    accounts = list(tag.energy_accounts.all())
+                    if accounts:
+                        transferable: list[EnergyAccount] = []
+                        for account in accounts:
+                            if existing_account_ids and account.pk not in existing_account_ids:
+                                conflicting_accounts += 1
+                                continue
+                            transferable.append(account)
+                        if transferable:
+                            canonical.energy_accounts.add(*transferable)
+                            existing_account_ids.update(
+                                account.pk for account in transferable
+                            )
+                    if tag.allowed and not canonical.allowed:
+                        canonical.allowed = True
+                        update_fields.add("allowed")
+                    if tag.released and not canonical.released:
+                        canonical.released = True
+                        update_fields.add("released")
+                    if tag.key_a_verified and not canonical.key_a_verified:
+                        canonical.key_a_verified = True
+                        update_fields.add("key_a_verified")
+                    if tag.key_b_verified and not canonical.key_b_verified:
+                        canonical.key_b_verified = True
+                        update_fields.add("key_b_verified")
+                    if tag.last_seen_on and (
+                        not canonical.last_seen_on
+                        or tag.last_seen_on > canonical.last_seen_on
+                    ):
+                        canonical.last_seen_on = tag.last_seen_on
+                        update_fields.add("last_seen_on")
+                    if not canonical.origin_node and tag.origin_node_id:
+                        canonical.origin_node = tag.origin_node
+                        update_fields.add("origin_node")
+                    merged_tags += 1
+                    tag.delete()
+                if update_fields:
+                    canonical.save(update_fields=sorted(update_fields))
+                merged_groups += 1
+
+        if merged_tags:
+            self.message_user(
+                request,
+                ngettext(
+                    "Merged %(removed)d RFID into %(groups)d canonical record.",
+                    "Merged %(removed)d RFIDs into %(groups)d canonical records.",
+                    merged_tags,
+                )
+                % {"removed": merged_tags, "groups": merged_groups},
+                level=messages.SUCCESS,
+            )
+
+        if skipped:
+            self.message_user(
+                request,
+                ngettext(
+                    "Skipped %(count)d RFID because it did not share the first %(length)d characters with another selection.",
+                    "Skipped %(count)d RFIDs because they did not share the first %(length)d characters with another selection.",
+                    skipped,
+                )
+                % {"count": skipped, "length": RFID.MATCH_PREFIX_LENGTH},
+                level=messages.WARNING,
+            )
+
+        if conflicting_accounts:
+            self.message_user(
+                request,
+                ngettext(
+                    "Skipped %(count)d energy account because the RFID was already linked to a different account.",
+                    "Skipped %(count)d energy accounts because the RFID was already linked to a different account.",
+                    conflicting_accounts,
+                )
+                % {"count": conflicting_accounts},
+                level=messages.WARNING,
+            )
+
     def _render_card_labels(
         self,
         request,
@@ -3492,11 +3644,13 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
                 "toggle_url": toggle_url,
                 "toggle_label": toggle_label,
                 "public_view_url": public_view_url,
+                "deep_read_url": reverse("rfid-scan-deep"),
             }
         )
         context["title"] = _("Scan RFIDs")
         context["opts"] = self.model._meta
         context["show_release_info"] = True
+        context["default_endianness"] = RFID.BIG_ENDIAN
         return render(request, "admin/core/rfid/scan.html", context)
 
     def scan_next(self, request):
@@ -3510,20 +3664,71 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
                 return JsonResponse({"error": "Invalid JSON payload"}, status=400)
             rfid = payload.get("rfid") or payload.get("value")
             kind = payload.get("kind")
-            result = validate_rfid_value(rfid, kind=kind)
+            endianness = payload.get("endianness")
+            result = validate_rfid_value(rfid, kind=kind, endianness=endianness)
         else:
-            result = scan_sources(request)
+            endianness = request.GET.get("endianness")
+            result = scan_sources(request, endianness=endianness)
         status = 500 if result.get("error") else 200
         return JsonResponse(result, status=status)
 
 
+class ClientReportRecurrencyFilter(admin.SimpleListFilter):
+    title = "Recurrency"
+    parameter_name = "recurrency"
+
+    def lookups(self, request, model_admin):
+        for value, label in ClientReportSchedule.PERIODICITY_CHOICES:
+            yield (value, label)
+
+    def queryset(self, request, queryset):
+        value = self.value()
+        if not value:
+            return queryset
+        if value == ClientReportSchedule.PERIODICITY_NONE:
+            return queryset.filter(
+                Q(schedule__isnull=True) | Q(schedule__periodicity=value)
+            )
+        return queryset.filter(schedule__periodicity=value)
+
+
 @admin.register(ClientReport)
 class ClientReportAdmin(EntityModelAdmin):
-    list_display = ("created_on", "start_date", "end_date")
+    list_display = (
+        "created_on",
+        "period_range",
+        "owner",
+        "recurrency_display",
+        "total_kw_period_display",
+        "download_link",
+    )
+    list_select_related = ("schedule", "owner")
+    list_filter = ("owner", ClientReportRecurrencyFilter)
     readonly_fields = ("created_on", "data")
 
     change_list_template = "admin/core/clientreport/change_list.html"
 
+    def period_range(self, obj):
+        return str(obj)
+
+    period_range.short_description = "Period"
+
+    def recurrency_display(self, obj):
+        return obj.periodicity_label
+
+    recurrency_display.short_description = "Recurrency"
+
+    def total_kw_period_display(self, obj):
+        return f"{obj.total_kw_period:.2f}"
+
+    total_kw_period_display.short_description = "Total kW (period)"
+
+    def download_link(self, obj):
+        url = reverse("admin:core_clientreport_download", args=[obj.pk])
+        return format_html('<a href="{}">Download</a>', url)
+
+    download_link.short_description = "Download"
+
     class ClientReportForm(forms.Form):
         PERIOD_CHOICES = [
             ("range", "Date range"),
@@ -3559,8 +3764,28 @@ class ClientReportAdmin(EntityModelAdmin):
             label="Month",
             required=False,
             widget=forms.DateInput(attrs={"type": "month"}),
+            input_formats=["%Y-%m"],
             help_text="Generates the report for the calendar month that you select.",
         )
+        language = forms.ChoiceField(
+            label="Report language",
+            choices=settings.LANGUAGES,
+            help_text="Choose the language used for the generated report.",
+        )
+        title = forms.CharField(
+            label="Report title",
+            required=False,
+            max_length=200,
+            help_text="Optional heading that replaces the default report title.",
+        )
+        chargers = forms.ModelMultipleChoiceField(
+            label="Charge points",
+            queryset=Charger.objects.filter(connector_id__isnull=True)
+            .order_by("display_name", "charger_id"),
+            required=False,
+            widget=forms.CheckboxSelectMultiple,
+            help_text="Choose which charge points are included in the report.",
+        )
         owner = forms.ModelChoiceField(
             queryset=get_user_model().objects.all(),
             required=False,
@@ -3578,10 +3803,10 @@ class ClientReportAdmin(EntityModelAdmin):
             initial=ClientReportSchedule.PERIODICITY_NONE,
             help_text="Defines how often the report should be generated automatically.",
         )
-        disable_emails = forms.BooleanField(
-            label="Disable email delivery",
+        enable_emails = forms.BooleanField(
+            label="Enable email delivery",
             required=False,
-            help_text="Generate files without sending emails.",
+            help_text="Send the report via email to the recipients listed above.",
         )
 
         def __init__(self, *args, request=None, **kwargs):
@@ -3593,6 +3818,13 @@ class ClientReportAdmin(EntityModelAdmin):
                 and request.user.is_authenticated
             ):
                 self.fields["owner"].initial = request.user.pk
+            self.fields["chargers"].widget.attrs["class"] = "charger-options"
+            language_initial = ClientReport.default_language()
+            if request:
+                language_initial = ClientReport.normalize_language(
+                    getattr(request, "LANGUAGE_CODE", language_initial)
+                )
+            self.fields["language"].initial = language_initial
 
         def clean(self):
             cleaned = super().clean()
@@ -3637,6 +3869,10 @@ class ClientReportAdmin(EntityModelAdmin):
                 emails.append(candidate)
             return emails
 
+        def clean_title(self):
+            title = self.cleaned_data.get("title")
+            return ClientReport.normalize_title(title)
+
     def get_urls(self):
         urls = super().get_urls()
         custom = [
@@ -3645,6 +3881,16 @@ class ClientReportAdmin(EntityModelAdmin):
                 self.admin_site.admin_view(self.generate_view),
                 name="core_clientreport_generate",
             ),
+            path(
+                "generate/action/",
+                self.admin_site.admin_view(self.generate_report),
+                name="core_clientreport_generate_report",
+            ),
+            path(
+                "download/<int:report_id>/",
+                self.admin_site.admin_view(self.download_view),
+                name="core_clientreport_download",
+            ),
         ]
         return custom + urls
 
@@ -3652,40 +3898,127 @@ class ClientReportAdmin(EntityModelAdmin):
         form = self.ClientReportForm(request.POST or None, request=request)
         report = None
         schedule = None
+        download_url = None
         if request.method == "POST" and form.is_valid():
             owner = form.cleaned_data.get("owner")
             if not owner and request.user.is_authenticated:
                 owner = request.user
+            enable_emails = form.cleaned_data.get("enable_emails", False)
+            disable_emails = not enable_emails
+            recipients = form.cleaned_data.get("destinations") if enable_emails else []
+            chargers = list(form.cleaned_data.get("chargers") or [])
+            language = form.cleaned_data.get("language")
+            title = form.cleaned_data.get("title")
             report = ClientReport.generate(
                 form.cleaned_data["start"],
                 form.cleaned_data["end"],
                 owner=owner,
-                recipients=form.cleaned_data.get("destinations"),
-                disable_emails=form.cleaned_data.get("disable_emails", False),
+                recipients=recipients,
+                disable_emails=disable_emails,
+                chargers=chargers,
+                language=language,
+                title=title,
             )
             report.store_local_copy()
+            if chargers:
+                report.chargers.set(chargers)
+            if enable_emails and recipients:
+                delivered = report.send_delivery(
+                    to=recipients,
+                    cc=[],
+                    outbox=ClientReport.resolve_outbox_for_owner(owner),
+                    reply_to=ClientReport.resolve_reply_to_for_owner(owner),
+                )
+                if delivered:
+                    report.recipients = delivered
+                    report.save(update_fields=["recipients"])
+                    self.message_user(
+                        request,
+                        "Consumer report emailed to the selected recipients.",
+                        messages.SUCCESS,
+                    )
             recurrence = form.cleaned_data.get("recurrence")
             if recurrence and recurrence != ClientReportSchedule.PERIODICITY_NONE:
                 schedule = ClientReportSchedule.objects.create(
                     owner=owner,
                     created_by=request.user if request.user.is_authenticated else None,
                     periodicity=recurrence,
-                    email_recipients=form.cleaned_data.get("destinations", []),
-                    disable_emails=form.cleaned_data.get("disable_emails", False),
+                    email_recipients=recipients,
+                    disable_emails=disable_emails,
+                    language=language,
+                    title=title,
                 )
+                if chargers:
+                    schedule.chargers.set(chargers)
                 report.schedule = schedule
                 report.save(update_fields=["schedule"])
                 self.message_user(
                     request,
-                    "Client report schedule created; future reports will be generated automatically.",
+                    "Consumer report schedule created; future reports will be generated automatically.",
                     messages.SUCCESS,
                 )
+            if disable_emails:
+                self.message_user(
+                    request,
+                    "Consumer report generated. The download will begin automatically.",
+                    messages.SUCCESS,
+                )
+                redirect_url = f"{reverse('admin:core_clientreport_generate')}?download={report.pk}"
+                return HttpResponseRedirect(redirect_url)
+        download_param = request.GET.get("download")
+        if download_param:
+            try:
+                download_report = ClientReport.objects.get(pk=download_param)
+            except ClientReport.DoesNotExist:
+                pass
+            else:
+                download_url = reverse(
+                    "admin:core_clientreport_download", args=[download_report.pk]
+                )
         context = self.admin_site.each_context(request)
-        context.update({"form": form, "report": report, "schedule": schedule})
+        context.update(
+            {
+                "form": form,
+                "report": report,
+                "schedule": schedule,
+                "download_url": download_url,
+                "opts": self.model._meta,
+            }
+        )
         return TemplateResponse(
             request, "admin/core/clientreport/generate.html", context
         )
 
+    def get_changelist_actions(self, request):
+        parent = getattr(super(), "get_changelist_actions", None)
+        actions: list[str] = []
+        if callable(parent):
+            parent_actions = parent(request)
+            if parent_actions:
+                actions.extend(parent_actions)
+        if "generate_report" not in actions:
+            actions.append("generate_report")
+        return actions
+
+    def generate_report(self, request):
+        return HttpResponseRedirect(reverse("admin:core_clientreport_generate"))
+
+    generate_report.label = _("Generate report")
+
+    def download_view(self, request, report_id: int):
+        report = get_object_or_404(ClientReport, pk=report_id)
+        pdf_path = report.ensure_pdf()
+        if not pdf_path.exists():
+            raise Http404("Report file unavailable")
+        end_date = report.end_date
+        if hasattr(end_date, "isoformat"):
+            end_date_str = end_date.isoformat()
+        else:  # pragma: no cover - fallback for unexpected values
+            end_date_str = str(end_date)
+        filename = f"consumer-report-{end_date_str}.pdf"
+        response = FileResponse(pdf_path.open("rb"), content_type="application/pdf")
+        response["Content-Disposition"] = f'attachment; filename="{filename}"'
+        return response
 
 @admin.register(PackageRelease)
 class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
@@ -3693,6 +4026,7 @@ class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
     list_display = (
         "version",
         "package_link",
+        "severity",
         "is_current",
         "pypi_url",
         "github_url",
@@ -3709,6 +4043,7 @@ class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
         "package",
         "release_manager",
         "version",
+        "severity",
         "revision",
         "is_current",
         "pypi_url",
@@ -3746,9 +4081,9 @@ class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
             self.message_user(request, str(exc), messages.ERROR)
             return
         releases = resp.json().get("releases", {})
-        created = 0
         updated = 0
         restored = 0
+        missing: list[str] = []
 
         for version, files in releases.items():
             release_on = self._release_on_from_files(files)
@@ -3773,23 +4108,11 @@ class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
                 if update_fields:
                     release.save(update_fields=update_fields)
                 continue
-            PackageRelease.objects.create(
-                package=package,
-                release_manager=package.release_manager,
-                version=version,
-                revision="",
-                pypi_url=f"https://pypi.org/project/{package.name}/{version}/",
-                release_on=release_on,
-            )
-            created += 1
+            missing.append(version)
 
-        if created or updated or restored:
+        if updated or restored:
             PackageRelease.dump_fixture()
             message_parts = []
-            if created:
-                message_parts.append(
-                    f"Created {created} release{'s' if created != 1 else ''} from PyPI"
-                )
             if updated:
                 message_parts.append(
                     f"Updated release date for {updated} release"
@@ -3800,8 +4123,17 @@ class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
                     f"Restored {restored} release{'s' if restored != 1 else ''}"
                 )
             self.message_user(request, "; ".join(message_parts), messages.SUCCESS)
-        else:
-            self.message_user(request, "No new releases found", messages.INFO)
+        elif not missing:
+            self.message_user(request, "No matching releases found", messages.INFO)
+
+        if missing:
+            versions = ", ".join(sorted(missing))
+            count = len(missing)
+            message = (
+                "Manual creation required for "
+                f"{count} release{'s' if count != 1 else ''}: {versions}"
+            )
+            self.message_user(request, message, messages.WARNING)
 
     refresh_from_pypi.label = "Refresh from PyPI"
     refresh_from_pypi.short_description = "Refresh from PyPI"