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

treenode/models/proxy.py

@@ -13,7 +13,7 @@ Features:
 - Provides a caching mechanism for performance optimization.
 - Includes methods for tree traversal, manipulation, and serialization.
 
-Version: 2.0.0
+Version: 2.0.11
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
@@ -131,14 +131,14 @@ class TreeNodeModel(models.Model, metaclass=TreeFactory):
 
     def get_ancestors_queryset(self, include_self=True, depth=None):
         """Get the ancestors queryset (ordered from parent to root)."""
-        return self.closure_model.get_ancestors_queryset(
-            self, include_self, depth)
+        ancestors_pks = self.get_ancestors_pks(include_self, depth)
+        result = self._meta.model.objects.filter(pk__in=ancestors_pks)
+        return result
 
     def get_ancestors(self, include_self=True, depth=None):
         """Get a list with all ancestors (ordered from root to self/parent)."""
-        return list(
-            self.get_ancestors_queryset(include_self, depth).iterator()
-        )
+        queryset = self.get_ancestors_queryset(include_self, depth)
+        return list(queryset.iterator())
 
     def get_ancestors_count(self, include_self=True, depth=None):
         """Get the ancestors count."""
@@ -146,8 +146,8 @@ class TreeNodeModel(models.Model, metaclass=TreeFactory):
 
     def get_ancestors_pks(self, include_self=True, depth=None):
         """Get the ancestors pks list."""
-        qs = self.get_ancestors_queryset(include_self, depth).only('pk')
-        return [ch.pk for ch in qs] if qs else []
+        pks = self.closure_model.get_ancestors_pks(self, include_self, depth)
+        return pks
 
     # Children --------------------
 
@@ -172,15 +172,14 @@ class TreeNodeModel(models.Model, metaclass=TreeFactory):
 
     def get_descendants_queryset(self, include_self=False, depth=None):
         """Get the descendants queryset."""
-        return self.closure_model.get_descendants_queryset(
-            self, include_self, depth
-        )
+        descendants_pks = self.get_descendants_pks(include_self, depth)
+        result = self._meta.model.objects.filter(pk__in=descendants_pks)
+        return result
 
     def get_descendants(self, include_self=False, depth=None):
         """Get a list containing all descendants."""
-        return list(
-            self.get_descendants_queryset(include_self, depth).iterator()
-        )
+        queryset = self.get_descendants_queryset(include_self, depth).iterator()
+        return list(queryset)
 
     def get_descendants_count(self, include_self=False, depth=None):
         """Get the descendants count."""
@@ -188,8 +187,8 @@ class TreeNodeModel(models.Model, metaclass=TreeFactory):
 
     def get_descendants_pks(self, include_self=False, depth=None):
         """Get the descendants pks list."""
-        qs = self.get_descendants_queryset(include_self, depth)
-        return [ch.pk for ch in qs] if qs else []
+        pks = self.closure_model.get_descendants_pks(self, include_self, depth)
+        return pks
 
     # Siblings --------------------
 
@@ -216,9 +215,16 @@ class TreeNodeModel(models.Model, metaclass=TreeFactory):
 
     # -----------------------------
 
-    def get_breadcrumbs(self, attr=None):
+    def get_breadcrumbs(self, attr='pk'):
         """Get the breadcrumbs to current node (self, included)."""
-        return self.closure_model.get_breadcrumbs(self, attr)
+        queryset = self.get_ancestors_queryset(include_self=True)
+
+        breadcrumbs = [
+            getattr(item, attr)
+            if hasattr(item, attr) else None
+            for item in queryset
+        ]
+        return breadcrumbs
 
     def get_depth(self):
         """Get the node depth (self, how many levels of descendants)."""
@@ -238,7 +244,7 @@ class TreeNodeModel(models.Model, metaclass=TreeFactory):
 
     def get_order(self):
         """Return the materialized path."""
-        path = self.closure_model.get_breadcrumbs(self, attr='tn_priority')
+        path = self.get_breadcrumbs(attr='tn_priority')
         segments = [to_base36(i).rjust(6, '0') for i in path]
         return ''.join(segments)
 
@@ -252,8 +258,18 @@ class TreeNodeModel(models.Model, metaclass=TreeFactory):
 
     def get_path(self, prefix='', suffix='', delimiter='.', format_str=''):
         """Return Materialized Path of node."""
-        path = self.closure_model.get_path(self, delimiter, format_str)
-        return prefix+path+suffix
+        priorities = self.get_breadcrumbs(attr='tn_priority')
+        # Проверяем, что список не пуст
+        if not priorities or all(p is None for p in priorities):
+            return prefix + suffix
+
+        str_ = "{%s}" % format_str
+        path = delimiter.join([
+            str_.format(p)
+            for p in priorities
+            if p is not None
+        ])
+        return prefix + path + suffix
 
     @cached_method
     def get_parent(self):
@@ -369,7 +385,9 @@ class TreeNodeModel(models.Model, metaclass=TreeFactory):
 
         # --- 2. Check mode _-------------------------------------------------
         # If the object already exists in the DB, we'll extract its old parent
