django-smartbase-admin 0.2.72__py3-none-any.whl → 0.2.74__py3-none-any.whl

django_smartbase_admin/actions/admin_action_list.py

@@ -6,7 +6,6 @@ from django.db.models import Q
 from django.utils import timezone
 from django.utils.text import smart_split, unescape_string_literal
 
-from django_smartbase_admin.engine.actions import SBAdminAction
 from django_smartbase_admin.engine.const import (
     XLSX_PAGE_CHUNK_SIZE,
     SELECTED_ROWS_KWARG_NAME,
@@ -43,6 +42,16 @@ QueryBuilderService = import_with_injection(
 )
 
 
+class SBAdminAction(object):
+    view = None
+    threadsafe_request = None
+
+    def __init__(self, view, request) -> None:
+        super().__init__()
+        self.view = view
+        self.threadsafe_request = request
+
+
 class SBAdminListAction(SBAdminAction):
     def __init__(
         self,

django_smartbase_admin/admin/admin_base.py

@@ -37,6 +37,7 @@ from nested_admin.nested import (
 
 from django_smartbase_admin.actions.admin_action_list import SBAdminListAction
 from django_smartbase_admin.engine.actions import SBAdminCustomAction
+from django_smartbase_admin.services.thread_local import SBAdminThreadLocalService
 from django_smartbase_admin.utils import FormFieldsetMixin
 
 parler_enabled = None
@@ -62,6 +63,16 @@ try:
 except ImportError:
     pass
 
+
+django_cms_attributes = None
+try:
+    from djangocms_attributes_field.fields import AttributesFormField
+
+    django_cms_attributes = True
+except ImportError:
+    pass
+
+
 from django_smartbase_admin.admin.widgets import (
     SBAdminTextInputWidget,
     SBAdminTextareaWidget,
@@ -83,6 +94,8 @@ from django_smartbase_admin.admin.widgets import (
     SBAdminReadOnlyPasswordHashWidget,
     SBAdminHiddenWidget,
     SBAdminCKEditorUploadingWidget,
+    SBAdminAttributesWidget,
+    SBAdminMultipleChoiceInlineWidget,
 )
 from django_smartbase_admin.engine.admin_base_view import (
     SBAdminBaseListView,
@@ -121,6 +134,8 @@ class SBAdminFormFieldWidgetsMixin:
         RichTextUploadingFormField: SBAdminCKEditorUploadingWidget,
         forms.ChoiceField: SBAdminSelectWidget,
         forms.TypedChoiceField: SBAdminSelectWidget,
+        forms.MultipleChoiceField: SBAdminMultipleChoiceInlineWidget,
+        forms.TypedMultipleChoiceField: SBAdminMultipleChoiceInlineWidget,
         forms.NullBooleanField: SBAdminNullBooleanSelectWidget,
         AdminImageFormField: SBAdminImageWidget,
         ReadOnlyPasswordHashWidget: SBAdminReadOnlyPasswordHashWidget,
@@ -128,6 +143,8 @@ class SBAdminFormFieldWidgetsMixin:
     }
     if postrgres_enabled:
         formfield_widgets[SimpleArrayField] = SBAdminArrayWidget
+    if django_cms_attributes:
+        formfield_widgets[AttributesFormField] = SBAdminAttributesWidget
 
     django_widget_to_widget = {
         forms.PasswordInput: SBAdminPasswordInputWidget,
@@ -250,12 +267,13 @@ class SBAdminFormFieldWidgetsMixin:
 
 
 class SBAdminBaseFormInit(SBAdminFormFieldWidgetsMixin, FormFieldsetMixin):
-    threadsafe_request = None
     view = None
 
     def __init__(self, *args, **kwargs):
         self.view = kwargs.pop("view", self.view)
-        self.threadsafe_request = kwargs.pop("request", self.threadsafe_request)
+        threadsafe_request = kwargs.pop(
+            "request", SBAdminThreadLocalService.get_request()
+        )
         super().__init__(*args, **kwargs)
         for field in self.fields:
             if not hasattr(self.fields[field].widget, "init_widget_dynamic"):
@@ -265,14 +283,12 @@ class SBAdminBaseFormInit(SBAdminFormFieldWidgetsMixin, FormFieldsetMixin):
                 self.fields[field],
                 field,
                 self.view,
-                self.threadsafe_request,
+                threadsafe_request,
             )
         for field in self.declared_fields:
             form_field = self.fields.get(field)
             if form_field:
-                self.assign_widget_to_form_field(
-                    form_field, request=self.threadsafe_request
-                )
+                self.assign_widget_to_form_field(form_field, request=threadsafe_request)
 
 
 class SBAdminBaseForm(SBAdminBaseFormInit, forms.ModelForm):
@@ -472,11 +488,6 @@ class SBAdminInlineAndAdminCommon(SBAdminFormFieldWidgetsMixin):
         if form:
             form.view = self
 
-    def initialize_form_class_threadsafe(self, form, request):
-        self.initialize_form_class(form)
-        if form:
-            form.threadsafe_request = request
-
 
 class SBAdminThirdParty(SBAdminInlineAndAdminCommon, SBAdminBaseView):
     def get_menu_view_url(self, request):
@@ -630,7 +641,7 @@ class SBAdmin(
 
     def get_form(self, request, obj=None, **kwargs):
         form = super().get_form(request, obj, **kwargs)
-        self.initialize_form_class_threadsafe(form, request)
+        self.initialize_form_class(form)
         return form
 
     def get_id(self):
@@ -692,7 +703,11 @@ class SBAdmin(
         all_config = self.get_all_config(request)
         url_suffix = ""
         if all_config and all_config.get("all_params_changed", False):
-            url_params_dict = all_config.get("url_params")
+            url_params_dict = SBAdminViewService.process_url_params(
+                view_id=self.get_id(),
+                url_params=all_config.get("url_params"),
+                filter_version=self.get_filters_version(request),
+            )
             if url_params_dict:
                 url_suffix = f"?{SBAdminViewService.build_list_url(self.get_id(), url_params_dict)}"
 
@@ -899,7 +914,7 @@ class SBAdminInline(
     def register_autocomplete_views(self, request):
         super().register_autocomplete_views(request)
         form_class = self.get_formset(request, self.model()).form
-        self.initialize_form_class_threadsafe(form_class, request)
+        self.initialize_form_class(form_class)
         form_class()
 
     @property
@@ -943,7 +958,7 @@ class SBAdminInline(
     def get_formset(self, request, obj=None, **kwargs):
         formset = super().get_formset(request, obj, **kwargs)
         form_class = formset.form
-        self.initialize_form_class_threadsafe(form_class, request)
+        self.initialize_form_class(form_class)
         return formset
 
 

django_smartbase_admin/admin/site.py

@@ -34,7 +34,7 @@ class SBAdminSite(admin.AdminSite):
         request.sbadmin_selected_view = selected_view
         kwargs["view"] = selected_view.get_id() if selected_view else None
         request_data = SBAdminViewRequestData.from_request_and_kwargs(request, **kwargs)
-        SBAdminThreadLocalService.set_data("request", request)
+        SBAdminThreadLocalService.set_request(request)
         if selected_view:
             # Initialize SBAdmin, ModelAdmin instances, class-based SBAdminEntrypointView are initialized with request_data
             selected_view.init_view_dynamic(
@@ -49,7 +49,6 @@ class SBAdminSite(admin.AdminSite):
                 response
             )
 
-        SBAdminThreadLocalService.clear_data()
         return response
 
     def admin_view(self, view_function, cacheable=False):

django_smartbase_admin/admin/widgets.py

@@ -16,6 +16,7 @@ from filer.fields.image import AdminImageWidget
 from django_smartbase_admin.engine.filter_widgets import (
     AutocompleteFilterWidget,
 )
+from django_smartbase_admin.services.thread_local import SBAdminThreadLocalService
 from django_smartbase_admin.templatetags.sb_admin_tags import SBAdminJSONEncoder
 
 
@@ -249,6 +250,27 @@ class SBAdminArrayWidget(SBAdminTextInputWidget):
         return context
 
 
+class SBAdminAttributesWidget(SBAdminTextInputWidget):
+    template_name = "sb_admin/widgets/attributes.html"
+
+    def get_context(self, name, value, attrs):
+        context = super().get_context(name, value, attrs)
+        widget = context.get("widget", None)
+        dict_widgets = []
+        template_widget = {"attrs": {"class": "input"}}
+        if widget and value:
+            dict_widgets = [
+                {
+                    "key": {"value": key, **template_widget},
+                    "value": {"value": value, **template_widget},
+                }
+                for key, value in value.items()
+            ]
+        context["dict_widgets"] = dict_widgets
+        context["template_widget"] = template_widget
+        return context
+
+
 class SBAdminAutocompleteWidget(
     SBAdminBaseWidget, AutocompleteFilterWidget, forms.Widget
 ):
@@ -256,7 +278,6 @@ class SBAdminAutocompleteWidget(
     view = None
     form = None
     field_name = None
-    threadsafe_request = None
     initialised = None
 
     def __init__(self, form_field=None, *args, **kwargs):
@@ -264,6 +285,12 @@ class SBAdminAutocompleteWidget(
         super().__init__(form_field, *args, **kwargs)
         self.attrs = {} if attrs is None else attrs.copy()
 
+    def get_id(self):
+        base_id = super().get_id()
+        if self.form:
+            base_id += f"_{self.form.__class__.__name__}"
+        return base_id
+
     def init_widget_dynamic(self, form, form_field, field_name, view, request):
         super().init_widget_dynamic(form, form_field, field_name, view, request)
         if self.initialised:
@@ -272,11 +299,10 @@ class SBAdminAutocompleteWidget(
         self.field_name = field_name
         self.view = view
         self.form = form
-        self.threadsafe_request = request
         self.init_autocomplete_widget_static(
             self.field_name,
             self.model,
-            self.threadsafe_request.request_data.configuration,
+            request.request_data.configuration,
         )
 
     def get_field_name(self):
@@ -294,20 +320,21 @@ class SBAdminAutocompleteWidget(
             getattr(self.form_field, "empty_label", "---------") or "---------"
         )
         query_suffix = "__in"
+        threadsafe_request = SBAdminThreadLocalService.get_request()
         if not self.is_multiselect():
             query_suffix = ""
             self.multiselect = False
         if value:
-            parsed_value = self.parse_value_from_input(self.threadsafe_request, value)
+            parsed_value = self.parse_value_from_input(threadsafe_request, value)
             if parsed_value:
                 selected_options = []
-                for item in self.get_queryset(self.threadsafe_request).filter(
+                for item in self.get_queryset(threadsafe_request).filter(
                     **{f"{self.get_value_field()}{query_suffix}": parsed_value}
                 ):
                     selected_options.append(
                         {
-                            "value": self.get_value(self.threadsafe_request, item),
-                            "label": self.get_label(self.threadsafe_request, item),
+                            "value": self.get_value(threadsafe_request, item),
+                            "label": self.get_label(threadsafe_request, item),
                         }
                     )
                 context["widget"]["value"] = json.dumps(selected_options)
@@ -322,7 +349,8 @@ class SBAdminAutocompleteWidget(
 
     def value_from_datadict(self, data, files, name):
         input_value = super().value_from_datadict(data, files, name)
-        parsed_value = self.parse_value_from_input(self.threadsafe_request, input_value)
+        threadsafe_request = SBAdminThreadLocalService.get_request()
+        parsed_value = self.parse_value_from_input(threadsafe_request, input_value)
         if parsed_value is None:
             return parsed_value
         return parsed_value if self.is_multiselect() else next(iter(parsed_value), None)

django_smartbase_admin/engine/actions.py

@@ -24,12 +24,6 @@ class SBAdminCustomAction(object):
         group=None,
     ) -> None:
         super().__init__()
-
-        if not (url or (view and action_id)):
-            raise ImproperlyConfigured(
-                "You must provide either url or view and action_id"
-            )
-
         self.title = title
         self.url = url
         self.view = view
@@ -39,17 +33,27 @@ class SBAdminCustomAction(object):
         self.no_params = no_params
         self.open_in_modal = open_in_modal
         self.group = group
-        if not url and not action_modifier:
+        self.resolve_url()
+
+    def resolve_url(self):
+        if not (self.url or (self.view and self.action_id)):
+            raise ImproperlyConfigured(
+                "You must provide either url or view and action_id"
+            )
+
+        if not self.url and not self.action_modifier:
             self.url = self.view.get_action_url(self.action_id)
-        if not url and action_modifier is not None:
-            self.url = self.view.get_action_url(self.action_id, action_modifier)
+        if not self.url and self.action_modifier is not None:
+            self.url = self.view.get_action_url(self.action_id, self.action_modifier)
 
 
-class SBAdminAction(object):
-    view = None
-    threadsafe_request = None
+class SBAdminFormViewAction(SBAdminCustomAction):
+    def __init__(self, target_view, *args, **kwargs) -> None:
+        self.target_view = target_view
+        super().__init__(*args, **kwargs)
 
-    def __init__(self, view, request) -> None:
-        super().__init__()
-        self.view = view
-        self.threadsafe_request = request
+    def resolve_url(self):
+        """
+        self.url and self.action_id is resolved in side django_smartbase_admin.engine.admin_base_view.SBAdminBaseView.process_actions
+        """
+        pass

django_smartbase_admin/engine/admin_base_view.py

@@ -13,7 +13,10 @@ from django.urls import reverse
 from django.utils.translation import gettext_lazy as _
 
 from django_smartbase_admin.actions.admin_action_list import SBAdminListAction
-from django_smartbase_admin.engine.actions import SBAdminCustomAction
+from django_smartbase_admin.engine.actions import (
+    SBAdminCustomAction,
+    SBAdminFormViewAction,
+)
 from django_smartbase_admin.engine.const import (
     Action,
     OBJECT_ID_PLACEHOLDER,
@@ -28,6 +31,7 @@ from django_smartbase_admin.engine.const import (
     BASE_PARAMS_NAME,
     TABLE_RELOAD_DATA_EVENT_NAME,
     TABLE_UPDATE_ROW_DATA_EVENT_NAME,
+    FILTER_DATA_NAME,
 )
 from django_smartbase_admin.services.views import SBAdminViewService
 from django_smartbase_admin.services.xlsx_export import (
@@ -82,6 +86,27 @@ class SBAdminBaseView(object):
             request, obj
         )
 
+    def delegate_to_action_view(self, processed_action):
+        def inner_view(request, modifier):
+            return processed_action.target_view.as_view(view=self)(request)
+
+        return inner_view
+
+    def process_actions(self, request, actions):
+        processed_actions = self.process_actions_permissions(request, actions)
+        for processed_action in processed_actions:
+            if isinstance(processed_action, SBAdminFormViewAction):
+                action_id = processed_action.target_view.__name__
+                setattr(
+                    self,
+                    action_id,
+                    self.delegate_to_action_view(processed_action),
+                )
+                processed_action.url = self.get_action_url(action_id)
+                processed_action.action_id = action_id
+
+        return processed_actions
+
     def process_actions_permissions(self, request, actions):
         result = []
         for action in actions:
@@ -211,6 +236,7 @@ class SBAdminBaseListView(SBAdminBaseView):
     sbadmin_list_reorder_field = None
     search_field_placeholder = _("Search...")
     filters_version = None
+    sbadmin_actions_initialized = False
     sbadmin_list_action_class = SBAdminListAction
 
     def activate_reorder(self, request):
@@ -297,11 +323,18 @@ class SBAdminBaseListView(SBAdminBaseView):
         messages.add_message(request, messages.ERROR, "Not Implemented")
         return HttpResponse(status=200, content=render_notifications(request))
 
+    def init_actions(self, request):
+        if self.sbadmin_actions_initialized:
+            return
+        self.process_actions(request, self.get_sbadmin_list_selection_actions())
+        self.sbadmin_actions_initialized = True
+
     def init_view_dynamic(self, request, request_data=None, **kwargs):
         super().init_view_dynamic(request, request_data, **kwargs)
         self.init_fields_cache(
             self.get_sbamin_list_display(request), request.request_data.configuration
         )
+        self.init_actions(request)
 
     def get_sbamin_list_display(self, request):
         return self.sbadmin_list_display or self.list_display
@@ -313,6 +346,11 @@ class SBAdminBaseListView(SBAdminBaseView):
             request.request_data.configuration,
             force=True,
         )
+        for list_action in self.get_sbadmin_list_selection_actions():
+            if isinstance(list_action, SBAdminFormViewAction):
+                form = list_action.target_view.form_class
+                form.view = self
+                form()
 
     def get_list_display(self, request):
         return [
@@ -453,7 +491,7 @@ class SBAdminBaseListView(SBAdminBaseView):
 
     def get_sbadmin_list_selection_actions_grouped(self, request):
         result = {}
-        list_selection_actions = self.process_actions_permissions(
+        list_selection_actions = self.process_actions(
             request, self.get_sbadmin_list_selection_actions()
         )
         for action in list_selection_actions:
@@ -607,6 +645,7 @@ class SBAdminBaseListView(SBAdminBaseView):
         if not list_filter:
             return all_config
         list_fields = self.get_sbamin_list_display(request) or []
+        self.init_fields_cache(list_fields, request.request_data.configuration)
         base_filter = {
             getattr(field, "filter_field", field): ""
             for field in list_fields
@@ -632,12 +671,15 @@ class SBAdminBaseListView(SBAdminBaseView):
         list_view_config = [self.get_all_config(request), *sbadmin_list_config]
         views = []
         for defined_view in list_view_config:
+            url_params = SBAdminViewService.process_url_params(
+                view_id=self.get_id(),
+                url_params=defined_view["url_params"],
+                filter_version=self.get_filters_version(request),
+            )
             views.append(
                 {
                     "name": defined_view["name"],
-                    "url_params": SBAdminViewService.json_dumps_for_url(
-                        defined_view["url_params"]
-                    ),
+                    "url_params": SBAdminViewService.json_dumps_for_url(url_params),
                     "default": True,
                 }
             )

django_smartbase_admin/engine/field.py

@@ -83,6 +83,7 @@ class SBAdminField(JSONSerializableMixin):
     python_formatter = None
     tabulator_options = None
     xlsx_options = None
+    initialized = False
 
     def __init__(
         self,
@@ -121,6 +122,7 @@ class SBAdminField(JSONSerializableMixin):
             if (list_visible is not None)
             else (self.list_visible if self.list_visible is not None else True)
         )
+        self.list_visible_arg = list_visible
         self.list_collapsed = list_collapsed or self.list_collapsed or False
         self.auto_created = auto_created or self.auto_created or False
         self.formatter = formatter
@@ -203,7 +205,9 @@ class SBAdminField(JSONSerializableMixin):
         if self.model_field:
             self.editable = self.model_field.editable
             if self.model_field.is_relation:
-                self.list_visible = False
+                self.list_visible = (
+                    False if self.list_visible_arg is None else self.list_visible_arg
+                )
             if self.model_field.auto_created:
                 self.detail_visible = False
             self.title = self.title or getattr(
@@ -225,6 +229,7 @@ class SBAdminField(JSONSerializableMixin):
             self.formatter = "html"
         self.filter_field = self.filter_field or self.field
         self.init_filter_for_field(configuration)
+        self.initialized = True
 
     def serialize_tabulator(self):
         data = {

django_smartbase_admin/engine/modal_view.py

@@ -28,11 +28,15 @@ class ActionModalView(FormView):
     def get_form_class(self):
         form_class = super().get_form_class()
 
-        class Form(form_class):
-            view = self.view
-            threadsafe_request = self.request
+        fake_form_class = type(
+            form_class.__name__,
+            (form_class,),
+            {
+                "view": self.view,
+            },
+        )
 
-        return Form
+        return fake_form_class
 
     def post(self, request, *args, **kwargs):
         form = self.get_form()

django_smartbase_admin/services/thread_local.py

@@ -1,26 +1,13 @@
-from threading import local
+from contextvars import ContextVar
 
-_thread_locals = local()
+sb_admin_request = ContextVar("sb_admin_request")
 
 
 class SBAdminThreadLocalService:
-    THREAD_DATA_KEY = "SB_ADMIN_DATA"
-
-    @classmethod
-    def get_wrapper(cls):
-        return getattr(_thread_locals, cls.THREAD_DATA_KEY, {})
-
-    @classmethod
-    def get_data(cls, key):
-        data_wrapper = cls.get_wrapper()
-        return data_wrapper.get(key)
-
     @classmethod
-    def set_data(cls, key, data):
-        data_wrapper = cls.get_wrapper()
-        data_wrapper[key] = data
+    def get_request(cls):
+        return sb_admin_request.get()
 
     @classmethod
-    def clear_data(cls):
-        if hasattr(_thread_locals, cls.THREAD_DATA_KEY):
-            delattr(_thread_locals, cls.THREAD_DATA_KEY)
+    def set_request(cls, request):
+        sb_admin_request.set(request)

django_smartbase_admin/services/views.py

@@ -4,6 +4,7 @@ import urllib
 
 from django.db.models import Q, FilteredRelation, F, Value, CharField
 from django.shortcuts import redirect
+from django_smartbase_admin.templatetags.sb_admin_tags import SBAdminJSONEncoder
 
 from django_smartbase_admin.engine.const import (
     BASE_PARAMS_NAME,
@@ -20,17 +21,52 @@ from django_smartbase_admin.services.translations import SBAdminTranslationsServ
 class SBAdminViewService(object):
     @classmethod
     def json_dumps_for_url(cls, data):
-        return json.dumps(data, separators=(",", ":"))
+        return json.dumps(data, separators=(",", ":"), cls=SBAdminJSONEncoder)
 
     @classmethod
     def json_dumps_and_replace(cls, data):
-        return cls.json_dumps_for_url(data).replace('"', '\\"')
+        return cls.json_dumps_for_url(data)
 
     @classmethod
     def build_list_url(cls, view_id, url_params):
         params = {view_id: url_params}
         return f"{BASE_PARAMS_NAME}={cls.json_dumps_for_url(params)}"
 
+    @classmethod
+    def process_url_params(cls, view_id, url_params, filter_version):
+        filter_data = SBAdminViewService.process_filter_data_url(
+            view_id=view_id,
+            filter_data=url_params.get(FILTER_DATA_NAME, {}),
+            filter_version=filter_version,
+        )
+        url_params_processed = {**url_params}
+        if filter_data:
+            url_params_processed[FILTER_DATA_NAME] = filter_data
+        return url_params_processed
+
+    @classmethod
+    def process_filter_data_url(cls, view_id, filter_data, filter_version):
+        if filter_version == FilterVersions.FILTERS_VERSION_2:
+            filter_data_processed = []
+            for key, value in filter_data.items():
+                filter_value = {
+                    "id": f"{view_id}-{key}",
+                    "field": key,
+                    "type": "string",
+                    "input": "text",
+                    "operator": "contains",
+                }
+                filter_value.update(value)
+                filter_data_processed.append(filter_value)
+            return filter_data_processed
+        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
+
     @classmethod
     def build_list_params_url(cls, view_id, filter_data=None, filter_version=None):
         if filter_version == FilterVersions.FILTERS_VERSION_2:
@@ -44,24 +80,18 @@ class SBAdminViewService(object):
                     TABLE_PARAMS_SELECTED_FILTER_TYPE: TABLE_TAB_ADVANCED_FITLERS
                 },
             }
-            for key, value in filter_data.items():
-                filter_value = {
-                    "id": f"{view_id}-{key}",
-                    "field": key,
-                    "type": "string",
-                    "input": "text",
-                    "operator": "contains",
-                }
-                filter_value.update(value)
-                filter_dict[ADVANCED_FILTER_DATA_NAME]["rules"].append(filter_value)
+            filter_dict[ADVANCED_FILTER_DATA_NAME]["rules"].extend(
+                cls.process_filter_data_url(view_id, filter_data, filter_version)
+            )
             params = {BASE_PARAMS_NAME: cls.json_dumps_for_url({view_id: filter_dict})}
             return urllib.parse.urlencode(params)
         filter_data = filter_data or {}
-        filter_data_processed = {}
-        for filter_key, filter_value in filter_data.items():
-            filter_data_processed[filter_key] = cls.json_dumps_and_replace(filter_value)
-        view_params = {FILTER_DATA_NAME: filter_data_processed}
-        return cls.build_list_url(view_id, view_params).replace("\\\\", "")
+        view_params = {
+            FILTER_DATA_NAME: cls.process_filter_data_url(
+                view_id, filter_data, filter_version
+            )
+        }
+        return cls.build_list_url(view_id, view_params)
 
     @classmethod
     def get_pk_field_for_model(cls, model):