django-smartbase-admin 2.3.9__tar.gz → 2.4.0__tar.gz

{django_smartbase_admin-2.3.9 → django_smartbase_admin-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-smartbase-admin
-Version: 2.3.9
+Version: 2.4.0
 Summary: 
 Home-page: https://smartbase-sk.github.io/django-smartbase-admin-docs/
 License: MIT

{django_smartbase_admin-2.3.9 → django_smartbase_admin-2.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-smartbase-admin"
-version = "2.3.9"
+version = "2.4.0"
 description = ""
 authors = ["SmartBase <info@smartbase.sk>"]
 readme = "README.md"

{django_smartbase_admin-2.3.9 → django_smartbase_admin-2.4.0}/src/django_smartbase_admin/mcp/mcp.py

@@ -218,6 +218,57 @@ def _validate_sort(admin, request, sort, field_map=None) -> None:
             raise ValueError(f"sort dir must be 'asc' or 'desc', got {entry['dir']!r}")
 
 
+def _sort_keys_to_fields(sort: list | None, field_map) -> list | None:
+    """Translate validated public sort names to browser data keys."""
+    if not sort:
+        return sort
+    return [{**entry, "field": field_map[entry["field"]].field} for entry in sort]
+
+
+def _sort_keys_to_names(sort: list | None, field_map) -> list | None:
+    """Translate browser sort keys from a stored preset to public names."""
+    if not sort:
+        return sort
+    field_to_name: dict = {}
+    for name, field in (field_map or {}).items():
+        field_to_name.setdefault(field.field, name)
+    return [
+        (
+            {**entry, "field": field_to_name.get(entry["field"], entry["field"])}
+            if isinstance(entry, dict) and "field" in entry
+            else entry
+        )
+        for entry in sort
+    ]
+
+
+def _row_keys_to_names(rows: list[dict], fields: list[str], field_map) -> None:
+    """Translate declared browser row keys back to MCP public field names."""
+    mappings = [
+        (name, field_map[name].field)
+        for name in fields
+        if name in field_map and field_map[name].field != name
+    ]
+    if not mappings:
+        return
+
+    public_names = set(fields)
+    internal_keys = {field_key for _name, field_key in mappings}
+
+    def translate(row):
+        translated = {
+            name: row[field_key] for name, field_key in mappings if field_key in row
+        }
+        for field_key in internal_keys - public_names:
+            row.pop(field_key, None)
+        row.update(translated)
+        for child in row.get("_children") or []:
+            translate(child)
+
+    for row in rows:
+        translate(row)
+
+
 def _decode_preset_url_params(url_params) -> dict:
     """Turn a preset's raw ``url_params`` blob (JSON string or dict) into
     the kwargs ``list_rows`` accepts: ``filter_data``,
@@ -464,14 +515,31 @@ class SBAdminTools(MCPToolset):
         if detail not in ("index", "full"):
             raise ValueError(f"detail must be 'index' or 'full', got {detail!r}.")
 
-        # Resolved against the same registry the unscoped call iterates, so
-        # scoping can only ever narrow that set — never reach a widget or
-        # inline view_id that ``admin_entry`` cannot describe.
-        candidates = [
-            admin
-            for admin in sb_admin_site._registry.values()
-            if isinstance(admin, SBAdminBaseListView)
-        ]
+        # Model admins live in the Django admin registry, while configured
+        # list views (notably ``ModelTranslationView``) live only in the
+        # role configuration.  Both are top-level MCP surfaces.  Do not walk
+        # ``view_map`` here: it also contains inlines and dashboard/detail
+        # widgets, which are discovered through their owning admin instead.
+        configured_views = getattr(
+            request.request_data.configuration, "registered_views", ()
+        )
+        candidates_by_id = {
+            candidate.get_id(): candidate
+            for candidate in configured_views
+            if isinstance(candidate, SBAdminBaseListView)
+            and candidate.model is not None
+        }
+        # Match ``SBAdminRoleConfiguration.init_view_map`` collision
+        # semantics: a real model admin wins over a configured view with the
+        # same id.
+        candidates_by_id.update(
+            {
+                admin.get_id(): admin
+                for admin in sb_admin_site._registry.values()
+                if isinstance(admin, SBAdminBaseListView)
+            }
+        )
+        candidates = list(candidates_by_id.values())
         if view_id:
             candidates = [admin for admin in candidates if admin.get_id() == view_id]
             if not candidates:
@@ -580,6 +648,8 @@ class SBAdminTools(MCPToolset):
                 decoded["filter_data"] = _filter_keys_to_names(
                     decoded["filter_data"], field_map
                 )
+            if "sort" in decoded:
+                decoded["sort"] = _sort_keys_to_names(decoded["sort"], field_map)
             return decoded
 
         if source == "static":
@@ -769,6 +839,7 @@ class SBAdminTools(MCPToolset):
         filter_data = _normalize_filter_keys(filter_data, field_map)
         _validate_filter_data(admin, request, filter_data, field_map)
         _validate_sort(admin, request, sort, field_map)
+        sort = _sort_keys_to_fields(sort, field_map)
         columns_data = build_columns_data(admin, request, fields, field_map)
 
         table_params: dict = {
@@ -832,6 +903,7 @@ class SBAdminTools(MCPToolset):
             if pk_attname != "id" and "id" not in row and pk_attname in row:
                 row["id"] = row[pk_attname]
         strip_html_cells(admin, request, rows)
+        _row_keys_to_names(rows, fields, field_map)
         if include_inlines:
             attach_inlines(admin, request, rows, include_inlines)
         if aggregates is not None:
@@ -854,7 +926,8 @@ class SBAdminTools(MCPToolset):
         )
         try:
             admin.init_view_dynamic(request, request.request_data)
-            result = SBAdminMCPDetailService.get_detail_data(
+            detail_service = SBAdminMCPDetailService.for_view(admin)
+            result = detail_service.get_detail_data(
                 admin, request, object_id, fields=fields
             )
             actions = detail_action_entries(admin, request, object_id=object_id)
@@ -1223,7 +1296,8 @@ class SBAdminTools(MCPToolset):
         )
         admin.init_view_dynamic(request, request.request_data)
         try:
-            return SBAdminMCPDetailService.update_detail_data(
+            detail_service = SBAdminMCPDetailService.for_view(admin)
+            return detail_service.update_detail_data(
                 admin,
                 request,
                 object_id,

{django_smartbase_admin-2.3.9 → django_smartbase_admin-2.4.0}/src/django_smartbase_admin/mcp/schema.py

@@ -265,8 +265,11 @@ def _inline_entry(inline, request) -> dict:
 
 def _inline_entries(admin, request) -> list[dict]:
     """Real + fake inlines the user can view; broken inlines are skipped."""
-    inline_classes = list(admin.get_inlines(request, None) or [])
-    inline_classes.extend(admin.get_sbadmin_fake_inlines(request, obj=None) or [])
+    inline_classes = []
+    if hasattr(admin, "get_inlines"):
+        inline_classes.extend(admin.get_inlines(request, None) or [])
+    if hasattr(admin, "get_sbadmin_fake_inlines"):
+        inline_classes.extend(admin.get_sbadmin_fake_inlines(request, obj=None) or [])
 
     entries: list[dict] = []
     for inline_class in inline_classes:
@@ -344,9 +347,8 @@ def _detail_field_entries(admin, request) -> list[str]:
     truth instead of two.
     """
     try:
-        names = list(
-            SBAdminMCPDetailService.get_detail_fields(admin, request, None) or []
-        )
+        detail_service = SBAdminMCPDetailService.for_view(admin)
+        names = list(detail_service.get_detail_fields(admin, request, None) or [])
     except ImproperlyConfigured:
         # List-only admin with no detail page — no fieldsets by design.
         # Mirrors how get_form autocomplete registration treats this case.

{django_smartbase_admin-2.3.9 → django_smartbase_admin-2.4.0}/src/django_smartbase_admin/mcp/service.py

@@ -101,6 +101,12 @@ class SBAdminMCPDetailService:
 
     # -- public ----------------------------------------------------------
 
+    @classmethod
+    def for_view(cls, view):
+        """Resolve a view-provided detail service, falling back to ModelAdmin."""
+        service_getter = getattr(view, "get_mcp_detail_service", None)
+        return service_getter() if service_getter else cls
+
     @classmethod
     def get_detail_fields(cls, admin, request, obj=None) -> list[str]:
         """Flat field list (form + readonly) the change form would show.

{django_smartbase_admin-2.3.9 → django_smartbase_admin-2.4.0}/src/django_smartbase_admin/mcp/tests/test_actions.py

@@ -199,6 +199,45 @@ class ListRowsTests(_ToolTestBase):
                 "filer_folder", fields=["name"]
             )
 
+    def test_annotated_column_uses_public_name_everywhere(self):
+        first_parent = Folder.objects.create(name="a parent")
+        last_parent = Folder.objects.create(name="z parent")
+        Folder.objects.create(name="sort child a", parent=first_parent)
+        Folder.objects.create(name="sort child z", parent=last_parent)
+        user = MagicMock(is_authenticated=True, is_superuser=True)
+        tools = SBAdminTools(request=build_mcp_request(user))
+
+        entry = tools.list_admins(view_id="filer_folder")["admin_views"][0]
+        self.assertIn("parent", {field["name"] for field in entry["fields"]})
+        result = tools.list_rows(
+            "filer_folder",
+            fields=["parent"],
+            sort=[{"field": "parent", "dir": "desc"}],
+            full_text_search="sort child",
+        )
+
+        self.assertEqual(
+            [row["parent"] for row in result["data"]],
+            ["z parent", "a parent"],
+        )
+        self.assertNotIn("parent_annt", result["data"][0])
+        filtered = tools.list_rows(
+            "filer_folder",
+            fields=["parent"],
+            filter_data={"parent": [{"value": first_parent.pk, "label": "a parent"}]},
+        )
+        self.assertEqual(filtered["data"][0]["parent"], "a parent")
+        with self.assertRaises(LookupError):
+            tools.list_rows("filer_folder", fields=["parent_annt"])
+        with self.assertRaises(ValueError):
+            tools.list_rows(
+                "filer_folder",
+                fields=["name"],
+                filter_data={
+                    "parent_annt": [{"value": first_parent.pk, "label": "a parent"}]
+                },
+            )
+
     def test_list_rows_respects_action_permission(self):
         class FolderListActionDeniedAdmin(FolderActionsTestAdmin):
             def has_permission_for_action(self, request, action):

{django_smartbase_admin-2.3.9 → django_smartbase_admin-2.4.0}/src/django_smartbase_admin/mcp/tests/test_fetch_filter_preset.py

@@ -63,6 +63,11 @@ class FolderPresetTestAdmin(SBAdmin):
                 choices=[("alpha", "Alpha"), ("beta", "Beta")]
             ),
         ),
+        SBAdminField(
+            name="parent",
+            annotate=F("parent__name"),
+            filter_field="parent",
+        ),
     )
     sbadmin_list_view_config = [
         {
@@ -96,6 +101,16 @@ class FolderPresetTestAdmin(SBAdmin):
                 }
             },
         },
+        {
+            "name": "By parent",
+            "url_params": {
+                "filterData": {
+                    "parent": [{"value": 1, "label": "Parent"}],
+                },
+                # Browser presets persist the Tabulator data key.
+                "tableParams": {"sort": [{"field": "parent_annt", "dir": "desc"}]},
+            },
+        },
     ]
 
 
@@ -213,3 +228,17 @@ class FetchFilterPresetTests(TestCase):
             decoded_str["filter_data"],
             {"status": [{"value": "alpha", "label": "Alpha"}]},
         )
+
+        # 8. Presets store internal filter and browser sort keys, but the
+        # fetched payload uses the public name advertised by list_admins.
+        decoded_parent = tools.fetch_filter_preset(
+            view_id="filer_folder", name="By parent", source="static"
+        )
+        self.assertEqual(
+            decoded_parent["filter_data"],
+            {"parent": [{"value": 1, "label": "Parent"}]},
+        )
+        self.assertEqual(
+            decoded_parent["sort"],
+            [{"field": "parent", "dir": "desc"}],
+        )

{django_smartbase_admin-2.3.9 → django_smartbase_admin-2.4.0}/src/django_smartbase_admin/mcp/tests/test_list_admins.py

@@ -9,7 +9,7 @@ through ``MCPToolset._add_tools_to`` — minus the JSON-RPC framing.
 
 from __future__ import annotations
 
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch
 
 from django.test import TestCase, override_settings
 from django.urls import path
@@ -27,6 +27,7 @@ from django_smartbase_admin.engine.filter_widgets import (
     MultipleChoiceFilterWidget,
 )
 from django_smartbase_admin.mcp.mcp import SBAdminTools
+from django_smartbase_admin.mcp.schema import _inline_entries
 from django_smartbase_admin.mcp.tests._common import (
     MCPToolTestConfig,
     build_mcp_request,
@@ -123,6 +124,38 @@ class ListAdminsTests(TestCase):
         # that ``full_text_search`` is a no-op for this admin.
         self.assertEqual(entry["search_fields"], [])
 
+    def test_fake_inline_provider_does_not_require_real_inline_provider(self):
+        class FakeInline:
+            def __init__(self, model, admin_site):
+                self.model = model
+                self.admin_site = admin_site
+
+            def has_view_or_change_permission(self, request, obj):
+                return True
+
+        class FakeOnlyAdmin:
+            model = Folder
+            admin_site = sb_admin_site
+
+            def get_sbadmin_fake_inlines(self, request, obj=None):
+                return [FakeInline]
+
+        request = build_mcp_request(MagicMock(is_authenticated=True))
+        expected = {"inline_name": "FakeInline"}
+        with (
+            patch(
+                "django_smartbase_admin.mcp.schema.is_fake_inline_batch_safe",
+                return_value=True,
+            ),
+            patch(
+                "django_smartbase_admin.mcp.schema._inline_entry",
+                return_value=expected,
+            ),
+        ):
+            entries = _inline_entries(FakeOnlyAdmin(), request)
+
+        self.assertEqual(entries, [expected])
+
     def test_whoami_is_omitted_when_unconfigured(self):
         user = MagicMock(
             id=1, is_authenticated=True, is_anonymous=False, is_superuser=True
@@ -364,7 +397,7 @@ class ListAdminsTests(TestCase):
         status = fields_by_name["status"]
         self.assertEqual(status["title"], "Status")
         self.assertEqual(status["filter"]["widget"], "MultipleChoiceFilterWidget")
-        # The filter is keyed by the column ``name`` in list_rows; the
+        # The filter is keyed by the column name in list_rows; the
         # internal ``filter_field`` is not surfaced.
         self.assertNotIn("filter_field", status["filter"])
         self.assertEqual(

django_smartbase_admin-2.4.0/src/django_smartbase_admin/mcp/tests/test_translations.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+from django.contrib.auth import get_user_model
+from django.core.exceptions import FieldError
+from django.db import connection, models
+from django.test import TransactionTestCase, override_settings
+from django.urls import path
+
+from django_smartbase_admin.admin.site import sb_admin_site
+from django_smartbase_admin.engine.const import TRANSLATION_MODEL_KEY
+from django_smartbase_admin.mcp.bridge import bind_sbadmin_request_data
+from django_smartbase_admin.mcp.mcp import SBAdminTools
+from django_smartbase_admin.mcp.service import SBAdminMCPDetailService
+from django_smartbase_admin.mcp.tests._common import (
+    MCPToolTestConfig,
+    build_mcp_request,
+)
+from django_smartbase_admin.mcp.translations import SBAdminMCPTranslationService
+from django_smartbase_admin.services.translations import SBAdminTranslationsService
+from django_smartbase_admin.views.translations_view import SBAdminTranslationsView
+
+
+class MCPTranslatedArticle(models.Model):
+    class Meta:
+        app_label = "django_smartbase_admin"
+
+    def __str__(self):
+        return str(self.pk)
+
+
+class MCPTranslatedArticleTranslation(models.Model):
+    master = models.ForeignKey(
+        MCPTranslatedArticle,
+        related_name="translations",
+        on_delete=models.CASCADE,
+    )
+    language_code = models.CharField(max_length=15)
+    title = models.CharField(max_length=100)
+    slug = models.SlugField(max_length=100, unique=True)
+
+    class Meta:
+        app_label = "django_smartbase_admin"
+        unique_together = (("language_code", "master"),)
+
+
+class _MCPTranslatedArticleParlerMeta:
+    def get_all_models(self):
+        return (MCPTranslatedArticleTranslation,)
+
+    def __getitem__(self, translation_model):
+        return SimpleNamespace(rel_name="translations")
+
+    def get_model_by_field(self, field_name):
+        if field_name in {"title", "slug"}:
+            return MCPTranslatedArticleTranslation
+        raise FieldError(field_name)
+
+
+MCPTranslatedArticle._parler_meta = _MCPTranslatedArticleParlerMeta()
+
+
+urlpatterns = [path("sb-admin/", sb_admin_site.urls)]
+
+
+@override_settings(
+    ROOT_URLCONF=__name__,
+    SB_ADMIN_CONFIGURATION="tests.sbadmin_config.MCPSBAdminConfiguration",
+    LANGUAGE_CODE="en",
+    LANGUAGES=(("en", "English"), ("de", "German"), ("fr", "French")),
+)
+class TranslationMCPTests(TransactionTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        with connection.schema_editor() as schema_editor:
+            schema_editor.create_model(MCPTranslatedArticle)
+            schema_editor.create_model(MCPTranslatedArticleTranslation)
+
+    @classmethod
+    def tearDownClass(cls):
+        with connection.schema_editor() as schema_editor:
+            schema_editor.delete_model(MCPTranslatedArticleTranslation)
+            schema_editor.delete_model(MCPTranslatedArticle)
+        super().tearDownClass()
+
+    def setUp(self):
+        super().setUp()
+        self.configuration = MCPToolTestConfig()
+        self._registered_views = self.configuration.registered_views
+        self._view_map = self.configuration.view_map
+        translations = SBAdminTranslationsView(
+            translations_definition=[
+                {
+                    "model_path": ("django_smartbase_admin.MCPTranslatedArticle"),
+                    "fields": ["title", "slug"],
+                }
+            ]
+        )
+        self.configuration.registered_views = [translations]
+        self.configuration.view_map = {}
+        self.configuration.init_registered_views()
+        self.configuration.init_view_map()
+        MCPToolTestConfig.view_permission_for = None
+
+        self.article = MCPTranslatedArticle.objects.create()
+        MCPTranslatedArticleTranslation.objects.create(
+            master=self.article,
+            language_code="en",
+            title="Source title",
+            slug="source-title",
+        )
+        MCPTranslatedArticleTranslation.objects.create(
+            master=self.article,
+            language_code="de",
+            title="German title",
+            slug="german-title",
+        )
+
+        self.view_id = SBAdminTranslationsService.get_translation_view_id(
+            MCPTranslatedArticle
+        )
+        self.translation_table = MCPTranslatedArticleTranslation._meta.db_table
+        user = get_user_model().objects.create_superuser(
+            username="translation-admin",
+            email="translation@example.com",
+            password="password",
+        )
+        self.tools = SBAdminTools(request=build_mcp_request(user))
+
+    def tearDown(self):
+        MCPToolTestConfig.view_permission_for = None
+        self.configuration.registered_views = self._registered_views
+        self.configuration.view_map = self._view_map
+        super().tearDown()
+
+    def test_translation_view_is_discoverable_and_listable(self):
+        view = self.tools.request.request_data.configuration.view_map[self.view_id]
+        self.assertIs(
+            SBAdminMCPDetailService.for_view(view),
+            SBAdminMCPTranslationService,
+        )
+
+        index = self.tools.list_admins(detail="index")["admin_views"]
+        self.assertIn(self.view_id, {entry["view_id"] for entry in index})
+
+        entry = self.tools.list_admins(view_id=self.view_id)["admin_views"][0]
+        self.assertEqual(entry["detail_fields"], ["title", "slug"])
+        field_names = {field["name"] for field in entry["fields"]}
+        source_title_key = f"{self.translation_table}_en__title"
+        self.assertIn("title", field_names)
+        self.assertIn(f"{self.translation_table}_de_status", field_names)
+        self.assertIn(f"{self.translation_table}_fr_status", field_names)
+
+        result = self.tools.list_rows(view_id=self.view_id, fields=["title"])
+        self.assertEqual(result["last_row"], 1)
+        self.assertIn("title", result["data"][0], result)
+        self.assertNotIn(source_title_key, result["data"][0], result)
+        self.assertEqual(result["data"][0]["title"], "Source title")
+
+    def test_fetch_and_update_translation_components(self):
+        detail = self.tools.fetch_detail(self.view_id, str(self.article.pk))
+        source_name = f"{self.translation_table}:en"
+        german_name = f"{self.translation_table}:de"
+        french_name = f"{self.translation_table}:fr"
+
+        self.assertEqual(
+            set(detail["components"]),
+            {source_name, german_name, french_name},
+        )
+        self.assertTrue(
+            detail["components"][source_name]["fields"]["title"]["readonly"]
+        )
+        self.assertFalse(
+            detail["components"][german_name]["fields"]["title"]["readonly"]
+        )
+        self.assertEqual(
+            detail["components"][german_name]["fields"]["title"]["value"],
+            "German title",
+        )
+        with self.assertRaises(LookupError):
+            self.tools.update_detail(
+                self.view_id,
+                str(self.article.pk),
+                component_values={source_name: {"title": "Changed source"}},
+            )
+
+        result = self.tools.update_detail(
+            self.view_id,
+            str(self.article.pk),
+            component_values={
+                german_name: {"title": "Updated German title"},
+                french_name: {
+                    "title": "French title",
+                    "slug": "french-title",
+                },
+            },
+        )
+
+        self.assertEqual(result["status"], "ok")
+        self.assertEqual(
+            MCPTranslatedArticleTranslation.objects.get(
+                master=self.article, language_code="de"
+            ).title,
+            "Updated German title",
+        )
+        self.assertEqual(
+            MCPTranslatedArticleTranslation.objects.get(
+                master=self.article, language_code="fr"
+            ).title,
+            "French title",
+        )
+        self.assertEqual(
+            MCPTranslatedArticleTranslation.objects.get(
+                master=self.article, language_code="en"
+            ).title,
+            "Source title",
+        )
+
+    def test_browser_detail_uses_shared_translation_forms(self):
+        request = self.tools.request
+        view = request.request_data.configuration.view_map[self.view_id]
+        german = MCPTranslatedArticleTranslation.objects.get(
+            master=self.article, language_code="de"
+        )
+        bind_sbadmin_request_data(
+            request,
+            view=self.view_id,
+            action="detail",
+            modifier="template",
+            object_id=str(self.article.pk),
+            method="POST",
+            post={
+                "id": str(german.pk),
+                "language_code": "de",
+                TRANSLATION_MODEL_KEY: self.translation_table,
+                "title": "Browser-updated title",
+                "slug": "browser-updated-title",
+            },
+        )
+
+        view.detail(request, "template", object_id=str(self.article.pk))
+
+        german.refresh_from_db()
+        self.assertEqual(german.title, "Browser-updated title")
+
+    def test_duplicate_unique_value_across_components_is_invalid(self):
+        german_name = f"{self.translation_table}:de"
+        french_name = f"{self.translation_table}:fr"
+
+        result = self.tools.update_detail(
+            self.view_id,
+            str(self.article.pk),
+            component_values={
+                german_name: {"slug": "duplicate-slug"},
+                french_name: {
+                    "title": "French title",
+                    "slug": "duplicate-slug",
+                },
+            },
+        )
+
+        self.assertEqual(result["status"], "invalid")
+        self.assertEqual(
+            result["errors"]["components"][french_name]["fields"]["slug"][0]["code"],
+            "unique",
+        )
+        self.assertEqual(
+            MCPTranslatedArticleTranslation.objects.get(
+                master=self.article,
+                language_code="de",
+            ).slug,
+            "german-title",
+        )
+        self.assertFalse(
+            MCPTranslatedArticleTranslation.objects.filter(
+                master=self.article,
+                language_code="fr",
+            ).exists()
+        )