django-fast-treenode 2.0.11__py3-none-any.whl → 2.1.1__py3-none-any.whl

treenode/models/mixins/tree.py

@@ -0,0 +1,344 @@
+# -*- coding: utf-8 -*-
+"""
+TreeNode Tree Mixin
+
+Version: 2.1.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+import json
+from django.db import models, transaction
+from collections import OrderedDict
+from django.core.serializers.json import DjangoJSONEncoder
+
+from ...cache import cached_method
+
+
+class TreeNodeTreeMixin(models.Model):
+    """TreeNode Tree Mixin."""
+
+    class Meta:
+        """Moxin Meta Class."""
+
+        abstract = True
+
+    @classmethod
+    def dump_tree(cls, instance=None):
+        """
+        Return an n-dimensional dictionary representing the model tree.
+
+        Introduced for compatibility with other packages.
+        """
+        return cls.get_tree(cls, instance)
+
+    @classmethod
+    @cached_method
+    def get_tree(cls, instance=None):
+        """
+        Return an n-dimensional dictionary representing the model tree.
+
+        If instance is passed, returns a subtree rooted at instance (using
+        get_descendants_queryset), if not passed, builds a tree for all nodes
+        (loads all records in one query).
+        """
+        # If instance is passed, we get all its descendants (including itself)
+        if instance:
+            queryset = instance.get_descendants_queryset(include_self=True)\
+                .annotate(depth=models.Max("parents_set__depth"))
+        else:
+            # Load all records at once
+            queryset = cls.objects.all()
+
+        # Dictionary for quick access to nodes by id and list for iteration
+        nodes_by_id = {}
+        nodes_list = []
+
+        # Loop through all nodes using an iterator
+        for node in queryset.iterator(chunk_size=1000):
+            # Create a dictionary for the node.
+            # In Python 3.7+, the standard dict preserves insertion order.
+            # We'll stick to the order:
+            # id, 'tn_parent', 'tn_priority', 'level', then the rest of
+            # the fields. Сlose the dictionary with the fields 'level', 'path',
+            # 'children'
+            node_dict = OrderedDict()
+            node_dict['id'] = node.id
+            node_dict['tn_parent'] = node.tn_parent_id
+            node_dict['tn_priority'] = node.tn_priority
+            node_dict['level'] = node.get_depth()
+            node_dict['path'] = node.get_breadcrumbs('tn_priority')
+
+            # Add the rest of the model fields.
+            # Iterate over all the fields obtained via _meta.get_fields()
+            for field in node._meta.get_fields():
+                # Skipping fields that are already added or not required
+                # (e.g. tn_closure or virtual links)
+                if field.name in [
+                        'id', 'tn_parent', 'tn_priority', 'tn_closure',
+                        'children']:
+                    continue
+
+                try:
+                    value = getattr(node, field.name)
+                except Exception:
+                    value = None
+
+                # If the field is many-to-many, we get a list of IDs of
+                # related objects
+                if hasattr(value, 'all'):
+                    value = list(value.all().values_list('id', flat=True))
+
+                node_dict[field.name] = value
+
+            # Adding a materialized path
+            node_dict['path'] = None
+            # Adding a nesting level
+            node_dict['level'] = None
+            # We initialize the list of children, which we will then fill
+            # when assembling the tree
+            node_dict['children'] = []
+
+            # Save the node both in the list and in the dictionary by id
+            # for quick access
+            nodes_by_id[node.id] = node_dict
+            nodes_list.append(node_dict)
+
+        # Build a tree: assign each node a list of its children
+        tree = []
+        for node_dict in nodes_list:
+            parent_id = node_dict['tn_parent']
+            # If there is a parent and it is present in nodes_by_id, then
+            # add the current node to the list of its children
+            if parent_id and parent_id in nodes_by_id:
+                parent_node = nodes_by_id[parent_id]
+                parent_node['children'].append(node_dict)
+            else:
+                # If there is no parent, this is the root node of the tree
+                tree.append(node_dict)
+
+        return tree
+
+    @classmethod
+    def get_tree_json(cls, instance=None):
+        """Represent the tree as a JSON-compatible string."""
+        tree = cls.dump_tree(instance)
+        return DjangoJSONEncoder().encode(tree)
+
+    @classmethod
+    def load_tree(cls, tree_data):
+        """
+        Load a tree from a list of dictionaries.
+
+        Loaded nodes are synchronized with the database: existing records
+        are updated, new ones are created.
+        Each dictionary must contain the 'id' key to identify the record.
+        """
+
+        def flatten_tree(nodes, model_fields):
+            """
+            Recursively traverse the tree and generate lists of nodes.
+
+            Each node in the list is a copy of the dictionary without
+            the service keys 'children', 'level', 'path'.
+            """
+            flat = []
+            for node in nodes:
+                # Create a copy of the dictionary so as not to affect
+                # the original tree
+                node_copy = node.copy()
+                children = node_copy.pop('children', [])
+                # Remove temporary/service fields that are not related to
+                # the model
+                for key in list(node_copy.keys() - model_fields):
+                    del node_copy[key]
+                flat.append(node_copy)
+                # Recursively add all children
+                flat.extend(flatten_tree(children, model_fields))
+            return flat
+
+        # Get a flat list of nodes (from root to leaf)
+        model_fields = [field.name for field in cls._meta.get_fields()]
+        flat_nodes = flatten_tree(tree_data, model_fields)
+
+        # Load all ids for a given model from the database to minimize
+        # the number of database requests
+        existing_ids = set(cls.objects.values_list('id', flat=True))
+
+        # Lists for nodes to update and create
+        nodes_to_update = []
+        nodes_to_create = []
+
+        # Determine which model fields should be updated (excluding 'id')
+        # This assumes that all model fields are used in serialization
+        # (excluding service ones, like children)
+        field_names = model_fields.remove('id')
+
+        # Iterate over each node from the flat list
+        for node_data in flat_nodes:
+            # Collect data for creation/update.
+            # There is already an 'id' in node_data, so we can distinguish
+            # an existing entry from a new one.
+            data = {k: v for k, v in node_data.items()
+                    if k in field_names or k == 'id'}
+
+            # Handle the foreign key tn_parent.
+            # If the value is None, then there is no parent, otherwise
+            # the parent id is expected.
+            # Additional checks can be added here if needed.
+            if 'tn_parent' in data and data['tn_parent'] is None:
+                data['tn_parent'] = None
+
+            # Если id уже есть в базе, то будем обновлять запись,
+            # иначе создаем новую.
+            if data['id'] in existing_ids:
+                nodes_to_update.append(cls(**data))
+            else:
+                nodes_to_create.append(cls(**data))
+
+        # Perform operations in a transaction to ensure data integrity.
+        with transaction.atomic():
+            # bulk_create – creating new nodes
+            if nodes_to_create:
+                cls.objects.bulk_create(nodes_to_create, batch_size=1000)
+            # bulk_update – updating existing nodes.
+            # When bulk_update, we must specify a list of fields to update.
+            if nodes_to_update:
+                cls.objects.bulk_update(
+                    nodes_to_update,
+                    fields=field_names,
+                    batch_size=1000
+                )
+        cls.clear_cache()
+
+    @classmethod
+    def load_tree_json(cls, json_str):
+        """
+        Decode a JSON string into a dictionary.
+
+        Takes a JSON-compatible string and decodes it into a tree structure.
+        """
+        try:
+            tree_data = json.loads(json_str)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Error decoding JSON: {e}")
+
+        cls.load_tree(tree_data)
+
+    @classmethod
+    @cached_method
+    def get_tree_display(cls, instance=None, symbol="—"):
+        """Get a multiline string representing the model tree."""
+        # If instance is passed, we get all its descendants (including itself)
+        if instance:
+            queryset = instance.get_descendants_queryset(include_self=True)\
+                .prefetch_related("tn_children")\
+                .annotate(depth=models.Max("parents_set__depth"))\
+                .order_by("depth", "tn_parent", "tn_priority")
+        else:
+            queryset = cls.objects.all()\
+                .prefetch_related("tn_children")\
+                .annotate(depth=models.Max("parents_set__depth"))\
+                .order_by("depth", "tn_parent", "tn_priority")
+        # Convert queryset to list for indexed access
+        nodes = list(queryset)
+        sorted_nodes = cls._sort_node_list(nodes)
+        result = []
+        for node in sorted_nodes:
+            # Insert an indent proportional to the depth of the node
+            indent = symbol * node.depth
+            result.append(indent + str(node))
+        return result
+
+    @classmethod
+    @cached_method
+    def get_tree_annotated(cls):
+        """
+        Get an annotated list from a tree branch.
+
+        Something like this will be returned:
+        [
+            (a,     {'open':True,  'close':[],    'level': 0})
+            (ab,    {'open':True,  'close':[],    'level': 1})
+            (aba,   {'open':True,  'close':[],    'level': 2})
+            (abb,   {'open':False, 'close':[],    'level': 2})
+            (abc,   {'open':False, 'close':[0,1], 'level': 2})
+            (ac,    {'open':False, 'close':[0],   'level': 1})
+        ]
+
+        All nodes are ordered by materialized path.
+        This can be used with a template like this:
+
+        {% for item, info in annotated_list %}
+            {% if info.open %}
+                <ul><li>
+            {% else %}
+                </li><li>
+            {% endif %}
+
+            {{ item }}
+
+            {% for close in info.close %}
+                </li></ul>
+            {% endfor %}
+        {% endfor %}
+
+        """
+        # Load the tree with the required preloads and depth annotation.
+        queryset = cls.objects.all()\
+            .prefetch_related("tn_children")\
+            .annotate(depth=models.Max("parents_set__depth"))\
+            .order_by("depth", "tn_parent", "tn_priority")
+        # Convert queryset to list for indexed access
+        nodes = list(queryset)
+        total_nodes = len(nodes)
+        sorted_nodes = cls._sort_node_list(nodes)
+
+        result = []
+
+        for i, node in enumerate(sorted_nodes):
+            # Get the value to display the node
+            value = str(node)
+            # Determine if there are descendants (use prefetch_related to avoid
+            # additional queries)
+            value_open = len(node.tn_children.all()) > 0
+            level = node.depth
+
+            # Calculate the "close" field
+            if i + 1 < total_nodes:
+                next_node = nodes[i + 1]
+                depth_diff = level - next_node.depth
+                # If the next node is at a lower level, then some open
+                # levels need to be closed
+                value_close = list(range(next_node.depth, level)
+                                   ) if depth_diff > 0 else []
+            else:
+                # For the last node, close all open levels
+                value_close = list(range(0, level + 1))
+
+            result.append(
+                (value, {
+                    "open": value_open,
+                    "close": value_close,
+                    "level": level
+                })
+            )
+        return result
+
+    @classmethod
+    @transaction.atomic
+    def update_tree(cls):
+        """Rebuilds the closure table."""
+        # Clear cache
+        cls.clear_cache()
+        cls.closure_model.delete_all()
+        objs = list(cls.objects.all())
+        cls.closure_model.objects.bulk_create(objs, batch_size=1000)
+
+    @classmethod
+    def delete_tree(cls):
+        """Delete the whole tree for the current node class."""
+        cls.clear_cache()
+        cls.objects.all().delete()
+
+# The end

treenode/signals.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+"""
+TreeNode Signals Module
+
+Version: 2.1.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+from contextlib import contextmanager
+
+
+@contextmanager
+def disable_signals(signal, sender):
+    """Temporarily disable execution of signal generation."""
+    # Save current signal handlers
+    old_receivers = signal.receivers[:]
+    signal.receivers = []
+    try:
+        yield
+    finally:
+        # Restore handlers
+        signal.receivers = old_receivers
+
+
+# Tne End