-        if not is_new:
+        if is_new:
+            force_insert = True
+        else:
             ql = model.objects.filter(pk=self.pk).values_list(
                 'tn_parent',
                 'tn_priority').first()
@@ -395,7 +413,8 @@ class TreeNodeModel(models.Model, metaclass=TreeFactory):
 
         # If the parent has changed, we move it
         if (old_parent != self.tn_parent):
-            closure_model.move_node(self)
+            subtree_nodes = self.get_descendants(include_self=True)
+            self.closure_model.move_node(subtree_nodes)
 
         # --- 5. Update siblings ---------------------------------------------
         if is_new or is_move:
@@ -582,7 +601,7 @@ class TreeNodeModel(models.Model, metaclass=TreeFactory):
         # Save changes
         model = self._meta.model
         with transaction.atomic():
-            model.objects.bulk_update(sorted_siblings, ('tn_priority',), 1000)
+            model.objects.bulk_update(sorted_siblings, ('tn_priority',))
         super().save(update_fields=['tn_priority'])
         model.clear_cache()
 

treenode/templates/admin/tree_node_import.html

@@ -1,7 +1,20 @@
 {% extends "admin/base_site.html" %}
+{% load static %}
+
+{% block extrahead %}
+    <link rel="stylesheet" type="text/css" href="{% static 'admin/css/forms.css' %}">
+{% endblock %}
+
 {% block content %}
     <div class="module">
         <h2>Import Data</h2>
+
+        {% if message %}
+            <div class="successnote">
+                <p>{{ message }}</p>
+            </div>
+        {% endif %}
+        
         {% if errors %}
             <div class="errornote">
                 <p>Errors occurred while importing the data:</p>
@@ -12,16 +25,21 @@
                 </ul>
             </div>
         {% endif %}
-        <form method="post" enctype="multipart/form-data">
+
+        <form id="importForm" method="post" enctype="multipart/form-data" style="margin: 20px 0;">
             {% csrf_token %}
-            <div>
-                <label for="file">Choose file:</label>
-                <input type="file" name="file" id="file" required>
-            </div>
-            <div class="form-group" style="margin-top: 35px;">
-                <button type="submit" class="button">Import</button>
-                <a href=".." class="button cancel">Cancel</a>
+            <fieldset class="module aligned">
+                <div class="form-row field-tn_parent">
+                    <label for="file">Choose file:</label>
+                    <input type="file" name="file" id="file" required>
+                </div>
+            </fieldset>
+
+            <div class="submit-row" style="margin-top: 35px;">
+                <input id="importBtn" type="submit" value="Import" name="_save">
+                <input type="button" value="Cancel" class="button cancel" onclick="window.location.href='..';">
             </div>
         </form>
+        
     </div>
-{% endblock %}
+{% endblock %}

treenode/templates/admin/tree_node_import_report.html

@@ -0,0 +1,32 @@
+{% extends "admin/base_site.html" %}
+{% block content %}
+    <div class="module">
+        <h2>Import Results</h2>
+        
+            <ul class="messagelist">
+                <li class="success"><strong>Created:</strong> {{ created_count }} records</li>
+                <li class="success"><strong>Updated:</strong> {{ updated_count }} records</li>
+            </ul>
+
+            {% if errors %}
+                <div class="errornote">
+                    <p>Errors occurred while importing the data:</p>
+                    <ul>
+                        {% for error in errors %}
+                            <li>{{ error }}</li>
+                        {% endfor %}
+                    </ul>
+                </div>
+            {% endif %}
+
+        <div style="margin-top: 20px;">
+            <button type="button" class="button" onclick="redirectAfterImport()">Finish</button>
+        </div>
+    </div>
+
+    <script>
+        function redirectAfterImport() {
+            window.location.href = window.location.pathname.replace("import/", "") + "?import_done=1";
+        }
+    </script>
+{% endblock %}

treenode/utils/exporter.py

@@ -12,7 +12,7 @@ Features:
 - Provides optimized data extraction for QuerySets.
 - Generates downloadable files with appropriate HTTP responses.
 
-Version: 2.0.10
+Version: 2.0.11
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
@@ -23,6 +23,7 @@ import json
 import yaml
 import xlsxwriter
 import numpy as np
+import uuid
 from io import BytesIO
 from django.http import HttpResponse
 import logging
@@ -43,6 +44,7 @@ class TreeNodeExporter:
         self.queryset = queryset
         self.filename = filename
         self.fields = [field.name for field in queryset.model._meta.fields]
+        self.fields = self.get_ordered_fields()
 
     def export(self, format):
         """Determine the export format and calls the corresponding method."""
@@ -60,7 +62,9 @@ class TreeNodeExporter:
     def process_complex_fields(self, record):
         """Convert complex fields (lists, dictionaries) into JSON strings."""
         for key, value in record.items():
-            if isinstance(value, (list, dict)):
+            if isinstance(value, uuid.UUID):
+                record[key] = str(value)
+            elif isinstance(value, (list, dict)):
                 try:
                     record[key] = json.dumps(value, ensure_ascii=False)
                 except Exception as e:
