django-fast-treenode 2.1.4__py3-none-any.whl → 3.0.1__py3-none-any.whl

treenode/admin/exporter.py

@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*-
+"""
+TreeNode Exporter Module
+
+This module provides functionality for stream exporting tree-structured data
+to various formats, including CSV, JSON, TSV, XLSX, YAML.
+
+Version: 3.0.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+import csv
+import json
+import yaml
+from django.core.serializers.json import DjangoJSONEncoder
+from django.http import StreamingHttpResponse
+from io import BytesIO, StringIO
+from openpyxl import Workbook
+
+
+class TreeNodeExporter:
+    """Exporter for tree-structured data to various formats."""
+
+    def __init__(self, model, filename="tree_nodes", fileformat="csv"):
+        """
+        Initialize exporter.
+
+        :param queryset: Django QuerySet to export.
+        :param filename: Base name for the output file.
+        :param fileformat: Export format (csv, json, xlsx, yaml, tvs).
+        """
+        self.filename = filename
+        self.format = fileformat
+        self.model = model
+        self.queryset = model.objects.get_queryset()
+        self.fields = self.get_ordered_fields()
+
+    def get_ordered_fields(self):
+        """
+        Define and return the ordered list of fields for export.
+
+        Required fields come first, blocked fields are omitted.
+        """
+        fields = sorted([field.name for field in self.model._meta.fields])
+        required_fields = ["id", "parent", "priority"]
+        blocked_fields = ["_path", "_depth"]
+
+        other_fields = [
+            field for field in fields
+            if field not in required_fields and field not in blocked_fields
+        ]
+        return required_fields + other_fields
+
+    def get_obj(self):
+        """Yield rows from queryset as row data dict."""
+        queryset = self.queryset.order_by('_path').only(*self.fields)
+        for obj in queryset.iterator():
+            yield obj
+
+    def get_serializable_row(self, obj):
+        """Get serialized object."""
+        fields = self.fields
+        raw_data = {}
+        for field in fields:
+            if field == "parent":
+                raw_data["parent"] = getattr(obj, "parent_id", None)
+            else:
+                raw_data[field] = getattr(obj, field, None)
+        serialized = json.loads(json.dumps(raw_data, cls=DjangoJSONEncoder))
+        return serialized
+
+    def csv_stream_data(self, delimiter=","):
+        """Stream CSV or TSV data."""
+        yield "\ufeff"  # BOM for Excel
+        buffer = StringIO()
+        writer = csv.DictWriter(
+            buffer,
+            fieldnames=self.fields,
+            delimiter=delimiter
+        )
+        writer.writeheader()
+        yield buffer.getvalue()
+        buffer.seek(0)
+        buffer.truncate(0)
+
+        for obj in self.get_obj():
+            row = self.get_serializable_row(obj)
+            writer.writerow(row)
+            yield buffer.getvalue()
+            buffer.seek(0)
+            buffer.truncate(0)
+
+    def json_stream_data(self):
+        """Stream JSON data."""
+        yield "[\n"
+        first = True
+        for obj in self.get_obj():
+            row = self.get_serializable_row(obj)
+            if not first:
+                yield ",\n"
+            else:
+                first = False
+            yield json.dumps(row, ensure_ascii=False)
+        yield "\n]"
+
+    def tsv_stream_data(self, chunk_size=1000):
+        """Stream TSV (tab-separated values) data."""
+        yield from self.csv_stream_data(delimiter="\t")
+
+    def yaml_stream_data(self):
+        """Stream YAML data."""
+        yield "---\n"
+        for obj in self.get_obj():
+            row = self.get_serializable_row(obj)
+            yield yaml.safe_dump([row], allow_unicode=True)
+
+    def xlsx_stream_data(self):
+        """Stream XLSX data."""
+        wb = Workbook()
+        ws = wb.active
+        ws.append(self.fields)
+
+        for obj in self.get_obj():
+            row = self.get_serializable_row(obj)
+            ws.append([row.get(f, "") for f in self.fields])
+
+        output = BytesIO()
+        wb.save(output)
+        output.seek(0)
+        yield output.getvalue()
+
+    def process_record(self):
+        """
+        Create a StreamingHttpResponse based on selected format.
+
+        :param chunk_size: Batch size for iteration.
+        :return: StreamingHttpResponse object.
+        """
+        if self.format == 'xlsx':
+            response = StreamingHttpResponse(
+                streaming_content=self.xlsx_stream_data(),
+                content_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet; charset=utf-8"  # noqa: D501
+            )
+        elif self.format == 'tsv':
+            response = StreamingHttpResponse(
+                streaming_content=self.csv_stream_data(delimiter="\t"),
+                content_type="text/tab-separated-values; charset=utf-8"
+            )
+        elif self.format == 'csv':
+            response = StreamingHttpResponse(
+                streaming_content=self.csv_stream_data(delimiter=","),
+                content_type="text/csv; charset=utf-8"
+            )
+        elif self.format == 'yaml':
+            response = StreamingHttpResponse(
+                streaming_content=self.yaml_stream_data(),
+                content_type=f"application/{self.format}; charset=utf-8"
+            )
+        else:
+            response = StreamingHttpResponse(
+                streaming_content=self.json_stream_data(),
+                content_type=f"application/{self.format}; charset=utf-8"
+            )
+
+        response['Content-Disposition'] = f'attachment; filename="{self.filename}"'  # noqa: D501
+        return response
+
+
+# The End

treenode/admin/importer.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+"""
+TreeNode Importer Module
+
+This module provides functionality for importing tree-structured data
+from various formats, including CSV, JSON, XLSX, YAML, and TSV.
+
+Features:
+- Supports field mapping and data type conversion for model compatibility.
+- Handles ForeignKey relationships and ManyToMany fields.
+- Validates and processes raw data before saving to the database.
+- Uses bulk operations for efficient data insertion and updates.
+- Supports transactional imports to maintain data integrity.
+
+Version: 3.0.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+# Новый модуль импорта для древовидных структур в Django
+
+import csv
+import json
+import yaml
+import openpyxl
+from io import BytesIO, StringIO
+from django.db import transaction
+from django.core.exceptions import ValidationError, ObjectDoesNotExist
+
+from ..cache import treenode_cache as cache
+
+
+class TreeNodeImporter:
+    """Importer of tree data from various formats."""
+
+    def __init__(self, model, file, file_format):
+        """Init."""
+        self.model = model
+        self.file = file
+        self.format = file_format.lower()
+        self.rows = []
+        self.rows_by_id = {}
+        self.result = {"created": 0, "updated": 0, "errors": []}
+
+    def parse(self):
+        """Parse a file."""
+        if self.format == "xlsx":
+            content = self.file.read()  # binary
+            self.rows = self._parse_xlsx(content)
+        else:
+            text = self.file.read()
+            if isinstance(text, bytes):
+                text = text.decode("utf-8")
+
+            if self.format == "csv":
+                self.rows = list(csv.DictReader(StringIO(text)))
+            elif self.format == "tsv":
+                self.rows = list(csv.DictReader(StringIO(text), delimiter="\t"))
+            elif self.format == "json":
+                self.rows = json.loads(text)
+            elif self.format == "yaml":
+                self.rows = yaml.safe_load(text)
+            else:
+                raise ValueError("Unsupported file format")
+
+        self._build_hierarchy()
+
+    def _parse_xlsx(self, content):
+        """Parse the xlsx format."""
+        wb = openpyxl.load_workbook(BytesIO(content), read_only=True)
+        ws = wb.active
+        headers = [cell.value for cell in next(
+            ws.iter_rows(min_row=1, max_row=1))]
+        return [
+            dict(zip(headers, row))
+            for row in ws.iter_rows(min_row=2, values_only=True)
+        ]
+
+    def _build_hierarchy(self):
+        """
+        Build and check hierarchy.
+
+        Calculates _depth and _path based on parent and priority. Checks that
+        each parent exists in either the imported set or the base. The _path
+        is built based on priority, as in the main package.
+        """
+        self.rows_by_id = {str(row.get("id")): row for row in self.rows}
+
+        def build_path_and_depth(row, visited=None):
+            if visited is None:
+                visited = set()
+            row_id = str(row.get("id"))
+            if row_id in visited:
+                raise ValueError(f"Cycle detected at row {row_id}")
+            visited.add(row_id)
+
+            parent_id = str(row.get("parent")) if row.get("parent") else None
+            if not parent_id:
+                row["_depth"] = 0
+                row["_path"] = str(row.get("priority", "0")).zfill(4)
+                return row["_path"]
+
+            parent_row = self.rows_by_id.get(parent_id)
+            if parent_row:
+                parent_path = build_path_and_depth(parent_row, visited)
+            else:
+                try:
+                    self.model.objects.get(pk=parent_id)
+                    parent_path = "fromdb"
+                except ObjectDoesNotExist:
+                    self.result["errors"].append(
+                        f"Parent {parent_id} for node {row_id} not found.")
+                    parent_path = "invalid"
+
+            row["_depth"] = parent_path.count(
+                ".") + 1 if parent_path != "invalid" else 0
+            priority = str(row.get("priority", "0")).zfill(4)
+            row["_path"] = parent_path + "." + \
+                priority if parent_path != "invalid" else priority
+            return row["_path"]
+
+        for row in self.rows:
+            try:
+                build_path_and_depth(row)
+            except Exception as e:
+                self.result["errors"].append(str(e))
+
+    def import_tree(self):
+        """Import tree nodes level by level."""
+        with transaction.atomic():
+            rows_by_level = {}
+            for row in self.rows:
+                level = row.get("_depth", 0)
+                rows_by_level.setdefault(level, []).append(row)
+
+            id_map = {}
+            for depth in sorted(rows_by_level.keys()):
+                to_create = []
+                for row in rows_by_level[depth]:
+                    pk = row.get("id")
+
+                    if "parent" in row and (row["parent"] == "" or row["parent"] is None):
+                        row["parent"] = None
+
+                    if "parent" in row:
+                        temp_parent_id = row.pop("parent")
+                        if temp_parent_id is not None:
+                            # Используем уже созданный ID родителя
+                            row["parent_id"] = id_map.get(
+                                temp_parent_id, temp_parent_id)
+
+                    try:
+                        obj = self.model(**row)
+                        obj.full_clean()
+                        to_create.append(obj)
+                    except ValidationError as e:
+                        self.result["errors"].append(
+                            f"Validation error for {pk}: {e}")
+
+                created = self.model.objects.bulk_create(to_create)
+                for obj in created:
+                    id_map[obj.pk] = obj.pk
+                self.result["created"] += len(created)
+
+        self.model.tasks.add("update", None)
+        cache.invalidate(self.model._meta.label)
+
+        return self.result
+
+
+# The End