treenode/static/treenode/css/tree_widget.css

@@ -11,52 +11,222 @@ Features:
 - Custom styling for search fields and selection indicators.
 - Enhances usability in tree-based data selection.
 
+Main styles:
+.tree-widget-display: styles the display area of ​​the selected item, adding
+ padding, borders, and background.
+.tree-dropdown-arrow: styles the dropdown arrow.
+.tree-widget-dropdown: defines the style of the dropdown, including positioning,
+ size, and shadows.
+.tree-search-wrapper: decorates the search area inside the dropdown.
+.tree-search: styles the search input.
+.tree-clear-button: button to clear the search input.
+.tree-list and .tree-node: styles for the list and its items.
+.expand-button: button to expand child elements.
+
+Dark theme:
+Uses the .dark-theme class to apply dark styles. Changes the background,
+borders, and text color for the corresponding elements. Ensures comfortable use
+of the widget in dark mode.
+
 Version: 2.0.0
 Author: Timur Kady
 Email: timurkady@yandex.com
+
 */
 
-/* Select2 dropdown */
-.select2-dropdown.dark-theme {
-    background-color: #2c2c2c !important;
-    border: 1px solid #444 !important;
-    color: #ddd !important;
+.form-row.field-tn_parent {
+    position: relative;
+    overflow: visible !important;
+    z-index: auto;
+}
+
+.tree-widget {
+    position: relative;
+    width: 100%;
+    font-family: Arial, sans-serif;
+}
+
+.tree-widget-display {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    border: 1px solid #aaa;
+    border-radius: 4px;
+    background-color: #fff;
+    cursor: pointer;
+    transition: border-color 0.2s;
+}
+
+.tree-widget-display:hover {
+    border-color: #333;
+}
+
+.tree-dropdown-arrow {
+    font-size: 0.8em;
+    color: #888;
+    display: inline-block;
+    height: 100%;
+    background-color: lightgrey;
+    padding: 8px;
+    margin: 0;
+    border-radius: 0 4px 4px 0;
+}
+
+.tree-widget-dropdown {
+    display: none;
+    position: absolute;
+    top: 100%;
+    left: 0;
+    width: 100%;
+    max-height: 242px;
+    overflow-y: auto;
+    border: 1px solid #aaa;
+    border-top: none;
+    border-radius: 0 3px 3px 0;
+    background-color: #fff;
+    z-index: 1000;
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+}
+
+.tree-search-wrapper {
+    display: flex;
+    align-items: center;
+    padding: 6px;
+    border-bottom: 1px solid #ddd;
+    background-color: #f9f9f9;
+}
+
+.tree-search-icon {
+    margin-right: 6px;
+    font-size: 1.3em;
+}
+
+.tree-search {
+    flex-grow: 1;
+    padding: 6px;
+    border: 1px solid #ccc;
+    border-radius: 4px;
+    font-size: 1em;
+}
+
+.tree-search-clear{
+    border: none;
+    border-radius: 3px;
+    background: none;
+    font-size: 1.8em;
+    cursor: pointer; 
+}
+
+.tree-clear-button {
+    background: none;
+    border: none;
+    font-size: 1.2em;
+    color: #888;
+    cursor: pointer;
+    margin-left: 6px;
+}
+
+.tree-list {
+    list-style: none;
+    margin: 0 !important;
+    padding: 0 !important;
+}
+
+.tree-node {
+    display: block !important;
+    padding: 6px 0px !important;
+    cursor: pointer;
+    transition: background-color 0.2s;
+}
+
+.tree-node:hover {
+    background-color: #f0f0f0;
+}
+
+.tree-node[data-level="1"] {
+    padding-left: 20px;
+}
+
+.tree-node[data-level="2"] {
+    padding-left: 40px;
+}
+
+.expand-button {
+    display: inline-block;
+    width: 18px;
+    height: 18px;
+    background: var(--button-bg);
+    color: var(--button-fg);
+    border-radius: 3px;
+    border: none;
+    margin: 0px 5px;
+    cursor: pointer;
+    font-size: 12px;
+    line-height: 18px;
+    padding: 0px;
+    opacity: 0.8;
+}
+
+.no-expand {
+    display: inline-block;
+    width: 18px;
+    height: 18px;    
+    border: none;
+    margin: 0px 5px;
+}
+
+.selected-node {
+    margin: 6px 12px;
+}
+
+/* Тёмная тема */
+.dark-theme .tree-widget-display {
+    background-color: #333;
+    border-color: #555;
+    color: #eee;
+}
+
+.dark-theme .tree-dropdown-arrow {
+    color: #ccc;
+}
+
+.dark-theme .tree-widget-dropdown {
+    background-color: #444;
+    border-color: #555;
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.5);
+}
+
+.dark-theme .tree-search-wrapper {
+    background-color: #555;
+    border-bottom-color: #666;
+}
+
+.dark-theme .tree-search {
+    background-color: #666;
+    border-color: #777;
+    color: #eee;
 }
 