@@ -68,11 +72,24 @@ class TreeNodeExporter:
                     record[key] = None
         return record
 
+    def get_ordered_fields(self):
+        """Return fields in the desired order.
+
+        Order: id, tn_parent, tn_priority, then the rest.
+        """
+        required_fields = ["id", "tn_parent", "tn_priority"]
+        other_fields = [
+            field for field in self.fields if field not in required_fields]
+        return required_fields + other_fields
+
     def get_sorted_queryset(self):
-        """Sort queryset by tn_order."""
-        queryset_list = list(self.queryset)
-        tn_orders = np.array([obj.tn_order for obj in queryset_list])
-        return [queryset_list[int(i)] for i in np.argsort(tn_orders)]
+        """Quick sort queryset by tn_order."""
+        queryset = self.queryset
+        tn_orders = np.array([obj.tn_order for obj in queryset])
+        sorted_indices = np.argsort(tn_orders)
+        queryset_list = list(queryset.iterator())
+        result = [queryset_list[int(idx)] for idx in sorted_indices]
+        return result
 
     def get_data(self):
         """Return a list of data from QuerySet as dictionaries."""
@@ -100,70 +117,78 @@ class TreeNodeExporter:
         return data
 
     def to_csv(self):
-        """Export to CSV with proper attachment handling."""
-        response = HttpResponse(content_type="text/csv")
+        """Export to CSV with proper UTF-8 encoding."""
+        response = HttpResponse(content_type="text/csv; charset=utf-8")
         response["Content-Disposition"] = f'attachment; filename="{self.filename}.csv"'
+        response.write("\ufeff")  # Добавляем BOM для Excel
+
         writer = csv.DictWriter(response, fieldnames=self.fields)
         writer.writeheader()
-        writer.writerows(self.get_data())
+        for row in self.get_data():
+            writer.writerow({key: str(value)
+                            for key, value in row.items()})  # Приводим к строкам
+
         return response
 
     def to_json(self):
-        """Export to JSON with UUID serialization handling."""
-        response = HttpResponse(content_type="application/octet-stream")
+        """Export to JSON with proper UTF-8 encoding."""
+        response = HttpResponse(content_type="application/json; charset=utf-8")
         response["Content-Disposition"] = f'attachment; filename="{self.filename}.json"'
-        json.dump(
-            self.get_data(),
-            response,
-            ensure_ascii=False,
-            indent=4,
-            default=str
-        )
+        json_str = json.dumps(self.get_data(), ensure_ascii=False, indent=4)
+        response.write(json_str)
         return response
 
     def to_xlsx(self):
-        """Export to XLSX."""
+        """Export to XLSX with UTF-8 encoding."""
         response = HttpResponse(
             content_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
         )
         response["Content-Disposition"] = f'attachment; filename="{self.filename}.xlsx"'
 
-        data = self.get_data()
         output = BytesIO()
         workbook = xlsxwriter.Workbook(output)
         worksheet = workbook.add_worksheet()
 
-        # Записываем заголовки
-        headers = list(data[0].keys()) if data else []
+        # Заголовки
+        headers = list(self.fields)
         for col_num, header in enumerate(headers):
             worksheet.write(0, col_num, header)
 
-        # Записываем строки данных
-        for row_num, row in enumerate(data, start=1):
+        # Данные
+        for row_num, row in enumerate(self.get_data(), start=1):
             for col_num, key in enumerate(headers):
-                worksheet.write(row_num, col_num, row[key])
+                worksheet.write(
+                    row_num,
+                    col_num,
+                    str(row[key]) if row[key] is not None else ""
+                )
 
         workbook.close()
         output.seek(0)
-        return response.write(output.read())
+        response.write(output.read())
+        return response
 
     def to_yaml(self):
-        """Export to YAML with proper attachment handling."""
-        response = HttpResponse(content_type="application/octet-stream")
+        """Export to YAML with proper UTF-8 encoding."""
+        response = HttpResponse(
+            content_type="application/x-yaml; charset=utf-8")
         response["Content-Disposition"] = f'attachment; filename="{self.filename}.yaml"'
-        yaml_str = yaml.dump(self.get_data(), allow_unicode=True)
+        yaml_str = yaml.dump(
+            self.get_data(), allow_unicode=True, default_flow_style=False)
         response.write(yaml_str)
         return response
 
     def to_tsv(self):
-        """Export to TSV with proper attachment handling."""
-        response = HttpResponse(content_type="application/octet-stream")
+        """Export to TSV with UTF-8 encoding."""
+        response = HttpResponse(
+            content_type="text/tab-separated-values; charset=utf-8")
         response["Content-Disposition"] = f'attachment; filename="{self.filename}.tsv"'
+        response.write("\ufeff")  # Добавляем BOM
+
         writer = csv.DictWriter(
-            response,
-            fieldnames=self.fields,
-            delimiter="	"
-        )
+            response, fieldnames=self.fields, delimiter="\t")
         writer.writeheader()
-        writer.writerows(self.get_data())
+        for row in self.get_data():
+            writer.writerow({key: str(value) for key, value in row.items()})
+
         return response