django-smartbase-admin 0.2.54__py3-none-any.whl → 1.0.38__py3-none-any.whl

django_smartbase_admin/engine/filter_widgets.py

@@ -2,10 +2,11 @@ import json
 from datetime import datetime, timedelta
 
 from django.core.exceptions import ImproperlyConfigured
+from django.contrib.postgres.fields import ArrayField
 from django.db.models import Q, fields, FilteredRelation, Count
 from django.http import JsonResponse
 from django.utils import timezone
-from django.utils.translation import gettext_lazy as _
+from django.utils.translation import gettext_lazy as _, pgettext_lazy
 
 from django_smartbase_admin.actions.advanced_filters import (
     AllOperators,
@@ -20,6 +21,7 @@ from django_smartbase_admin.engine.const import (
     Action,
     AUTOCOMPLETE_PAGE_NUM,
     AUTOCOMPLETE_FORWARD_NAME,
+    SELECT_ALL_KEYWORD,
 )
 from django_smartbase_admin.services.translations import SBAdminTranslationsService
 from django_smartbase_admin.services.views import SBAdminViewService
@@ -44,6 +46,22 @@ class AutocompleteParseMixin:
             value = input_value
         return value
 
+    def parse_is_create_from_input(self, request, input_value):
+        try:
+            input_value = json.loads(input_value)
+        except:
+            pass
+        if isinstance(input_value, list):
+            value = []
+            for data in input_value:
+                if type(data) is dict:
+                    value.append(data.get("create", False))
+                else:
+                    value.append(False)
+        else:
+            value = False
+        return value
+
 
 class SBAdminFilterWidget(JSONSerializableMixin):
     template_name = None
@@ -211,6 +229,8 @@ class ChoiceFilterWidget(SBAdminFilterWidget):
             return found_label[0] if found_label else default_value
 
     def get_base_filter_query_for_parsed_value(self, request, filter_value):
+        if isinstance(self.model_field, ArrayField):
+            return Q(**{f"{self.field.filter_field}__contains": [filter_value]})
         return Q(**{self.field.filter_field: filter_value})
 
 
@@ -220,8 +240,38 @@ class RadioChoiceFilterWidget(ChoiceFilterWidget):
 
 class MultipleChoiceFilterWidget(AutocompleteParseMixin, ChoiceFilterWidget):
     template_name = "sb_admin/filter_widgets/multiple_choice_field.html"
+    enable_select_all = False
+    select_all_keyword = None
+    select_all_label = None
+
+    def __init__(
+        self,
+        choices,
+        template_name=None,
+        default_value=None,
+        default_label=None,
+        enable_select_all=False,
+        select_all_keyword=SELECT_ALL_KEYWORD,
+        select_all_label=_("All"),
+        **kwargs,
+    ) -> None:
+        super().__init__(
+            choices=choices,
+            template_name=template_name,
+            default_value=default_value,
+            default_label=default_label,
+            **kwargs,
+        )
+        self.enable_select_all = enable_select_all
+        self.select_all_keyword = select_all_keyword
+        self.select_all_label = select_all_label
 
     def get_base_filter_query_for_parsed_value(self, request, filter_value):
+        if isinstance(self.model_field, ArrayField):
+            q_objects = Q()
+            for value in filter_value:
+                q_objects |= Q(**{f"{self.field.filter_field}__contains": [value]})
+            return q_objects
         return Q(**{f"{self.field.filter_field}__in": filter_value})
 
     def get_advanced_filter_operators(self):
@@ -284,6 +334,7 @@ class DateFilterWidget(SBAdminFilterWidget):
             "label": _("Last 12 months"),
         },
     ]
