django-smartbase-admin 1.0.37__py3-none-any.whl → 1.0.40__py3-none-any.whl

django_smartbase_admin/actions/admin_action_list.py

@@ -427,6 +427,11 @@ class SBAdminListAction(SBAdminAction):
                     data: row.get(data, None)
                     for data in self.view.sbadmin_list_display_data
                 }
+            # Include supporting_annotates values in additional_data
+            for field in visible_columns:
+                if field.supporting_annotates:
+                    for key in field.supporting_annotates.keys():
+                        additional_data[key] = row.get(key, None)
             for field_key, value in row.items():
                 if field_key in field_key_field_map:
                     field = field_key_field_map[field_key]

django_smartbase_admin/admin/widgets.py

@@ -11,7 +11,12 @@ from django.contrib.admin.widgets import (
     ForeignKeyRawIdWidget,
 )
 from django.contrib.auth.forms import ReadOnlyPasswordHashWidget
-from django.core.exceptions import ValidationError, ImproperlyConfigured
+from django.core.exceptions import (
+    FieldDoesNotExist,
+    ImproperlyConfigured,
+    ValidationError,
+)
+from django.db.models import ForeignKey, OneToOneField
 from django.template.loader import render_to_string
 from django.urls import reverse
 from django.utils.formats import get_format
