API for performantly bulk-creating pages programatically

wagtail/models/__init__.py

@@ -1299,6 +1299,164 @@
     def __str__(self):
         return self.title
 
+    def _process_sibling(self, nodes, parent):
+        """
+        Create child nodes according to the node_order_by attribute.
+        """
+
+        newpositions = []
+        siblings_so_far = self.get_siblings()
+        for i, node in enumerate(nodes):
+            pos = self._prepare_pos_var_for_add_sibling("sorted-sibling")
+            node.depth = self.depth
+            siblings = self.get_sorted_pos_queryset(siblings_so_far, node)
+            try:
+                newpos = siblings.all()[0]._get_lastpos_in_path()
+            except IndexError:
+                newpos = None
+                pos = "last-sibling"
+            newpositions.append(newpos)
+            _, newpath = self.reorder_nodes_before_add_or_move(
+                pos, newpos, self.depth, self, siblings, None, False
+            )
+
+            parent.numchild += 1
+            node.path = newpath
+            # Add node to siblings_so_far. Make node a queryset to union with siblings_so_far
+            siblings_so_far = siblings_so_far.union(siblings)
+
+        return nodes
+
+    def _process_leaf(self, nodes):
+        """
+        Process children to add to a leaf node
+        """
+        # Get number of children
+
+        step = 1
+        max_length = self.__class__._meta.get_field("path").max_length
+        for node in nodes:
+            node.depth = self.depth + 1
+            node.path = self.__class__._get_path(self.path, node.depth, step)
+            step += 1
+            if len(node.path) > max_length:
+                raise ValidationError(
+                    "The new node is too deep in the tree, try \
+                      increasing the path.max_length property \
+                    and UPDATE your database"
+                )
+            self.numchild += 1
+            node._cached_parent_obj = self
+
+        self.save()
+
+        return
+
+    def _process_unordered_children(self, nodes):
+        """
+        Create child nodes without any specific order.
+        """
+        last_child = self.get_last_child()
+        max_length = self.__class__._meta.get_field("path").max_length
+        for node in nodes:
+            node.depth = self.depth + 1
+            node.path = last_child._inc_path()
+            last_child = node
+            if len(node.path) > max_length:
+                raise ValidationError(
+                    "The new node is too deep in the tree, try \
+                      increasing the path.max_length property \
+                    and UPDATE your database"
+                )
+            self.numchild += 1
+            node._cached_parent_obj = self
+
+        self.save()
+
+        return
+
+    def _process_child_nodes(self, nodes):
+        """
+        Process the child nodes of this page, setting their paths and depths
+        as appropriate and also updating the parent's numchild. This is performed by the treebeard library when saving
+        the page to the database using their inbuilt tree functionality.
+        """
+
+        if self.node_order_by and not self.is_leaf():
+            return self.get_last_child()._process_sibling(nodes, self)
+
+        if self.is_leaf():
+            return self._process_leaf(nodes)
+
+        return self._process_unordered_children(nodes)
+
+    def _check_unique(self, children, existing_pages=None):
+        if not existing_pages:
+            existing_pages = []
+        # Extract slugs from the children
+        # Children is a list of Page objects
+        slugs = [
+            child.slug
+            for child in children + list(existing_pages)
+            if hasattr(child, "slug") and child.slug
+        ]
+        if len(slugs) != len(set(slugs)):
+            raise ValidationError(
+                {
+                    "slug": _(
+                        "Duplicate slugs in use within the parent page at '%(parent_url_path)s'"
+                    )
+                    % {
+                        "parent_url_path": self.path,
+                    }
+                }
+            )
+        for child in children:
+            if not hasattr(child, "slug") or not child.slug:
+                candidate_slug = slugify(child.title, allow_unicode=True)
+                suffix = 1
+                while candidate_slug in slugs:
+                    suffix += 1
+                    candidate_slug = "%s-%d" % (candidate_slug, suffix)
+                child.slug = candidate_slug
+                slugs.append(candidate_slug)
+
+            if child.locale_id is None:
+                child.locale = self.get_default_locale()
+        return
+
+    @transaction.atomic
+    def bulk_add_children(self, children):
+        """
+        Add multiple pages as children of this page.
+
+        This calls bulk_create on the Page model, so it bypasses the save method and does not
+        """
+
+        # Check if the children are in adding state
+        for child in children:
+            if not child._state.adding:
+                raise ValueError(
+                    "Attempted to add a tree node that is \
+                    already in the database.\
+                    bulk_add_children can only be used to add new pages, not to update existing pages"
+                )
+        # Get the list of existing children to check for duplicate slugs
+        existing_pages = self.get_children()
+
+        try:
+            self._check_unique(children, existing_pages)
+        except ValidationError as e:
+            raise e
+
+        # Process the child nodes
+        self._process_child_nodes(children)
+
+        # Load the pages into the database
+        pages = Page.objects.bulk_create(children)
+
+        return pages
+
     @property
     def revisions(self):
         # Always use the specific page instance when querying for revisions as
@@ -3456,7 +3614,8 @@
 
     def user_can_access_editor(self, obj, user):
         """Returns True if a user who would not normally be able to access the editor for the object should be able to if the object is currently on this task.
-        Note that returning False does not remove permissions from users who would otherwise have them."""
+        Note that returning False does not remove permissions from users who would otherwise have them.
+        """
         return False
 
     def locked_for_user(self, obj, user):
@@ -3468,12 +3627,14 @@
 
     def user_can_lock(self, obj, user):
         """Returns True if a user who would not normally be able to lock the object should be able to if the object is currently on this task.
-        Note that returning False does not remove permissions from users who would otherwise have them."""
+        Note that returning False does not remove permissions from users who would otherwise have them.
+        """
         return False
 
     def user_can_unlock(self, obj, user):
         """Returns True if a user who would not normally be able to unlock the object should be able to if the object is currently on this task.
-        Note that returning False does not remove permissions from users who would otherwise have them."""
+        Note that returning False does not remove permissions from users who would otherwise have them.
+        """
         return False
 
     def get_actions(self, obj, user):
@@ -4288,7 +4449,8 @@
     @transaction.atomic
     def cancel(self, user=None, resume=False, comment=""):
         """Cancel the task state and update the workflow state. If ``resume`` is set to True, then upon update the workflow state
-        is passed the current task as ``next_task``, causing it to start a new task state on the current task if possible"""
+        is passed the current task as ``next_task``, causing it to start a new task state on the current task if possible
+        """
         self.status = self.STATUS_CANCELLED
         self.finished_at = timezone.now()
         self.comment = comment
@@ -4305,7 +4467,8 @@
 
     def copy(self, update_attrs=None, exclude_fields=None):
         """Copy this task state, excluding the attributes in the ``exclude_fields`` list and updating any attributes to values
-        specified in the ``update_attrs`` dictionary of ``attribute``: ``new value`` pairs"""
+        specified in the ``update_attrs`` dictionary of ``attribute``: ``new value`` pairs
+        """
         exclude_fields = (
             self.default_exclude_fields_in_copy
             + self.exclude_fields_in_copy