django-smartbase-admin 0.2.91__py3-none-any.whl → 0.2.93__py3-none-any.whl

django_smartbase_admin/actions/admin_action_list.py

@@ -141,11 +141,6 @@ class SBAdminListAction(SBAdminAction):
             if field.field in values
         ]
 
-    def is_jquery_required(self, request):
-        return (
-            self.view.get_filters_version(request) == FilterVersions.FILTERS_VERSION_2
-        )
-
     def get_template_data(self):
         context_data = self.view.get_context_data(self.threadsafe_request)
         constants = {
@@ -194,7 +189,6 @@ class SBAdminListAction(SBAdminAction):
                 "tabulator_definition": tabulator_definition,
                 "id_column_name": id_column_name,
                 "filters": self.get_filters(),
-                "is_jquery_required": self.is_jquery_required(self.threadsafe_request),
                 "advanced_filters_data": QueryBuilderService.get_advanced_filters_context_data(
                     self
                 ),

django_smartbase_admin/admin/admin_base.py

@@ -651,6 +651,7 @@ class SBAdmin(
     NestedModelAdmin,
 ):
     change_list_template = "sb_admin/actions/list.html"
+    reorder_list_template = "sb_admin/actions/list.html"
     change_form_template = "sb_admin/actions/change_form.html"
     delete_selected_confirmation_template = (
         "sb_admin/actions/delete_selected_confirmation.html"

django_smartbase_admin/admin/widgets.py

@@ -10,6 +10,7 @@ from django.contrib.admin.widgets import (
     ForeignKeyRawIdWidget,
 )
 from django.contrib.auth.forms import ReadOnlyPasswordHashWidget
+from django.core.exceptions import ValidationError
 from django.template.loader import render_to_string
 from django.urls import reverse
 from django.utils.formats import get_format
@@ -23,6 +24,7 @@ from filer.models import File
 
 from django_smartbase_admin.engine.filter_widgets import (
     AutocompleteFilterWidget,
+    SBAdminTreeWidgetMixin,
 )
 from django_smartbase_admin.services.thread_local import SBAdminThreadLocalService
 from django_smartbase_admin.templatetags.sb_admin_tags import SBAdminJSONEncoder
@@ -542,3 +544,71 @@ class SBAdminColorWidget(SBAdminTextInputWidget):
         js = [
             "sb_admin/js/coloris/coloris.min.js",
         ]
+
+
+class SBAdminTreeWidget(SBAdminTreeWidgetMixin, SBAdminAutocompleteWidget):
+    template_name = "sb_admin/widgets/tree_select.html"
+
+    def get_context(self, name, value, attrs):
+        context = super().get_context(name, value, attrs)
+        context["widget"]["raw_value"] = value
+        context["widget"]["relationship_pick_mode"] = self.relationship_pick_mode
+        context["widget"]["value_dict"] = {
+            item["value"]: item["label"]
+            for item in context["widget"].get("value_list", [])
+        }
+        context["widget"]["additional_columns"] = self.additional_columns
+        context["widget"]["tree_strings"] = self.tree_strings
+
+        return context
+
+    @classmethod
+    def get_descendants_from_tree_data(cls, tree_data, parent_id):
+        parent_item = cls.find_parent_in_tree_data(tree_data, parent_id)
+        descendants = cls.get_descendats_from_item(parent_item)
+        return descendants
+
+    @classmethod
+    def get_descendats_from_item(cls, item):
+        descendants = []
+        if not item:
+            return descendants
+        for child in item.get("children", []):
+            descendants.append(child)
+            descendants.extend(cls.get_descendats_from_item(child))
+        return descendants
+
+    @classmethod
+    def find_parent_in_tree_data(cls, tree_data, parent_id):
+        str_parent_id = str(parent_id)
+        for item in tree_data:
+            if item["key"] == str_parent_id:
+                return item
+            parent = cls.find_parent_in_tree_data(
+                item.get("children", []), str_parent_id
+            )
+            if parent:
+                return parent
+        return None
+
+    def value_from_datadict(self, data, files, name):
+        input_value = data.get(name)
+        threadsafe_request = SBAdminThreadLocalService.get_request()
+        parsed_value = self.parse_value_from_input(threadsafe_request, input_value)
+        obj = self.form.instance
+        if (
+            obj
+            and parsed_value
+            and self.relationship_pick_mode == self.RELATIONSHIP_PICK_MODE_PARENT
+        ):
+            if obj.id == parsed_value:
+                raise ValidationError(_("Cannot set parent to itself"))
+            qs = self.get_queryset(threadsafe_request).order_by(*self.order_by)
+            tree_data = self.format_tree_data(threadsafe_request, qs)
+            children = self.get_descendants_from_tree_data(tree_data, obj.id)
+            children_ids = []
+            for child in children:
+                children_ids.append(child.get("key"))
+            if input_value in children_ids:
+                raise ValidationError(_("Cannot set parent to it's own child"))
+        return parsed_value

django_smartbase_admin/engine/admin_base_view.py

@@ -282,6 +282,7 @@ class SBAdminBaseListView(SBAdminBaseView):
                     url=self.get_menu_view_url(request),
                 ),
             ],
+            template=self.reorder_list_template,
         )
 
     def is_reorder_active(self, request) -> bool:
@@ -618,6 +619,7 @@ class SBAdminBaseListView(SBAdminBaseView):
         tabulator_definition=None,
         extra_context=None,
         list_actions=None,
+        template=None,
     ):
         action = self.sbadmin_list_action_class(
             self,
@@ -640,7 +642,8 @@ class SBAdminBaseListView(SBAdminBaseView):
 
         return TemplateResponse(
             request,
-            self.change_list_template
+            template
+            or self.change_list_template
             or [
                 "admin/%s/%s/change_list.html"
                 % (self.model._meta.app_label, self.model._meta.model_name),

django_smartbase_admin/engine/filter_widgets.py

@@ -5,7 +5,7 @@ from django.core.exceptions import ImproperlyConfigured
 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,
@@ -701,3 +701,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"