treenode/admin/mixin.py

@@ -0,0 +1,291 @@
+# -*- coding: utf-8 -*-
+"""
+TreeNode Admin Model Class Mixin
+
+Views for AdminModel
+
+Version: 3.0.0
+Author: Timur Kady
+Email: timurkady@yandex.com
+"""
+
+import os
+import json
+from datetime import datetime
+from django.contrib import admin
+from django.contrib.admin.helpers import ACTION_CHECKBOX_NAME
+from django.contrib.admin.utils import lookup_field
+from django.db.models import Q
+from django.http import HttpResponseBadRequest
+from django.http import JsonResponse
+from django.shortcuts import render
+from django.template.loader import render_to_string
+from django.urls import path
+from django.utils.decorators import method_decorator
+from django.utils.safestring import mark_safe
+from django.utils.translation import gettext_lazy as _
+from django.views.decorators.cache import never_cache
+
+
+class AdminMixin(admin.ModelAdmin):
+    """Admin Mixin for lazy loading and search in tree."""
+
+    def get_search_help_text(self, request):
+        """Get search help text."""
+        return getattr(super(), 'get_search_help_text', lambda r: '')(request)
+
+    def get_urls(self):
+        """Add custom URLs for AJAX loading and searching."""
+        default_urls = super().get_urls()
+
+        custom_urls = [
+            path(
+                "change_list/",
+                self.admin_site.admin_view(self.ajax_changelist_view),
+                name="tree_changelist"
+            ),
+            path(
+                "move/",
+                self.admin_site.admin_view(self.ajax_move_view),
+                name="tree_changelist_move"
+            ),
+            path(
+                "import/",
+                self.admin_site.admin_view(self.import_view),
+                name="tree_node_import"
+            ),
+            path("export/",
+                 self.admin_site.admin_view(self.export_view),
+                 name="tree_node_export"
+                 ),
+        ]
+        return custom_urls + default_urls
+
+    def render_changelist_rows(self, objs: list, request):
+        """Rander rows for incert to changelist."""
+        list_display = list(self.get_list_display(request))
+        checkbox_field_name = ACTION_CHECKBOX_NAME
+        if checkbox_field_name not in list_display:
+            list_display.insert(0, checkbox_field_name)
+
+        rows = []
+        for obj in objs:
+            row_data = []
+            td_classes = []
+
+            for field in list_display:
+                if field == ACTION_CHECKBOX_NAME:
+                    checkbox = f'<input type="checkbox" id="action_{obj.pk}" name="{ACTION_CHECKBOX_NAME}" value="{obj.pk}" class="action-select" />'  # noqa: D501
+                    row_data.append(mark_safe(checkbox))
+                    td_classes.append("action-checkbox")
+                    continue
+
+                if callable(field):
+                    value = field(obj)
+                    field_name = getattr(field, "__name__", "field")
+                else:
+                    attr, value = lookup_field(field, obj, self)
+                    field_name = field
+
+                row_data.append(value)
+                td_classes.append(f"field-{field_name}")
+
+            rows.append({
+                "node_id": obj.pk,
+                "attrs": f'data-node-id="{obj.pk}" data-parent-of="{obj.parent_id or ""}" class="model-{self.model._meta.model_name} pk-{obj.pk}"',  # noqa: D501
+                "parent_id": obj.parent_id,
+                "cells": list(zip(row_data, td_classes)),
+            })
+        return rows
+
+    @method_decorator(never_cache)
+    def ajax_changelist_view(self, request, extra_context=None):
+        """
+        Create a default changelist or load child elements via AJAX.
+
+        - If `parent_id` is passed, returns only child rows (HTML).
+        - If `q` is passed, returns up to 20 matching rows (HTML).
+        - Otherwise, displays the full changelist.
+        """
+        extra_context = extra_context or {}
+        extra_context['import_export_enabled'] = self.import_export
+        # Define the show_admin_actions variable in the context
+        extra_context['show_admin_actions'] = extra_context.get(
+            "show_admin_actions", False)
+        parent_id = request.GET.get("parent_id", "")
+        query = request.GET.get("q", "")
+        expanded = request.GET.get("expanded", "[]")
+
+        if parent_id:
+            parent = self.model.objects.filter(pk=parent_id).first()
+            rows_list = parent.get_children() if parent else []
+
+        elif query:
+            name_field = getattr(self.model, "display_field", "id")
+            rows_list = list(self.model.objects.filter(
+                Q(**{f"{name_field}__icontains": query})
+                | Q(pk__icontains=query)
+            ).order_by("_path")[:20])
+
+        elif expanded:
+            try:
+                expanded_list = json.loads(expanded)
+            except ValueError:
+                return JsonResponse({"error": _("Bad node list.")}, status=422)
+            if expanded_list:
+                queryset = self.model.objects.filter(
+                    Q(parent__isnull=True) |
+                    Q(pk__in=expanded_list) |
+                    Q(parent_id__in=expanded_list)
+                ).distinct()
+            else:
+                queryset = self.model.objects.filter(parent__isnull=True)
+
+            rows_list = list(queryset.order_by("_path"))
+        else:
+            return JsonResponse({"html": ""})
+
+        rows = self.render_changelist_rows(rows_list, request)
+
+        # Take model verbose name
+        verbose_name = getattr(self.model._meta, "verbose_name_plural", None) \
+            or getattr(self.model._meta, "verbose_name", None) \
+            or self.model._meta.object_name
+
+        # Render HTML
+        html = render_to_string(
+            "admin/treenode_ajax_rows.html",
+            {"rows": rows},
+            request=request
+        )
+        return JsonResponse({"html": html, "label": verbose_name})
+
+    @method_decorator(never_cache)
+    def ajax_move_view(self, request, extra_context=None):
+        """
+        Perform drag-and-drop move operation for a node.
+
+        Moves a node relative to a target node using the specified mode.
+        """
+        # 1. Extracting parameters
+        node_id = request.POST.get("node_id")
+        target_id = request.POST.get("target_id")
+        mode = request.POST.get("mode")
+
+        if not (node_id and mode):
+            return JsonResponse({"error": _("Missing parameters.")}, status=400)
+
+        # 2. Getting objects
+        node = self.model.objects.filter(pk=node_id).first()
+        if not node or mode not in ("child", "after"):
+            return JsonResponse(
+                {"error": _(f"Invalid node ({node_id}) or mode ({mode}).")},
+                status=422
+            )
+
+        # Prepare the target
+        if not target_id or target_id == 'null':
+            # Insetr like a root
+            target_id = None
+            target = None
+        else:
+            target_id = int(target_id)
+            target = self.model.objects.filter(pk=target_id).first()
+
+        # 3. Protection from moving into your descendants
+        descendants_pks = node.query("descendants", include_self=True)
+        if target_id in descendants_pks:
+            return JsonResponse({
+                "error": _("Cannot move a node into its own descendants.")
+            }, status=409)
+
+        # 4. Positioning and moving
+        sorting_mode = self.model.sorting_field == 'priority'
+        if target:
+            position = {
+                "after": 'right-sibling' if sorting_mode else 'sorted-sibling',
+                "child": 'last-child' if sorting_mode else 'sorted-child'
+            }[mode]
+        else:
+            position = 'first-root' if sorting_mode else 'sorted-root'
+
+        # 5. Adjustments
+        if mode == 'after' and node.parent == target:
+            # User wants to insert a node after a node-parent
+            # print("User wants to insert a node after a node-parent.")
+            pass
+
+        # Debug
+        # print(mode, "-", position)
+
+        # Moving
+        node.move_to(target, position)
+
+        return JsonResponse({
+            "message": _("1 node successfully moved")
+        }, status=200)
+
+    def import_view(self, request):
+        """
+        Impoern View.
+
+        Handles file upload and initiates import processing via
+        TreeNodeImporter.
+        Renders summary and any errors.
+        """
+        if request.method == "POST":
+            file = request.FILES.get("file")
+            if not file:
+                return HttpResponseBadRequest("Missing file or format")
+
+            filename = file.name
+            extension = os.path.splitext(filename)[1].lower().lstrip('.')
+            if extension not in ['csv', 'tsv', 'json', 'xlsx', 'yaml']:
+                return JsonResponse(
+                    {"error": _(f"Invalid file format ({extension}.")},
+                    status=200
+                )
+            importer = self.TreeNodeImporter(self.model, file, extension)
+            importer.parse()
+            result = importer.import_tree()
+
+            return render(request, "admin/treenode_import_export.html", {
+                "created_count": result.get("created", 0),
+                "updated_count": result.get("updated", 0),
+                "errors": result.get("errors", []),
+                "import_active": True
+            })
+
+        return render(
+            request,
+            "admin/treenode_import_export.html",
+            {"import_active": True}
+        )
+
+    def export_view(self, request):
+        """
+        Export View.
+
+        Handles GET-based export of data in selected format via
+        TreeNodeExporter.
+        Returns a streaming response for large datasets.
+        """
+        if request.GET.get("download"):
+            fmt = request.GET.get("format", "csv")
+            filename = self.model._meta.object_name
+            timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M")
+            filename = f"{filename}-{timestamp}.{fmt}"
+            exporter = self.TreeNodeExporter(
+                self.model,
+                filename=filename,
+                fileformat=fmt
+            )
+            return exporter.process_record()
+
+        return render(
+            request,
+            "admin/treenode_import_export.html",
+            {"import_active": False}
+        )
+
+# The End