django-fast-treenode 2.1.5__py3-none-any.whl → 3.0.0__py3-none-any.whl

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

treenode/apps.py

@@ -1,34 +1,56 @@
-# -*- coding: utf-8 -*-
 """
-TreeNode Application Configuration
+TreeNode configuration definition module.
 
-This module defines the application configuration for the TreeNode app.
-It sets the default auto field and specifies the app's name.
+Customization:
+- checks the correctness of the sorting fields
+- checks the correctness of model inheritance
+- starts asynchronous loading of node data into the cache
 
-Version: 2.1.0
+Version: 3.0.0
 Author: Timur Kady
 Email: timurkady@yandex.com
 """
 
-
-import logging
-from django.apps import AppConfig
-from django.db.models.signals import post_migrate
-
-logger = logging.getLogger(__name__)
+from django.apps import apps, AppConfig
 
 
 class TreeNodeConfig(AppConfig):
-    """TreeNodeConfig Class."""
+    """Config Class."""
 
     default_auto_field = "django.db.models.BigAutoField"
-    name = "treenode"
+    name = "supertree"
 
     def ready(self):
-        """
-        Attach a post_migrate handler.
-
-        This allows you to perform operations after the migration is complete.
-        """
-        from .utils.db import post_migrate_update
-        post_migrate.connect(post_migrate_update, sender=self)
+        """Ready method."""
+        from .models import TreeNodeModel
+
+        # Models checking
+        subclasses = [
+            m for m in apps.get_models()
+            if issubclass(m, TreeNodeModel) and m is not TreeNodeModel
+        ]
+
+        for model in subclasses:
+
+            field_names = {f.name for f in model._meta.get_fields()}
+
+            # Check display_field is correct
+            if model.display_field is not None:
+                if model.display_field not in field_names:
+                    raise ValueError(
+                        f'Invalid display_field "{model.display_field}. "'
+                        f'Available fields: {field_names}')
+
+            # Check sorting_field is correct
+            if model.sorting_field is not None:
+                if model.sorting_field not in field_names:
+                    raise ValueError(
+                        f'Invalid sorting_field "{model.sorting_field}. "'
+                        f'Available fields: {field_names}')
+
+            # Check if Meta is a descendant of TreeNodeModel.Meta
+            if not issubclass(model.Meta, TreeNodeModel.Meta):
+                raise ValueError(
+                    f'{model.__name__} must inherit Meta class ' +
+                    'from TreeNodeModel.Meta.'
+                )