django-fast-treenode 2.0.10__py3-none-any.whl → 2.1.0__py3-none-any.whl

treenode/views.py

@@ -14,33 +14,100 @@ Features:
 - Uses optimized QuerySets for efficient database queries.
 - Handles validation and error responses gracefully.
 
-Version: 2.0.0
+Version: 2.1.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
 
-
+from django.apps import apps
 from django.http import JsonResponse
+from django.utils.translation import gettext_lazy as _
 from django.views import View
-from django.apps import apps
-from django.db.models import Case, When, Value, IntegerField
-from django.core.exceptions import ObjectDoesNotExist
+
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 class TreeNodeAutocompleteView(View):
-    """Returns JSON data for Select2 with tree structure."""
+    """
+    Return JSON data for Select2 with tree structure.
+
+    Lazy load tree nodes for Select2 scrolling with reference node support.
+    """
 
     def get(self, request):
-        """Get method."""
+        """
+        Process an AJAX request to lazily load tree nodes.
+
+        Operation logic:
+        """
+        # Search Processing
         q = request.GET.get("q", "")
-        model_label = request.GET.get("model")  # Получаем модель
+        if q:
+            return self.search(request)
 
-        if not model_label:
+        # Model extracting
+        model_label = request.GET.get("model")
+        try:
+            model = apps.get_model(model_label)
+        except LookupError:
             return JsonResponse(
-                {"error": "Missing model parameter"},
+                {"error": f"Invalid model: {model_label}"},
                 status=400
             )
 
+        # select_id not specified
+        queryset_list = model.get_roots()
+
+        select_id = request.GET.get("select_id", "")
+        if select_id:
+            select = model.objects.filter(pk=select_id).first()
+            if not select:
+                return JsonResponse(
+                    {"error": f"Invalid select_id: {select_id}"},
+                    status=400
+                )
+            breadcrumbs = select.get_breadcrumbs()
+            # Delete self
+            del breadcrumbs[-1]
+            for pk in breadcrumbs:
+                parent = model.model.objects.filter(pk=pk).first()
+                children = parent.get_children()
+                queryset_list.extend(children)
+
+        nodes = model._sort_node_list(queryset_list)
+        # Generate a response
+        results = [
+            {
+                "id": node.pk,
+                "text": str(node),
+                "level": node.get_depth(),
+                "is_leaf": node.is_leaf(),
+            }
+            for node in nodes
+        ]
+        # Add the "Root" option to the top of the list
+        root_option = {
+            "id": "",
+            "text": _("Root"),
+            "level": 0,
+            "is_leaf": True,
+        }
+        results.insert(0, root_option)
+
+        response_data = {"results": results}
+        return JsonResponse(response_data)
+
+    def search(self, request):
+        """Search processing."""
+        # Chack search query
+        q = request.GET.get("q", "")
+        if not q:
+            return JsonResponse({"results": []})
+
+        # Model extracting
+        model_label = request.GET.get("model")
         try:
             model = apps.get_model(model_label)
         except LookupError:
@@ -49,21 +116,21 @@ class TreeNodeAutocompleteView(View):
                 status=400
             )
 
-        queryset = model.objects.filter(name__icontains=q)
-        node_list = sorted(queryset, key=lambda x: x.tn_order)
-        pk_list = [node.pk for node in node_list]
-        nodes = queryset.filter(pk__in=pk_list).order_by(
-            Case(*[When(pk=pk, then=Value(index))
-                   for index, pk in enumerate(pk_list)],
-                 default=Value(len(pk_list)),
-                 output_field=IntegerField())
-        )[:10]
+        # Search
+        params = {}
+        treenode_field = model.treenode_display_field
+        if not treenode_field:
+            return {"results": ""}
 