-/* List of options */
-.select2-dropdown.dark-theme .select2-results__option {
-    background-color: transparent !important;
-    color: #ddd !important;
+.dark-theme .tree-search::placeholder {
+    color: #ccc;
 }
 
-/* Hover/selected option */
-.select2-dropdown.dark-theme .select2-results__option--highlighted,
-.select2-dropdown.dark-theme .select2-results__option--selected {
-    background-color: #555 !important;
-    color: #fff !important;
+.dark-theme .tree-clear-button {
+    color: #ccc;
 }
 
-/* Search field */
-.select2-dropdown.dark-theme .select2-search.select2-search--dropdown .select2-search__field {
-    background-color: #2c2c2c !important;
-    color: #ddd !important;
-    border: 1px solid #444 !important;
-    outline: none !important;
+.dark-theme .tree-node {
+    color: #eee;
 }
 
-/* Container of the selected element (if we want to darken it too) */
-.select2-container--default .select2-selection--single.dark-theme {
-    background-color: #2c2c2c !important;
-    border: 1px solid #444 !important;
-    color: #ddd !important;
+.dark-theme .tree-node:hover {
+    background-color: #555;
 }
 
-/* Arrow */
-.select2-container--default .select2-selection--single.dark-theme .select2-selection__arrow b {
-    border-color: #ddd transparent transparent transparent !important;
+.dark-theme .expand-button {
+    color: #ccc;
 }
 
-/* Text of the selected element */
-.select2-container--default .select2-selection--single.dark-theme .select2-selection__rendered {
-    color: #ddd !important;
+.dark-theme .selected-node {
+    color: #eee;
 }