arthexis 0.1.19__py3-none-any.whl → 0.1.21__py3-none-any.whl

core/admin.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 from io import BytesIO
 import os
 
@@ -90,9 +91,7 @@ from .models import (
     SecurityGroup,
     InviteLead,
     PublicWifiAccess,
-    AssistantProfile,
     Todo,
-    hash_key,
 )
 from .user_data import (
     EntityModelAdmin,
@@ -109,8 +108,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__)
@@ -1303,46 +1300,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 = ("assistant_name", "user_key", "scopes", "is_active")
-
-    class Meta:
-        model = AssistantProfile
-        fields = ("assistant_name", "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,
@@ -1473,12 +1430,6 @@ PROFILE_INLINE_CONFIG = {
             "secondary_pypi_url",
         ),
     },
-    AssistantProfile: {
-        "form": AssistantProfileInlineForm,
-        "fields": ("assistant_name", "user_key", "scopes", "is_active"),
-        "readonly_fields": ("user_key_hash", "created_at", "last_used_at"),
-        "template": "admin/edit_inline/profile_stacked.html",
-    },
 }
 
 
@@ -1525,7 +1476,6 @@ PROFILE_MODELS = (
     EmailOutbox,
     SocialProfile,
     ReleaseManager,
-    AssistantProfile,
 )
 USER_PROFILE_INLINES = [
     _build_profile_inline(model, "user") for model in PROFILE_MODELS
@@ -2012,188 +1962,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 = ("assistant_name", "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": (
-                    "assistant_name",
-                    "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")
@@ -2909,7 +2677,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.")
             )
@@ -2943,6 +2711,7 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
         "print_card_labels",
         "print_release_form",
         "copy_rfids",
+        "merge_rfids",
         "toggle_selected_user_data",
         "toggle_selected_released",
         "toggle_selected_allowed",
@@ -3177,6 +2946,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,
@@ -3549,6 +3457,7 @@ 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")

core/apps.py

@@ -348,9 +348,3 @@ class CoreConfig(AppConfig):
             weak=False,
         )
 
-        try:
-            from .mcp.auto_start import schedule_auto_start
-
-            schedule_auto_start(check_profiles_immediately=False)
-        except Exception:  # pragma: no cover - defensive
-            logger.exception("Failed to schedule MCP auto-start")

core/backends.py

@@ -81,10 +81,16 @@ class RFIDBackend:
         if not rfid_value:
             return None
 
-        tag = RFID.objects.filter(rfid=rfid_value).first()
-        if not tag or not tag.allowed:
+        tag = RFID.matching_queryset(rfid_value).filter(allowed=True).first()
+        if not tag:
             return None
 
+        update_fields: list[str] = []
+        if tag.adopt_rfid(rfid_value):
+            update_fields.append("rfid")
+        if update_fields:
+            tag.save(update_fields=update_fields)
+
         command = (tag.external_command or "").strip()
         if command:
             env = os.environ.copy()