+        params[f"{treenode_field}__icontains"] = q
+        queryset = model.objects.filter(**params)[:15]
+        queryset_list = list(queryset)
+        nodes = model._sort_node_list(queryset_list)
         results = [
             {
                 "id": node.pk,
                 "text": node.name,
-                "level": node.get_level(),
+                "level": node.get_depth(),
                 "is_leaf": node.is_leaf(),
             }
             for node in nodes
@@ -71,17 +138,18 @@ class TreeNodeAutocompleteView(View):
         return JsonResponse({"results": results})
 
 
-class GetChildrenCountView(View):
-    """Return the number of children for a given parent node."""
+class ChildrenView(View):
+    """Return JSON data for Select2 with node children."""
 
     def get(self, request):
-        """Get method."""
-        parent_id = request.GET.get("parent_id")
-        model_label = request.GET.get("model")  # Получаем модель
-
-        if not model_label or not parent_id:
-            return JsonResponse({"error": "Missing parameters"}, status=400)
-
+        """Process an AJAX request to load node children."""
+        # Get reference_id
+        reference_id = request.GET.get("reference_id", "")
+        if not reference_id:
+            return JsonResponse({"results": []})
+
+        # Model extracting
+        model_label = request.GET.get("model")
         try:
             model = apps.get_model(model_label)
         except LookupError:
@@ -89,15 +157,28 @@ class GetChildrenCountView(View):
                 {"error": f"Invalid model: {model_label}"},
                 status=400
             )
-
-        try:
-            parent_node = model.objects.get(pk=parent_id)
-            children_count = parent_node.get_children_count()
-            print("parent_id=", parent_id, " children_count=", children_count)
-        except ObjectDoesNotExist:
+        obj = model.objects.filter(pk=reference_id).first()
+        if not obj:
             return JsonResponse(
-                {"error": "Parent node not found"},
-                status=404
+                {"error": f"Invalid reference_id: {reference_id}"},
+                status=400
             )
 
-        return JsonResponse({"children_count": children_count})
+        if obj.is_leaf():
+            return JsonResponse({"results": []})
+
+        queryset_list = obj.get_children()
+        nodes = model._sort_node_list(queryset_list)
+        results = [
+            {
+                "id": node.pk,
+                "text": node.name,
+                "level": node.get_depth(),
+                "is_leaf": node.is_leaf(),
+            }
+            for node in nodes
+        ]
+        return JsonResponse({"results": results})
+
+
+# The End

treenode/widgets.py