@@ -359,13 +364,19 @@ class SBAdminAutocompleteWidget(
     form = None
     field_name = None
     initialised = None
+    allow_add = None
+    create_value_field = None
     default_create_data = None
+    forward_to_create = None
     reload_on_save = None
     REQUEST_CREATED_DATA_KEY = "autocomplete_created_data"
 
     def __init__(self, form_field=None, *args, **kwargs):
         attrs = kwargs.pop("attrs", None)
         self.reload_on_save = kwargs.pop("reload_on_save", False)
+        self.allow_add = kwargs.pop("allow_add", None)
+        self.create_value_field = kwargs.pop("create_value_field", None)
+        self.forward_to_create = kwargs.pop("forward_to_create", [])
         super().__init__(form_field, *args, **kwargs)
         self.attrs = {} if attrs is None else attrs.copy()
         if self.multiselect and self.allow_add:
@@ -595,6 +606,34 @@ class SBAdminAutocompleteWidget(
 
         return forward_data
 
+    def get_forward_data_to_create(self, request, forward_data):
+        forward_data_to_create = {}
+        for field_name in self.forward_to_create:
+            value = forward_data.get(field_name)
+            if value is None:
+                continue
+            # If forwarding a FK value from the parent form (e.g. for dependent dropdowns),
+            # store it under `<field>_id` so `Model(**kwargs)` accepts the raw PK.
+            store_key = field_name
+            form_model = getattr(getattr(self, "form", None), "model", None)
+            if form_model is not None:
+                try:
+                    form_model_field = form_model._meta.get_field(field_name)
+                except FieldDoesNotExist:
+                    form_model_field = None
+                if isinstance(form_model_field, (ForeignKey, OneToOneField)):
+                    store_key = form_model_field.attname
+
+            forward_data_to_create[store_key] = self.parse_value_from_input(
+                request, value
+            )
+            if not self.is_multiselect():
+                forward_data_to_create[store_key] = next(
+                    iter(forward_data_to_create[store_key]), None
+                )
+
+        return forward_data_to_create
+
     def value_from_datadict(self, data, files, name):
         input_value = super().value_from_datadict(data, files, name)
         threadsafe_request = SBAdminThreadLocalService.get_request()
@@ -630,7 +669,11 @@ class SBAdminAutocompleteWidget(
                 )
                 self.form_field.queryset = qs
                 parsed_value = self.validate(
-                    parsed_value, qs, threadsafe_request, parsed_is_create
+                    parsed_value,
+                    qs,
+                    threadsafe_request,
+                    forward_data,
+                    parsed_is_create,
                 )
 
         return parsed_value
@@ -638,14 +681,18 @@ class SBAdminAutocompleteWidget(
     def should_create_new_obj(self):
         return self.allow_add and self.create_value_field
 
-    def create_new_obj(self, value, queryset, is_create):
+    def create_new_obj(self, value, queryset, request, forward_data):
         if isinstance(value, list):
             # TODO: multiselect creation
             return self.form_field.to_python(value)
         else:
+            forward_data_to_create = self.get_forward_data_to_create(
+                request, forward_data
+            )
             data_to_create = {
                 self.create_value_field: value,
                 **self.default_create_data,
+                **forward_data_to_create,
             }
             new_obj = queryset.model.objects.create(**data_to_create)
             try:
@@ -658,12 +705,12 @@ class SBAdminAutocompleteWidget(
                     params={"value": value},
                 )
 
-    def validate(self, value, queryset, request, is_create=False):
+    def validate(self, value, queryset, request, forward_data, is_create=False):
         is_create_value = (
             True in is_create if isinstance(is_create, list) else is_create
         )
         if is_create_value and self.should_create_new_obj():
-            new_object = self.create_new_obj(value, queryset, is_create)
+            new_object = self.create_new_obj(value, queryset, request, forward_data)
             request.request_data.additional_data[self.REQUEST_CREATED_DATA_KEY] = (
                 request.request_data.additional_data.get(
                     self.REQUEST_CREATED_DATA_KEY, {}

django_smartbase_admin/engine/actions.py

@@ -11,6 +11,7 @@ class SBAdminCustomAction(object):
     no_params = False
     open_in_modal = False
     open_in_new_tab = False
+    template = None
 
     def __init__(
         self,
@@ -26,6 +27,7 @@ class SBAdminCustomAction(object):
         sub_actions=None,
         icon=None,
         open_in_new_tab=None,
+        template=None,
     ) -> None:
         super().__init__()
         self.title = title
@@ -40,6 +42,7 @@ class SBAdminCustomAction(object):
         self.sub_actions = sub_actions
         self.icon = icon
         self.open_in_new_tab = open_in_new_tab
+        self.template = template or "sb_admin/actions/partials/action_link.html"
         self.resolve_url()
 
     def resolve_url(self):

django_smartbase_admin/engine/admin_base_view.py

@@ -9,7 +9,7 @@ from django.contrib import messages
 from django.contrib.admin.actions import delete_selected
 from django.core.exceptions import PermissionDenied
 from django.db.models import F
-from django.http import HttpResponse, Http404, JsonResponse
+from django.http import HttpResponse, Http404, JsonResponse, HttpRequest
 from django.shortcuts import redirect
 from django.template.response import TemplateResponse
 from django.urls import reverse
@@ -60,11 +60,12 @@ SBADMIN_RELOAD_ON_SAVE_VAR = "sbadmin_reload_on_save"
 
 
 class SBAdminBaseView(object):
-    menu_label = None
     global_filter_data_map = None
     field_cache = None
     sbadmin_detail_actions = None
-    add_label = None
+    menu_label: str | None = None
+    add_label: str | None = None
+    change_label: str | None = None
     delete_confirmation_template = "sb_admin/actions/delete_confirmation.html"
 
     def init_view_static(self, configuration, model, admin_site):
@@ -222,9 +223,16 @@ class SBAdminBaseView(object):
             "color_scheme_form": color_scheme_form,
         }
 
-    def get_add_label(self, request, object_id: int | str | None = None):
+    def get_add_label(
+        self, request: HttpRequest, object_id: str | None = None
+    ) -> str | None:
         return self.add_label
 
+    def get_change_label(
+        self, request: HttpRequest, object_id: str | None = None
+    ) -> str | None:
+        return self.change_label
+
     def get_global_context(
         self, request, object_id: int | str | None = None
     ) -> dict[str, Any]:
@@ -233,6 +241,7 @@ class SBAdminBaseView(object):
             "configuration": request.request_data.configuration,
             "request_data": request.request_data,
             "add_label": self.get_add_label(request, object_id),
+            "change_label": self.get_change_label(request, object_id),
             "DETAIL_STRUCTURE_RIGHT_CLASS": DETAIL_STRUCTURE_RIGHT_CLASS,
             "OVERRIDE_CONTENT_OF_NOTIFICATION": OVERRIDE_CONTENT_OF_NOTIFICATION,
             "username_data": self.get_username_data(request),
@@ -616,8 +625,6 @@ class SBAdminBaseListView(SBAdminBaseView):
         return response
 
     def action_config(self, request, config_id=None):
-        from django_smartbase_admin.models import SBAdminListViewConfiguration
-
         config_id = config_id if config_id != "None" else None
 
         config_name = request.POST.get(CONFIG_NAME, None)
@@ -625,32 +632,21 @@ class SBAdminBaseListView(SBAdminBaseView):
             config_name = urllib.parse.unquote(config_name)
         updated_configuration = None
         if request.request_data.request_method == "POST":
-            config_params = {}
-            if config_id:
-                config_params["id"] = config_id
-            elif config_name:
-                config_params["name"] = config_name
-            if config_params:
-                (
-                    updated_configuration,
-                    created,
-                ) = SBAdminListViewConfiguration.objects.update_or_create(
-                    user_id=request.request_data.user.id,
-                    **config_params,
-                    defaults={
-                        "url_params": request.request_data.request_post.get(
-                            URL_PARAMS_NAME
-                        ),
-                        "view": self.get_id(),
-                        "action": None,
-                        "modifier": None,
-                    },
+            updated_configuration = (
+                SBAdminUserConfigurationService.create_or_update_saved_view(
+                    request,
+                    view_id=self.get_id(),
+                    config_id=config_id,
+                    config_name=config_name,
+                    url_params=request.request_data.request_post.get(URL_PARAMS_NAME),
                 )
+            )
         if request.request_data.request_method == "DELETE":
-            if config_id:
-                SBAdminListViewConfiguration.objects.by_user_id(
-                    request.request_data.user.id
-                ).by_id(config_id).by_view_action_modifier(view=self.get_id()).delete()
+            SBAdminUserConfigurationService.delete_saved_view(
+                request,
+                view_id=self.get_id(),
+                config_id=config_id,
+            )
 
         redirect_to = self.get_redirect_url_from_request(request, updated_configuration)
 
@@ -767,14 +763,8 @@ class SBAdminBaseListView(SBAdminBaseView):
         return views
 
     def get_config_data(self, request) -> dict[str, list[dict[str, Any]]]:
-        from django_smartbase_admin.models import SBAdminListViewConfiguration
-
-        current_views = list(
-            SBAdminListViewConfiguration.objects.by_user_id(
-                request.request_data.user.id
-            )
-            .by_view_action_modifier(view=self.get_id())
-            .values()
+        current_views = SBAdminUserConfigurationService.get_saved_views(
+            request, view_id=self.get_id()
         )
         for view in current_views:
             view["detail_url"] = self.get_config_url(request, view["id"])

django_smartbase_admin/engine/configuration.py

@@ -9,7 +9,11 @@ from django_smartbase_admin.engine.const import (
     FilterVersions,
     Action,
 )
-from django_smartbase_admin.models import ColorScheme
+from django_smartbase_admin.models import (
+    ColorScheme,
+    SBAdminListViewConfiguration,
+    SBAdminUserConfiguration,
+)
 from django_smartbase_admin.utils import to_list, is_modal
 
 
@@ -23,6 +27,145 @@ class SBAdminConfigurationBase(object):
     def get_configuration_for_roles(self, user_roles):
         raise NotImplementedError
 
+    # User configuration hooks - override these methods to customize user identification
+    # (e.g., use email instead of user_id for OAuth/external auth scenarios)
+
+    @classmethod
+    def get_user_config(cls, request):
+        """
+        Get or create user configuration (e.g., color scheme preferences).
+
+        Override this method to customize user identification. Default uses user_id.
+
+        Example for email-based users::
+
+            @classmethod
+            def get_user_config(cls, request):
+                from myapp.models import MyUserConfig
+                email = getattr(request.user, "email", None)
+                if not email:
+                    return MyUserConfig(email="anonymous", color_scheme=ColorScheme.AUTO.value)
+                config, _ = MyUserConfig.objects.get_or_create(
+                    email=email,
+                    defaults={"color_scheme": request.request_data.configuration.default_color_scheme},
+                )
+                return config
+        """
+        if not request.user or request.user.is_anonymous:
+            return None
+        user_config, _ = SBAdminUserConfiguration.objects.get_or_create(
+            defaults={
+                "color_scheme": request.request_data.configuration.default_color_scheme
+            },
+            user_id=request.user.id,
+        )
+        return user_config
+
+    @classmethod
+    def get_saved_views(cls, request, view_id):
+        """
+        Get saved views for the current user and view.
+
+        Override this method to customize user identification. Default uses user_id.
+        Returns a list of dicts with keys: id, name, url_params, view (view_id).
+
+        Example for email-based users::
+
+            @classmethod
+            def get_saved_views(cls, request, view_id):
+                from myapp.models import MySavedView
+                email = getattr(request.user, "email", None)
+                if not email:
+                    return []
+                return list(
+                    MySavedView.objects.filter(email=email, view_id=view_id)
+                    .values("id", "name", "config", "view_id")
+                )
+        """
+        if not request.user or request.user.is_anonymous:
+            return []
+        return list(
+            SBAdminListViewConfiguration.objects.by_user_id(request.user.id)
+            .by_view_action_modifier(view=view_id)
+            .values()
+        )
+
+    @classmethod
+    def create_or_update_saved_view(
+        cls, request, view_id, config_id, config_name, url_params
+    ):
+        """
+        Create or update a saved view for the current user.
+
+        Override this method to customize user identification. Default uses user_id.
+        Returns the created/updated saved view object.
+
+        Example for email-based users::
+
+            @classmethod
+            def create_or_update_saved_view(cls, request, view_id, config_id, config_name, url_params):
+                from myapp.models import MySavedView
+                email = getattr(request.user, "email", None)
+                if not email:
+                    return None
+                config_params = {}
+                if config_id:
+                    config_params["id"] = config_id
+                if config_name:
+                    config_params["name"] = config_name
+                saved_view, _ = MySavedView.objects.update_or_create(
+                    email=email,
+                    **config_params,
+                    defaults={"config": {"url_params": url_params}, "view_id": view_id},
+                )
+                return saved_view
+        """
+        if not request.user or request.user.is_anonymous:
+            return None
+        config_params = {}
+        if config_id:
+            config_params["id"] = config_id
+        elif config_name:
+            config_params["name"] = config_name
+        if not config_params:
+            return None
+        saved_view, _ = SBAdminListViewConfiguration.objects.update_or_create(
+            user_id=request.user.id,
+            **config_params,
+            defaults={
+                "url_params": url_params,
+                "view": view_id,
+                "action": None,
+                "modifier": None,
+            },
+        )
+        return saved_view
+
+    @classmethod
+    def delete_saved_view(cls, request, view_id, config_id):
+        """
+        Delete a saved view for the current user.
+
+        Override this method to customize user identification. Default uses user_id.
+
+        Example for email-based users::
+
+            @classmethod
+            def delete_saved_view(cls, request, view_id, config_id):
+                from myapp.models import MySavedView
+                email = getattr(request.user, "email", None)
+                if not email or not config_id:
+                    return
+                MySavedView.objects.filter(
+                    email=email, id=config_id, view_id=view_id
+                ).delete()
+        """
+        if not request.user or request.user.is_anonymous or not config_id:
+            return
+        SBAdminListViewConfiguration.objects.by_user_id(request.user.id).by_id(
+            config_id
+        ).by_view_action_modifier(view=view_id).delete()
+
 
 class Singleton(type):
     _instances = {}

django_smartbase_admin/engine/field_formatter.py

@@ -1,9 +1,10 @@
 from enum import Enum
 
 from django.template.defaultfilters import date, time
+from django.utils import timezone
+from django.utils.html import format_html, format_html_join
 from django.utils.safestring import mark_safe
 from django.utils.translation import gettext_lazy as _
-from django.utils import timezone
 
 
 class BadgeType(Enum):
@@ -39,21 +40,26 @@ def datetime_formatter_with_format(date_format=None, time_format=None):
 
 def boolean_formatter(object_id, value):
     if value:
-        return mark_safe(
-            f'<span class="badge badge-simple badge-positive">{_("Yes")}</span>'
+        return format_html(
+            '<span class="badge badge-simple badge-positive">{}</span>', _("Yes")
         )
-    return mark_safe(f'<span class="badge badge-simple badge-neutral">{_("No")}</span>')
+    return format_html(
+        '<span class="badge badge-simple badge-neutral">{}</span>', _("No")
+    )
 
 
 def format_array(value_list, separator="", badge_type: BadgeType = BadgeType.NOTICE):
-    result = ""
     if not value_list:
-        return result
-    for value in value_list:
-        if not value:
-            continue
-        result += f'<span class="badge badge-simple badge-{badge_type.value} mr-4">{value}</span>{separator}'
-    return mark_safe(result)
+        return ""
+
+    # `separator` is intended to be an internal constant (e.g. "" or "<br>").
+    # We mark it safe so HTML separators render as HTML rather than being escaped.
+    sep = mark_safe(separator) if separator else ""
+    return format_html_join(
+        sep,
+        '<span class="badge badge-simple badge-{} mr-4">{}</span>',
+        ((badge_type.value, value) for value in value_list if value),
+    )
 
 
 def array_badge_formatter(object_id, value_list):
@@ -61,14 +67,18 @@ def array_badge_formatter(object_id, value_list):
 
 
 def newline_separated_array_badge_formatter(object_id, value_list):
-    return format_array(value_list, separator="<br>")
+    return format_html("<div>{}</div>", format_array(value_list, separator="<br>"))
 
 
 def rich_text_formatter(object_id, value):
-    return mark_safe(
-        f'<div style="max-width: 500px; white-space: normal;">{value}</div>'
+    # Intentionally renders HTML (e.g. from a rich text editor field).
+    return format_html(
+        '<div style="max-width: 500px; white-space: normal;">{}</div>',
+        mark_safe(value) if value else "",
     )
 
 
 def link_formatter(object_id, value):
-    return mark_safe(f'<a href="{value}">{value}</a>')
+    if not value:
+        return ""
+    return format_html('<a href="{0}">{0}</a>', value)

django_smartbase_admin/engine/filter_widgets.py

@@ -492,7 +492,6 @@ class AutocompleteFilterWidget(
     forward = None
     label_lambda = None
     value_lambda = None
-    allow_add = False
     hide_clear_button = False
     search_query_lambda = None
     create_value_field = None
@@ -515,10 +514,8 @@ class AutocompleteFilterWidget(
         value_lambda=None,
         multiselect=None,
         forward=None,
-        allow_add=None,
         hide_clear_button=None,
         search_query_lambda=None,
-        create_value_field=None,
         **kwargs,
     ) -> None:
         super().__init__(template_name, default_value, **kwargs)
@@ -534,8 +531,6 @@ class AutocompleteFilterWidget(
         self.multiselect = multiselect if multiselect is not None else self.multiselect
         self.multiselect = self.multiselect if self.multiselect is not None else True
         self.forward = forward or self.forward
-        self.allow_add = allow_add or self.allow_add
-        self.create_value_field = create_value_field or self.create_value_field
         self.hide_clear_button = (
             hide_clear_button
             if hide_clear_button is not None

django_smartbase_admin/monkeypatch/admin_readonly_field_monkeypatch.py

@@ -88,6 +88,7 @@ class SBAdminReadonlyField(django.contrib.admin.helpers.AdminReadonlyField):
             context={
                 "readonly_content": conditional_escape(result_repr),
                 "field_label": self.field.get("label"),
+                "field_label_suffix": self.form.label_suffix,
             },
         )
 

django_smartbase_admin/services/configuration.py

@@ -25,14 +25,28 @@ class SBAdminConfigurationService(object):
 class SBAdminUserConfigurationService(object):
     @classmethod
     def get_user_config(cls, request):
-        if not request.user:
-            return None
-        from django_smartbase_admin.models import SBAdminUserConfiguration
-
-        user_config, created = SBAdminUserConfiguration.objects.get_or_create(
-            defaults={
-                "color_scheme": request.request_data.configuration.default_color_scheme
-            },
-            user_id=request.user.id,
+        """Delegate to the configuration class's get_user_config method."""
+        configuration_class = import_string(settings.SB_ADMIN_CONFIGURATION)
+        return configuration_class.get_user_config(request)
+
+    @classmethod
+    def get_saved_views(cls, request, view_id):
+        """Delegate to the configuration class's get_saved_views method."""
+        configuration_class = import_string(settings.SB_ADMIN_CONFIGURATION)
+        return configuration_class.get_saved_views(request, view_id)
+
+    @classmethod
+    def create_or_update_saved_view(
+        cls, request, view_id, config_id, config_name, url_params
+    ):
+        """Delegate to the configuration class's create_or_update_saved_view method."""
+        configuration_class = import_string(settings.SB_ADMIN_CONFIGURATION)
+        return configuration_class.create_or_update_saved_view(
+            request, view_id, config_id, config_name, url_params
         )
-        return user_config
+
+    @classmethod
+    def delete_saved_view(cls, request, view_id, config_id):
+        """Delegate to the configuration class's delete_saved_view method."""
+        configuration_class = import_string(settings.SB_ADMIN_CONFIGURATION)
+        return configuration_class.delete_saved_view(request, view_id, config_id)

django_smartbase_admin/services/views.py

@@ -64,10 +64,13 @@ class SBAdminViewService(object):
         else:
             filter_data_processed = {}
             for filter_key, filter_value in filter_data.items():
-                filter_data_processed[filter_key] = cls.json_dumps_and_replace(
-                    filter_value
-                )
-        return filter_data_processed
+                if isinstance(filter_value, str):
+                    filter_data_processed[filter_key] = filter_value
+                else:
+                    filter_data_processed[filter_key] = cls.json_dumps_and_replace(
+                        filter_value
+                    )
+            return filter_data_processed
 
     @classmethod
     def build_list_params_url(cls, view_id, filter_data=None, filter_version=None):