+    shortcuts_dict = {AllOperators.IN_THE_LAST.value: shortcuts}
     default_value_shortcut_index = None
 
     def __init__(
@@ -306,33 +357,43 @@ class DateFilterWidget(SBAdminFilterWidget):
     def get_advanced_filter_operators(self):
         return DATE_ATTRIBUTES
 
+    def process_shortcut(self, shortcut, now):
+        return shortcut
+
     def get_shortcuts(self):
         now = timezone.now()
         shortcuts = []
         for shortcut in self.shortcuts:
-            shortcuts.append(
-                {
-                    "label": shortcut["label"],
-                    "value": [
-                        now + timedelta(days=shortcut["value"][0]),
-                        now + timedelta(days=shortcut["value"][1]),
-                    ],
-                }
-            )
+            shortcuts.append(self.process_shortcut(shortcut, now))
+        return shortcuts
+
+    def get_shortcuts_dict(self):
+        now = timezone.now()
+        shortcuts = {}
+        for key, shortcuts_group in self.shortcuts_dict.items():
+            shortcuts[key] = []
+            for shortcut in shortcuts_group:
+                shortcuts[key].append(self.process_shortcut(shortcut, now))
         return shortcuts
 
+    def get_default_label(self):
+        if self.default_value_shortcut_index is not None:
+            return self.get_shortcuts()[self.default_value_shortcut_index]["label"]
+        return super().get_default_value()
+
     def get_default_value(self):
         if self.default_value_shortcut_index is not None:
             selected_shortcut_value = self.get_shortcuts()[
                 self.default_value_shortcut_index
             ]["value"]
-            return self.get_value_from_date_or_range(selected_shortcut_value)
+            return SBAdminViewService.json_dumps_for_url(
+                self.get_value_from_date_or_range(selected_shortcut_value)
+            )
         return super().get_default_value()
 
     def get_data(self):
         return json.dumps(
             {
-                "shortcuts": self.get_shortcuts(),
                 "flatpickrOptions": {
                     "locale": {
                         "rangeSeparator": self.DATE_RANGE_SPLIT,
@@ -342,6 +403,19 @@ class DateFilterWidget(SBAdminFilterWidget):
             cls=SBAdminJSONEncoder,
         )
 
+    def get_shortcuts_data(self):
+        return json.dumps(
+            self.get_shortcuts(),
+            cls=SBAdminJSONEncoder,
+        )
+
+    def get_shortcuts_dict_data(self):
+        # used for advanced filters with different calendar operators "in the last", "in the next", etc.
+        return json.dumps(
+            self.get_shortcuts_dict(),
+            cls=SBAdminJSONEncoder,
+        )
+
     @classmethod
     def is_used_for_model_field_type(cls, model_field):
         return isinstance(model_field, fields.DateField)
@@ -356,12 +430,28 @@ class DateFilterWidget(SBAdminFilterWidget):
         if filter_value is None:
             return [None, None]
         date_format = cls.DATE_FORMAT
-        date_range = filter_value.split(cls.DATE_RANGE_SPLIT)
-        if len(date_range) == 2:
-            date_from = datetime.strptime(date_range[0], date_format)
-            date_to = datetime.strptime(date_range[1], date_format)
-            return [date_from, date_to]
-        else:
+        if type(filter_value) is list:
+            if type(filter_value[0]) is int:
+                return [
+                    timezone.now() + timedelta(days=filter_value[0]),
+                    timezone.now() + timedelta(days=filter_value[1]),
+                ]
+            return [
+                datetime.strptime(filter_value[0], date_format),
+                datetime.strptime(filter_value[1], date_format),
+            ]
+        try:
+            days_range = json.loads(filter_value)
+            return [
+                timezone.now() + timedelta(days=days_range[0]),
+                timezone.now() + timedelta(days=days_range[1]),
+            ]
+        except json.decoder.JSONDecodeError:
+            date_range = filter_value.split(cls.DATE_RANGE_SPLIT)
+            if len(date_range) == 2:
+                date_from = datetime.strptime(date_range[0], date_format)
+                date_to = datetime.strptime(date_range[1], date_format)
+                return [date_from, date_to]
             date_value = datetime.strptime(filter_value, date_format)
             return [date_value, date_value]
 
@@ -369,9 +459,11 @@ class DateFilterWidget(SBAdminFilterWidget):
     def get_value_from_date_or_range(cls, date_or_range):
         if not isinstance(date_or_range, list):
             return datetime.strftime(date_or_range, cls.DATE_FORMAT)
+        if type(date_or_range[0]) is int:
+            return date_or_range
         date_from = datetime.strftime(date_or_range[0], cls.DATE_FORMAT)
         date_to = datetime.strftime(date_or_range[1], cls.DATE_FORMAT)
-        return f"{date_from}{cls.DATE_RANGE_SPLIT}{date_to}"
+        return [date_from, date_to]
 
     def parse_value_from_input(self, request, filter_value):
         return self.get_range_from_value(filter_value)
@@ -403,6 +495,7 @@ class AutocompleteFilterWidget(
     allow_add = False
     hide_clear_button = False
     search_query_lambda = None
+    create_value_field = None
 
     def get_field_name(self):
         return self.field.name
@@ -425,13 +518,16 @@ class AutocompleteFilterWidget(
         allow_add=None,
         hide_clear_button=None,
         search_query_lambda=None,
+        create_value_field=None,
         **kwargs,
     ) -> None:
         super().__init__(template_name, default_value, **kwargs)
         self.model = model or self.model
         self.value_field = value_field or self.value_field
         self.filter_query_lambda = filter_query_lambda or self.filter_query_lambda
+        # filters queryset to search in
         self.filter_search_lambda = filter_search_lambda or self.filter_search_lambda
+        # defines fields to search on
         self.search_query_lambda = search_query_lambda or self.search_query_lambda
         self.label_lambda = label_lambda or self.label_lambda
         self.value_lambda = value_lambda or self.value_lambda
@@ -439,6 +535,7 @@ class AutocompleteFilterWidget(
         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
@@ -547,8 +644,9 @@ class AutocompleteFilterWidget(
     def get_value_field(self):
         return self.value_field or self.model._meta.pk.name
 
-    def filter_search_queryset(self, request, qs, search_term, forward_data):
+    def filter_search_queryset(self, request, qs, search_term="", forward_data=None):
         if self.filter_search_lambda:
+            forward_data = forward_data or {}
             qs = qs.filter(
                 self.filter_search_lambda(request, search_term, forward_data)
             )
@@ -560,9 +658,16 @@ class AutocompleteFilterWidget(
         page_num = int(post_data.get(AUTOCOMPLETE_PAGE_NUM, 1))
         from_item = (page_num - 1) * AUTOCOMPLETE_PAGE_SIZE
         to_item = (page_num) * AUTOCOMPLETE_PAGE_SIZE
+
+        # filter queryset
+        # base restricted queryset
         qs = self.get_queryset(request)
+        # filters queryset to search in, uses filter_search_lambda
         qs = self.filter_search_queryset(request, qs, search_term, forward_data)
+
+        # search in queryset
         if self.search_query_lambda:
+            # defines fields to search on
             qs = self.search_query_lambda(
                 request,
                 qs,
@@ -571,6 +676,7 @@ class AutocompleteFilterWidget(
                 SBAdminTranslationsService.get_main_lang_code(),
             )
         else:
+            # defines default fields to search on - all char fields
             qs = self.get_default_search_query(
                 request,
                 qs,
@@ -598,6 +704,8 @@ class AutocompleteFilterWidget(
     def get_label(self, request, item):
         if self.label_lambda:
             return self.label_lambda(request, item)
+        if isinstance(item, list):
+            return ", ".join(map(str, item))
         return str(item)
 
     def get_context(self, name, value, attrs):
@@ -657,3 +765,184 @@ class FromValuesAutocompleteWidget(AutocompleteFilterWidget):
 
     def get_label(self, request, item):
         return item.get(self.field.name)
+
+
+class SBAdminTreeWidgetMixin:
+    order_by = None
+    inline = False
+    RELATIONSHIP_PICK_MODE_NONE = None
+    RELATIONSHIP_PICK_MODE_PARENT = "parent"
+    relationship_pick_mode = RELATIONSHIP_PICK_MODE_NONE
+    additional_columns = None
+    tree_strings = {
+        "loading": pgettext_lazy("Tree widget", "Loading..."),
+        "loadError": pgettext_lazy("Tree widget", "Load error!"),
+        "moreData": pgettext_lazy("Tree widget", "More..."),
+        "noData": pgettext_lazy("Tree widget", "No data."),
+    }
+    model = None
+    path_field = "path"
+
+    def __init__(
+        self,
+        order_by=None,
+        relationship_pick_mode=None,
+        inline=None,
+        additional_columns=None,
+        tree_strings=None,
+        *args,
+        **kwargs,
+    ):
+        self.inline = inline if inline is not None else self.inline
+        self.order_by = order_by if order_by is not None else self.order_by
+        self.relationship_pick_mode = relationship_pick_mode
+        self.additional_columns = (
+            additional_columns
+            if additional_columns is not None
+            else self.additional_columns
+        )
+        self.tree_strings = (
+            tree_strings if tree_strings is not None else self.tree_strings
+        )
+        if self.inline:
+            self.template_name = "sb_admin/widgets/tree_select_inline.html"
+        super().__init__(*args, **kwargs)
+
+    def action_autocomplete(self, request, modifier):
+        result = self.format_tree_data(request, self.get_queryset(request))
+        return JsonResponse(data=result, safe=False)
+
+    def format_tree_data(self, request, queryset):
+        self_id = None
+        if self.relationship_pick_mode == self.RELATIONSHIP_PICK_MODE_PARENT:
+            # disable selecting self and children if selecting parent
+            self_id = self.form.instance.id if self.form.instance else None
+        return self.get_tree_data(request, queryset, self_id=self_id)
+
+    @classmethod
+    def get_tree_base_values(cls):
+        return ["id", cls.path_field]
+
+    @classmethod
+    def get_tree_key(cls, request, item):
+        return item.get(cls.path_field)
+
+    @classmethod
+    def get_tree_title(cls, request, item):
+        raise NotImplementedError
+
+    @classmethod
+    def get_value(cls, request, item):
+        return getattr(item, cls.path_field)
+
+    @classmethod
+    def get_label(cls, request, item):
+        raise NotImplementedError
+
+    @classmethod
+    def tree_process_global_data(cls, request, queryset, **kwargs):
+        return {}
+
+    @classmethod
+    def get_additional_data(cls, request, item, tree_process_global_data):
+        return {}
+
+    @classmethod
+    def get_tree_data(cls, request, queryset, values=None, self_id=None, **kwargs):
+        tree_values = cls.get_tree_base_values()
+        tree_values.extend(values if values else [])
+
+        queryset = queryset.order_by(*cls.order_by)
+        queryset = queryset.annotate(
+            **SBAdminViewService.get_annotates(cls.model, tree_values, [])
+        )
+        flat_data = []
+        tree_data, lnk = [], {}
+        tree_process_global_data = cls.tree_process_global_data(
+            request, queryset, **kwargs
+        )
+
+        data = list(queryset.values(*tree_values))
+        for item in data:
+            path = item.get("path")
+            depth = int(len(path) / cls.model.steplen)
+            item_id = cls.get_tree_key(request, item)
+            item_label = cls.get_tree_title(request, item)
+            newobj = {
+                "title": item_label,
+                "key": str(item_id),
+                "data": {"id": item.get("id")},
+            }
+            if item_id == self_id:
+                # disable selecting self and children if selecting parent
+                newobj["checkbox"] = False
+
+            additional_data = cls.get_additional_data(
+                request, item, tree_process_global_data
+            )
+            newobj.update(additional_data)
+
+            if depth == 1:
+                tree_data.append(newobj)
+                flat_data.append(newobj)
+            else:
+                parentpath = cls.model._get_basepath(path, depth - 1)
+                parentobj = lnk[parentpath]
+                if "children" not in parentobj:
+                    parentobj["children"] = []
+                if parentobj.get("checkbox") is False:
+                    # disable selecting self and children if selecting parent
+                    newobj["checkbox"] = False
+                parentobj["children"].append(newobj)
+                flat_data.append(newobj)
+            lnk[path] = newobj
+        return tree_data
+
+    # tree_widget_data: [{"key":"path", "children": [{...}]}]
+    @classmethod
+    def process_treebeard_tree(
+        cls,
+        tree_widget_data,
+        treebeard_objs_by_path,
+        depth=1,
+        parent_path="",
+        path_base="",
+    ):
+        if not path_base:
+            path_base = ((cls.model.steplen - 1) * "0") + "1"
+        previous = None
+        objs_to_update = []
+        for tree_widget_node in tree_widget_data:
+            treebeard_obj = treebeard_objs_by_path.get(tree_widget_node["key"])
+            old_depth = treebeard_obj.depth
+            old_path = getattr(treebeard_obj, cls.path_field)
+            old_numchild = treebeard_obj.numchild
+            treebeard_obj.depth = depth
+            if not previous:
+                previous = treebeard_obj
+                setattr(treebeard_obj, cls.path_field, parent_path + path_base)
+            else:
+                setattr(treebeard_obj, cls.path_field, previous._inc_path())
+                previous = treebeard_obj
+            children = tree_widget_node.get("children", [])
+            treebeard_obj.numchild = len(children)
+            if (
+                treebeard_obj.depth != old_depth
+                or getattr(treebeard_obj, cls.path_field) != old_path
+                or treebeard_obj.numchild != old_numchild
+            ):
+                objs_to_update.append(treebeard_obj)
+            objs_to_update.extend(
+                cls.process_treebeard_tree(
+                    children,
+                    treebeard_objs_by_path,
+                    depth + 1,
+                    getattr(treebeard_obj, cls.path_field),
+                    path_base,
+                )
+            )
+        return objs_to_update
+
+
+class SBAdminTreeFilterWidget(SBAdminTreeWidgetMixin, AutocompleteFilterWidget):
+    template_name = "sb_admin/filter_widgets/tree_select_filter.html"

django_smartbase_admin/engine/menu_item.py

@@ -56,11 +56,14 @@ class SBAdminMenuItem(object):
         return self.label or self.view.get_menu_label()
 
     def get_url(self, request):
-        return (
-            self.url
-            or (self.view.get_menu_view_url(request) if self.view else None)
-            or ""
-        )
+        if callable(self.url):
+            return self.url(request)
+        elif self.url:
+            return self.url
+        elif self.view:
+            return self.view.get_menu_view_url(request)
+        else:
+            return ""
 
     def get_icon(self):
         return self.icon or getattr(self.view, "icon", None)

django_smartbase_admin/engine/modal_view.py

@@ -2,6 +2,7 @@ from django.http import HttpResponse
 from django.views.generic import FormView
 from django_htmx.http import trigger_client_event
 from django_smartbase_admin.actions.admin_action_list import SBAdminListAction
+from django_smartbase_admin.engine.const import TABLE_RELOAD_DATA_EVENT_NAME
 
 
 class ActionModalView(FormView):
@@ -19,7 +20,7 @@ class ActionModalView(FormView):
         trigger_client_event(response, "hideModal", {})
         trigger_client_event(
             response,
-            "SBAdminReloadTableData",
+            TABLE_RELOAD_DATA_EVENT_NAME,
             {},
         )
         return response
@@ -27,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()
@@ -59,9 +64,9 @@ class ListActionModalView(ActionModalView):
         return response
 
     def get_selection_queryset(self, request, form):
-        list_action = SBAdminListAction(self.view, request)
+        list_action = self.view.sbadmin_list_action_class(self.view, request)
         return list_action.get_data_queryset().filter(
-            list_action.get_selection_queryset()
+            list_action.get_selection_queryset(), list_action.get_filter_from_request()
         )
 
     def process_form_valid_list_selection_queryset(

django_smartbase_admin/engine/request.py

@@ -20,6 +20,7 @@ class SBAdminViewRequestData(object):
     configuration = None
     selected_view = None
     session = None
+    additional_data = None
 
     def __init__(
         self,
@@ -47,6 +48,7 @@ class SBAdminViewRequestData(object):
         self.request_method = request_method
         self.global_filter = global_filter or {}
         self.session = session or {}
+        self.additional_data = {}
 
     def refresh_selected_view(self, request):
         self.configuration = SBAdminConfigurationService.get_configuration(self)

django_smartbase_admin/integration/django_cms.py

@@ -0,0 +1,43 @@
+from typing import Any
+
+from django_smartbase_admin.admin.site import sb_admin_site
+
+from django_smartbase_admin.admin.admin_base import SBAdmin
+
+
+class DjangoCMSPluginSBAdmin(SBAdmin):
+    initialised = False
+    list_display = []
+
+    def get_inline_instances(self, request, obj=None):
+        inline_instances = super().get_inline_instances(request, obj)
+        if not self.initialised:
+            for inline_instance in inline_instances:
+                inline_instance.init_view_static(
+                    request.request_data.configuration,
+                    inline_instance.model,
+                    sb_admin_site,
+                )
+            self.initialised = True
+        return inline_instances
+
+    def get_sbadmin_fieldsets(self, request, object_id=None):
+        obj = self.model.objects.get(pk=object_id) if object_id else None
+        fieldsets = self.sbadmin_fieldsets or [
+            (
+                None,
+                {"fields": self.get_fields(request, obj)},
+            )
+        ]
+        self.sbadmin_fieldsets = fieldsets
+        return fieldsets
+
+    def response_add(self, request, obj, **kwargs):
+        # response_add from CMSPluginBase
+        self.object_successfully_changed = True
+        return self.render_close_frame(request, obj)
+
+    def get_change_view_context(self, request, object_id) -> dict | dict[str, Any]:
+        return {
+            "show_back_button": True,
+        }