@@ -2,64 +2,128 @@
 """
 TreeNode Widgets Module
 
-This module defines custom form widgets for handling hierarchical data
-within Django's admin interface. It includes a Select2-based widget
-for tree-structured data selection.
-
-Features:
-- `TreeWidget`: A custom Select2 widget that enhances usability for
-  hierarchical models.
-- Automatically fetches hierarchical data via AJAX.
-- Supports dynamic model binding for reusable implementations.
-- Integrates with Django’s form system.
-
-Version: 2.0.0
+This module defines a custom form widget for handling hierarchical data
+within Django's admin interface. It replaces the standard <select> dropdown
+with a fully customizable tree selection UI.
+
+Version: 2.1.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
 
-
+import json
 from django import forms
+from django.urls import reverse
+from django.utils.safestring import mark_safe
+from django.utils.translation import gettext_lazy as _
 
 
-class TreeWidget(forms.Select):
-    """Custom Select2 widget for hierarchical data."""
+class TreeWidget(forms.Widget):
+    """Custom widget for hierarchical tree selection."""
 
     class Media:
-        """Mrta class."""
-
-        css = {
-            "all": (
-                "https://cdnjs.cloudflare.com/ajax/libs/select2/4.0.13/css/select2.min.css",
-                "treenode/css/tree_widget.css",
-            )
-        }
-        js = (
-            "https://cdnjs.cloudflare.com/ajax/libs/select2/4.0.13/js/select2.min.js",
-            "treenode/js/tree_widget.js",
-        )
+        """Meta class to define required CSS and JS files."""
+
+        css = {"all": ("treenode/css/tree_widget.css",)}
+        js = ("treenode/js/tree_widget.js",)
 
     def build_attrs(self, base_attrs, extra_attrs=None):
-        """Add attributes for Select2 integration."""
+        """Build attributes for the widget."""
         attrs = super().build_attrs(base_attrs, extra_attrs)
-        attrs.setdefault("data-url", "/treenode/tree-autocomplete/")
-        existing_class = attrs.get("class", "")
-        attrs["class"] = f"{existing_class} tree-widget".strip()
-        if "placeholder" in attrs:
-            del attrs["placeholder"]
+        attrs.setdefault("data-url", reverse("tree_autocomplete"))
+        attrs.setdefault("data-url-children", reverse("tree_children"))
+        attrs["class"] = f"{attrs.get('class', '')} tree-widget".strip()
 
-        # Принудительно передаём `model`
         if "data-forward" not in attrs:
-            try:
+            model = getattr(self, "model", None)
+
+            if not model and hasattr(self.choices, "queryset"):
                 model = self.choices.queryset.model
-                label = model._meta.app_label
-                model_name = model._meta.model_name
-                model_label = f"{label}.{model_name}"
-                attrs["data-forward"] = f'{{"model": "{model_label}"}}'
+            if model is None:
+                raise ValueError("TreeWidget: model not passed or not defined")
+
+            try:
+                forward_data = json.dumps({"model": model._meta.label})
+                attrs["data-forward"] = forward_data.replace('"', "&quot;")
+            except AttributeError as e:
+                raise ValueError("TreeWidget: invalid Django model") from e
+
+        if self.choices:
+            try:
+                current_value = self.value()
+                if current_value:
+                    attrs["data-selected"] = str(current_value)
             except Exception:
-                attrs["data-forward"] = '{"model": ""}'
+                pass
 
         return attrs
 
+    def optgroups(self, name, value, attrs=None):
+        """
+        Override optgroups to return an empty structure.
+
+        The dropdown will be rendered dynamically via JS.
+        """
+        return []
+
+    def render(self, name, value, attrs=None, renderer=None):
+        """Render widget as a hidden input + tree container structure."""
+
+        attrs = self.build_attrs(attrs)
+        attrs["name"] = name
+        attrs["type"] = "hidden"
+        if value:
+            attrs["value"] = str(value)
+
+        # If value is set, try to get string representation of instance,
+        # otherwise print "Root"
+        if value not in [None, "", "None"]:
+            try:
+                from django.apps import apps
+                # Define the model: first self.model if it is defined,
+                # otherwise via choices
+                model = getattr(self, "model", None)
+                if model is None and hasattr(self, "choices") and getattr(self.choices, "queryset", None):
+                    model = self.choices.queryset.model
+                if model is not None:
+                    instance = model.objects.get(pk=value)
+                    selected_value = str(instance)
+                else:
+                    selected_value = str(value)
+            except Exception:
+                selected_value = str(value)
+        else:
+            selected_value = _("Root")
+
+        # Remove the 'tree-widget' class from the input so it doesn't interfere
+        # with container initialization
+        if "class" in attrs:
+            attrs["class"] = " ".join(
+                [cl for cl in attrs["class"].split() if cl != "tree-widget"])
+
+        html = """
+        <div class="tree-widget">
+            <div class="tree-widget-display">
+                <span class="selected-node">{selected_value}</span>
+                <span class="tree-dropdown-arrow">▼</span>
+            </div>
+            <input {attrs} />
+            <div class="tree-widget-dropdown">
+                <div class="tree-search-wrapper">
+                    <span class="tree-search-icon">&#x1F50E;&#xFE0E;</span>
+                    <input type="text" class="tree-search" placeholder="{search_placeholder}" />
+                    <button type="button" class="tree-search-clear">&times;</button>
+                </div>
+                <ul class="tree-list"></ul>
+            </div>
+        </div>
+        """.format(
+            attrs=" ".join(f'{key}="{val}"' for key, val in attrs.items()),
+            search_placeholder=_("Search node..."),
+            selected_value=selected_value
+        )
+
+        return mark_safe(html)
+
 
 # The End