nautobot 2.3.9__py3-none-any.whl → 2.3.11__py3-none-any.whl

nautobot/core/testing/views.py

@@ -873,6 +873,8 @@ class ViewTestCases:
                 response_body,
             )
 
+            return response
+
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_list_objects_with_constrained_permission(self):
             instance1, instance2 = self._get_queryset().all()[:2]
@@ -1112,13 +1114,10 @@ class ViewTestCases:
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_bulk_edit_form_contains_all_pks(self):
-            # We are testing the intermediary step of bulk_edit with pagination applied.
+            # We are testing the intermediary step of all bulk_edit.
             # i.e. "_all" passed in the form.
             pk_list = self._get_queryset().values_list("pk", flat=True)
-            # We only pass in one pk to test the functionality of "_all"
-            # which should grab all instance pks regardless of "pk"
             selected_data = {
-                "pk": pk_list[:1],
                 "_all": "on",
             }
             # Assign model-level permission
@@ -1133,13 +1132,19 @@ class ViewTestCases:
             # after pressing Edit Selected button.
             self.assertHttpStatus(response, 200)
             response_body = utils.extract_page_body(response.content.decode(response.charset))
+            # Assert the table which shows all the selected objects is not part of the html body in edit all case
+            self.assertNotIn('<table class="table table-hover table-headings">', response_body)
             # Check if all the pks are passed into the BulkEditForm/BulkUpdateForm
             for pk in pk_list:
-                self.assertIn(f'<input type="hidden" name="pk" value="{pk}"', response_body)
+                self.assertNotIn(str(pk), response_body)
+            self.assertInHTML(
+                '<input type="hidden" name="_all" value="True" class="form-control" required="required" placeholder="None" id="id__all">',
+                response_body,
+            )
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_bulk_edit_form_contains_all_filtered(self):
-            # We are testing the intermediary step of bulk_edit with pagination applied and additional filter.
+            # We are testing the intermediary step of bulk editing all filtered objects.
             # i.e. "_all" passed in the form and filter using query params.
             self.add_permissions(f"{self.model._meta.app_label}.change_{self.model._meta.model_name}")
 
@@ -1155,7 +1160,6 @@ class ViewTestCases:
 
             # Open bulk update form with first two objects
             selected_data = {
-                "pk": third_pk,  # This is ignored when filtering with "_all"
                 "_all": "on",
                 **post_data,
             }
@@ -1164,12 +1168,15 @@ class ViewTestCases:
             # Expect a 200 status cause we are only rendering the bulk edit table after pressing Edit Selected button.
             self.assertHttpStatus(response, 200)
             response_body = utils.extract_page_body(response.content.decode(response.charset))
-            # Check if the first and second pk is passed into the form.
-            self.assertIn(f'<input type="hidden" name="pk" value="{first_pk}"', response_body)
-            self.assertIn(f'<input type="hidden" name="pk" value="{second_pk}"', response_body)
+            # Check if all pks is not part of the html.
+            self.assertNotIn(str(first_pk), response_body)
+            self.assertNotIn(str(second_pk), response_body)
+            self.assertNotIn(str(third_pk), response_body)
             self.assertIn("Editing 2 ", response_body)
-            # Check if the third pk is not passed into the form.
-            self.assertNotIn(f'<input type="hidden" name="pk" value="{third_pk}"', response_body)
+            self.assertInHTML(
+                '<input type="hidden" name="_all" value="True" class="form-control" required="required" placeholder="None" id="id__all">',
+                response_body,
+            )
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_bulk_edit_objects_with_constrained_permission(self):
@@ -1271,14 +1278,10 @@ class ViewTestCases:
             self.assertEqual(self._get_queryset().count(), initial_count - len(pk_list))
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
-        def test_bulk_delete_form_contains_all_pks(self):
-            # We are testing the intermediary step of bulk_delete with pagination applied.
+        def test_bulk_delete_form_contains_all_objects(self):
+            # We are testing the intermediary step of bulk_delete all objects.
             # i.e. "_all" passed in the form.
-            pk_list = self._get_queryset().values_list("pk", flat=True)
-            # We only pass in one pk to test the functionality of "_all"
-            # which should grab all instance pks regardless of "pks".
             selected_data = {
-                "pk": pk_list[:1],
                 "confirm": True,
                 "_all": "on",
             }
@@ -1293,13 +1296,16 @@ class ViewTestCases:
             response = self.client.post(self._get_url("bulk_delete"), selected_data)
             self.assertHttpStatus(response, 200)
             response_body = utils.extract_page_body(response.content.decode(response.charset))
-            # Check if all the pks are passed into the BulkDeleteForm/BulkDestroyForm
-            for pk in pk_list:
-                self.assertIn(f'<input type="hidden" name="pk" value="{pk}"', response_body)
+            # Assert the table which shows all the selected objects is not part of the html body in delete all case
+            self.assertNotIn('<table class="table table-hover table-headings">', response_body)
+            # Assert none of the hidden input fields for each of the pks that would be deleted is part of the html body
+            for pk in self._get_queryset().values_list("pk", flat=True):
+                self.assertNotIn(str(pk), response_body)
+            self.assertInHTML('<input type="hidden" name="_all" value="true" />', response_body)
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
         def test_bulk_delete_form_contains_all_filtered(self):
-            # We are testing the intermediary step of bulk_delete with pagination applied and additional filter.
+            # We are testing the intermediary step of bulk_delete all with additional filter.
             # i.e. "_all" passed in the form and filter using query params.
             self.add_permissions(f"{self.model._meta.app_label}.delete_{self.model._meta.model_name}")
 
@@ -1321,12 +1327,12 @@ class ViewTestCases:
             # Expect a 200 status cause we are only rendering the bulk delete table after pressing Delete Selected button.
             self.assertHttpStatus(response, 200)
             response_body = utils.extract_page_body(response.content.decode(response.charset))
-            # Check if the first and second pk is passed into the form.
-            self.assertIn(f'<input type="hidden" name="pk" value="{first_pk}"', response_body)
-            self.assertIn(f'<input type="hidden" name="pk" value="{second_pk}"', response_body)
+            # Check if all pks is not part of the html.
+            self.assertNotIn(str(first_pk), response_body)
+            self.assertNotIn(str(second_pk), response_body)
+            self.assertNotIn(str(third_pk), response_body)
             self.assertIn("<strong>Warning:</strong> The following operation will delete 2 ", response_body)
-            # Check if the third pk is not passed into the form.
-            self.assertNotIn(f'<input type="hidden" name="pk" value="{third_pk}"', response_body)
+            self.assertInHTML('<input type="hidden" name="_all" value="true" />', response_body)
 
         @override_settings(EXEMPT_VIEW_PERMISSIONS=[])
         def test_bulk_delete_objects_with_constrained_permission(self):

nautobot/core/tests/integration/test_app_navbar.py

@@ -61,7 +61,7 @@ class AppNavBarTestCase(SeleniumTestCase):
         tab_xpath = "//*[@id='navbar']//span[normalize-space()='Example Menu']/.."
         tab = self.browser.find_by_xpath(tab_xpath)
         tab.click()
-        self.assertTrue(bool(tab["aria-expanded"]))
+        self.assertEqual(tab["aria-expanded"], "true")
 
         group = tab.find_by_xpath(f"{tab_xpath}/following-sibling::ul//li[normalize-space()='Example Group 1']")
 
@@ -82,7 +82,7 @@ class AppNavBarTestCase(SeleniumTestCase):
         tab_xpath = "//*[@id='navbar']//*[normalize-space()='Circuits']"
         tab = self.browser.find_by_xpath(tab_xpath)
         tab.click()
-        self.assertTrue(bool(tab["aria-expanded"]))
+        self.assertEqual(tab["aria-expanded"], "true")
 
         for group_name, items in self.navbar["Circuits"].items():
             group = tab.find_by_xpath(f"{tab_xpath}/following-sibling::ul//li[normalize-space()='{group_name}']")
@@ -114,7 +114,7 @@ class AppNavBarTestCase(SeleniumTestCase):
         tab_xpath = "//*[@id='navbar']//*[normalize-space()='Apps']"
         tab = self.browser.find_by_xpath(tab_xpath)
         tab.click()
-        self.assertTrue(bool(tab["aria-expanded"]))
+        self.assertEqual(tab["aria-expanded"], "true")
 
         for group_name, items in self.navbar["Apps"].items():
             group = tab.find_by_xpath(f"{tab_xpath}/following-sibling::ul//li[normalize-space()='{group_name}']")

nautobot/core/tests/integration/test_navbar.py

@@ -60,7 +60,7 @@ class NavBarTestCase(SeleniumTestCase):
             tab_xpath = f"//*[@id='navbar']//span[normalize-space()='{tab_name}']/.."
             tab = self.browser.find_by_xpath(tab_xpath)
             tab.click()
-            self.assertTrue(bool(tab["aria-expanded"]))
+            self.assertEqual(tab["aria-expanded"], "true")
 
             for group_name, items in groups.items():
                 # Append onto tab xpath with group name search

nautobot/core/tests/test_csv.py

@@ -267,6 +267,9 @@ class CSVParsingRelatedTestCase(TestCase):
         url = reverse("dcim:device_import")
         response = self.client.post(url, data)
         self.assertEqual(response.status_code, 200)
+        # uploading the CSV always returns a 200 code with a page with an error message on it
+        # ensure we don't have that error message
+        self.assertNotIn("FORM-ERROR", response.content.decode(response.charset))
         self.assertEqual(Device.objects.count(), 4)
 
         # Assert TestDevice3 got created with the right fields

nautobot/core/tests/test_models_query_functions.py

@@ -0,0 +1,108 @@
+from nautobot.core.models.query_functions import JSONRemove, JSONSet
+from nautobot.core.testing import TestCase
+from nautobot.dcim.models import Manufacturer
+
+
+class JSONFuncTests(TestCase):
+    """Test JSONSet and JSONRemove functionality."""
+
+    def test_json_set(self):
+        # Setting a key/value should efficiently work
+        with self.assertNumQueries(1):
+            Manufacturer.objects.all().update(_custom_field_data=JSONSet("_custom_field_data", "a", 1))
+        for mfr in Manufacturer.objects.all():
+            self.assertIn("a", mfr._custom_field_data)
+            self.assertEqual(1, mfr._custom_field_data["a"])
+
+        # Setting a different key/value shouldn't overwrite other keys
+        with self.assertNumQueries(1):
+            Manufacturer.objects.all().update(_custom_field_data=JSONSet("_custom_field_data", "b", "text"))
+        for mfr in Manufacturer.objects.all():
+            self.assertIn("a", mfr._custom_field_data)
+            self.assertEqual(1, mfr._custom_field_data["a"])
+            self.assertIn("b", mfr._custom_field_data)
+            self.assertEqual("text", mfr._custom_field_data["b"])
+
+        # Setting a key/value again should overwrite that value only
+        with self.assertNumQueries(1):
+            Manufacturer.objects.all().update(_custom_field_data=JSONSet("_custom_field_data", "b", "more text"))
+        for mfr in Manufacturer.objects.all():
+            self.assertIn("a", mfr._custom_field_data)
+            self.assertEqual(1, mfr._custom_field_data["a"])
+            self.assertIn("b", mfr._custom_field_data)
+            self.assertEqual("more text", mfr._custom_field_data["b"])
+
+        # A filtered query should be updatable
+        with self.assertNumQueries(1):
+            Manufacturer.objects.filter(name__istartswith="a").update(
+                _custom_field_data=JSONSet("_custom_field_data", "a", None)
+            )
+        for mfr in Manufacturer.objects.filter(name__istartswith="a"):
+            self.assertIn("a", mfr._custom_field_data)
+            self.assertEqual(None, mfr._custom_field_data["a"])
+        for mfr in Manufacturer.objects.exclude(name__istartswith="a"):
+            self.assertIn("a", mfr._custom_field_data)
+            self.assertEqual(1, mfr._custom_field_data["a"])
+        for mfr in Manufacturer.objects.all():
+            self.assertIn("b", mfr._custom_field_data)
+            self.assertEqual("more text", mfr._custom_field_data["b"])
+
+        # Setting a value doesn't require all existing values to be homogeneous
+        with self.assertNumQueries(1):
+            Manufacturer.objects.all().update(_custom_field_data=JSONSet("_custom_field_data", "a", "hello"))
+        for mfr in Manufacturer.objects.all():
+            self.assertIn("a", mfr._custom_field_data)
+            self.assertEqual("hello", mfr._custom_field_data["a"])
+            self.assertIn("b", mfr._custom_field_data)
+            self.assertEqual("more text", mfr._custom_field_data["b"])
+
+    def test_json_remove(self):
+        Manufacturer.objects.all().update(_custom_field_data=JSONSet("_custom_field_data", "a", 1))
+        Manufacturer.objects.filter(name__istartswith="a").update(
+            _custom_field_data=JSONSet("_custom_field_data", "b", "hello")
+        )
+        Manufacturer.objects.exclude(name__istartswith="a").update(
+            _custom_field_data=JSONSet("_custom_field_data", "b", "world")
+        )
+
+        # Should be able to clear all values for a key without impacting other keys
+        with self.assertNumQueries(1):
+            Manufacturer.objects.all().update(_custom_field_data=JSONRemove("_custom_field_data", "a"))
+        for mfr in Manufacturer.objects.all():
+            self.assertNotIn("a", mfr._custom_field_data)
+            self.assertIn("b", mfr._custom_field_data)
+        for mfr in Manufacturer.objects.filter(name__istartswith="a"):
+            self.assertEqual("hello", mfr._custom_field_data["b"])
+        for mfr in Manufacturer.objects.exclude(name__istartswith="a"):
+            self.assertEqual("world", mfr._custom_field_data["b"])
+
+        # Clearing a value that doesn't exist should be safe
+        with self.assertNumQueries(1):
+            Manufacturer.objects.all().update(_custom_field_data=JSONRemove("_custom_field_data", "a"))
+        for mfr in Manufacturer.objects.all():
+            self.assertNotIn("a", mfr._custom_field_data)
+            self.assertIn("b", mfr._custom_field_data)
+        for mfr in Manufacturer.objects.filter(name__istartswith="a"):
+            self.assertEqual("hello", mfr._custom_field_data["b"])
+        for mfr in Manufacturer.objects.exclude(name__istartswith="a"):
+            self.assertEqual("world", mfr._custom_field_data["b"])
+
+        # Subsets should be updateable
+        with self.assertNumQueries(1):
+            Manufacturer.objects.filter(name__istartswith="a").update(
+                _custom_field_data=JSONRemove("_custom_field_data", "b")
+            )
+        for mfr in Manufacturer.objects.all():
+            self.assertNotIn("a", mfr._custom_field_data)
+        for mfr in Manufacturer.objects.filter(name__istartswith="a"):
+            self.assertNotIn("b", mfr._custom_field_data)
+        for mfr in Manufacturer.objects.exclude(name__istartswith="a"):
+            self.assertIn("b", mfr._custom_field_data)
+            self.assertEqual("world", mfr._custom_field_data["b"])
+
+        # Non-homogeneous data should be updatable
+        with self.assertNumQueries(1):
+            Manufacturer.objects.all().update(_custom_field_data=JSONRemove("_custom_field_data", "b"))
+        for mfr in Manufacturer.objects.all():
+            self.assertNotIn("a", mfr._custom_field_data)
+            self.assertNotIn("b", mfr._custom_field_data)

nautobot/core/tests/test_utils.py

@@ -21,6 +21,7 @@ from nautobot.extras import models as extras_models, utils as extras_utils
 from nautobot.extras.choices import ObjectChangeActionChoices, RelationshipTypeChoices
 from nautobot.extras.models import ObjectChange
 from nautobot.extras.registry import registry
+from nautobot.ipam import models as ipam_models
 
 from example_app.models import ExampleModel
 
@@ -164,7 +165,7 @@ class GetFooForModelTest(TestCase):
 
     def test_get_filterset_for_model(self):
         """
-        Test the util function `get_filterset_for_model` returns the appropriate FilterSet, if model (as dotted string or class) provided.
+        Test that `get_filterset_for_model` returns the right FilterSet for various inputs.
         """
         self.assertEqual(lookup.get_filterset_for_model("dcim.device"), dcim_filters.DeviceFilterSet)
         self.assertEqual(lookup.get_filterset_for_model(dcim_models.Device), dcim_filters.DeviceFilterSet)
@@ -173,7 +174,7 @@ class GetFooForModelTest(TestCase):
 
     def test_get_form_for_model(self):
         """
-        Test the util function `get_form_for_model` returns the appropriate Form, if form type and model (as dotted string or class) provided.
+        Test that `get_form_for_model` returns the right Form for various inputs.
         """
         self.assertEqual(lookup.get_form_for_model("dcim.device", "Filter"), dcim_forms.DeviceFilterForm)
         self.assertEqual(lookup.get_form_for_model(dcim_models.Device, "Filter"), dcim_forms.DeviceFilterForm)
@@ -184,9 +185,28 @@ class GetFooForModelTest(TestCase):
         self.assertEqual(lookup.get_form_for_model("dcim.location"), dcim_forms.LocationForm)
         self.assertEqual(lookup.get_form_for_model(dcim_models.Location), dcim_forms.LocationForm)
 
+    def test_get_related_field_for_models(self):
+        """
+        Test that `get_related_field_for_models` returns the appropriate field for various inputs.
+        """
+        # No direct relation found
+        self.assertIsNone(lookup.get_related_field_for_models(dcim_models.Device, dcim_models.LocationType))
+        # ForeignKey and reverse
+        self.assertEqual(lookup.get_related_field_for_models(dcim_models.Device, dcim_models.Location).name, "location")
+        self.assertEqual(lookup.get_related_field_for_models(dcim_models.Location, dcim_models.Device).name, "devices")
+        # ManyToMany and reverse
+        self.assertEqual(
+            lookup.get_related_field_for_models(ipam_models.Prefix, dcim_models.Location).name, "locations"
+        )
+        self.assertEqual(lookup.get_related_field_for_models(dcim_models.Location, ipam_models.Prefix).name, "prefixes")
+        # Multiple candidate fields
+        with self.assertRaises(AttributeError):
+            # both primary_ip4 and primary_ip6 are candidates
+            lookup.get_related_field_for_models(dcim_models.Device, ipam_models.IPAddress)
+
     def test_get_route_for_model(self):
         """
-        Test the util function `get_route_for_model` returns the appropriate URL route name, if model (as dotted string or class) provided.
+        Test that `get_route_for_model` returns the appropriate URL route name for various inputs.
         """
         # UI
         self.assertEqual(lookup.get_route_for_model("dcim.device", "list"), "dcim:device_list")
@@ -221,7 +241,7 @@ class GetFooForModelTest(TestCase):
 
     def test_get_table_for_model(self):
         """
-        Test the util function `get_table_for_model` returns the appropriate Table, if model (as dotted string or class) provided.
+        Test that `get_table_for_model` returns the appropriate Table for various inputs.
         """
         self.assertEqual(lookup.get_table_for_model("dcim.device"), tables.DeviceTable)
         self.assertEqual(lookup.get_table_for_model(dcim_models.Device), tables.DeviceTable)
@@ -237,7 +257,7 @@ class GetFooForModelTest(TestCase):
 
     def test_get_model_for_view_name(self):
         """
-        Test the util function `get_model_for_view_name` returns the appropriate Model, if the colon separated view name provided.
+        Test that `get_model_for_view_name` returns the appropriate Model, if the colon separated view name provided.
         """
         with self.subTest("Test core view."):
             self.assertEqual(lookup.get_model_for_view_name("dcim:device_list"), dcim_models.Device)

nautobot/core/utils/lookup.py

@@ -177,6 +177,41 @@ def get_form_for_model(model, form_prefix=""):
     return get_related_class_for_model(model, module_name="forms", object_suffix=object_suffix)
 
 
+def get_related_field_for_models(from_model, to_model):
+    """
+    Find the field on `from_model` that is a relation to `to_model`.
+
+    If no such field is found, returns None.
+    If more than one such field is found, raises an AttributeError.
+
+    Args:
+        from_model (BaseModel): The model class that should contain the relevant field or relation.
+        to_model (BaseModel): The model class that we're looking for as the destination.
+
+    Examples:
+        >>> get_related_field_for_models(Device, Location)
+        <django.db.models.fields.related.ForeignKey: location>
+        >>> get_related_field_for_models(Location, Device)
+        <ManyToOneRel: dcim.device>
+        >>> get_related_field_for_models(Prefix, Location)
+        <django.db.models.fields.related.ManyToManyField: locations>
+        >>> get_related_field_for_models(Location, Prefix)
+        <ManyToManyRel: ipam.prefix>
+        >>> get_related_field_for_models(Device, IPAddress)
+        AttributeError: Device has more than one relation to IPAddress: primary_ip4, primary_ip6
+    """
+    matching_field = None
+    for field in from_model._meta.get_fields():
+        if hasattr(field, "remote_field") and field.remote_field and field.remote_field.model == to_model:
+            if matching_field is not None:
+                raise AttributeError(
+                    f"{from_model.__name__} has more than one relation to {to_model.__name__}: "
+                    f"{matching_field.name}, {field.name}"
+                )
+            matching_field = field
+    return matching_field
+
+
 def get_table_for_model(model):
     """Return the `Table` class associated with a given `model`.
 

nautobot/core/views/generic.py

@@ -46,7 +46,7 @@ from nautobot.core.utils.requests import (
     get_filterable_params_from_filter_params,
     normalize_querydict,
 )
-from nautobot.core.views.mixins import GetReturnURLMixin, ObjectPermissionRequiredMixin
+from nautobot.core.views.mixins import EditAndDeleteAllModelMixin, GetReturnURLMixin, ObjectPermissionRequiredMixin
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
 from nautobot.core.views.utils import (
     check_filter_for_display,
@@ -979,7 +979,7 @@ class BulkImportView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):  #
         )
 
 
-class BulkEditView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
+class BulkEditView(GetReturnURLMixin, ObjectPermissionRequiredMixin, EditAndDeleteAllModelMixin, View):
     """
     Edit objects in bulk.
 
@@ -1013,18 +1013,18 @@ class BulkEditView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
     def post(self, request, **kwargs):
         logger = logging.getLogger(__name__ + ".BulkEditView")
         model = self.queryset.model
+        edit_all = request.POST.get("_all")
 
         # If we are editing *all* objects in the queryset, replace the PK list with all matched objects.
-        if request.POST.get("_all"):
-            if self.filterset is not None:
-                pk_list = list(self.filterset(request.GET, model.objects.only("pk")).qs.values_list("pk", flat=True))
-            else:
-                pk_list = list(model.objects.all().values_list("pk", flat=True))
+        if edit_all:
+            pk_list = []
+            queryset = self._get_bulk_edit_delete_all_queryset(request)
         else:
             pk_list = request.POST.getlist("pk")
+            queryset = self.queryset.filter(pk__in=pk_list)
 
         if "_apply" in request.POST:
-            form = self.form(model, request.POST)
+            form = self.form(model, request.POST, edit_all=edit_all)
             restrict_form_fields(form, request.user)
 
             if form.is_valid():
@@ -1041,7 +1041,8 @@ class BulkEditView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
                 try:
                     with deferred_change_logging_for_bulk_operation():
                         updated_objects = []
-                        for obj in self.queryset.filter(pk__in=form.cleaned_data["pk"]):
+                        queryset = queryset if edit_all else queryset.filter(pk__in=form.cleaned_data["pk"])
+                        for obj in queryset:
                             obj = self.alter_obj(obj, request, [], kwargs)
 
                             # Update standard fields. If a field is listed in _nullify, delete its value.
@@ -1130,23 +1131,26 @@ class BulkEditView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
             elif "device_type" in request.GET:
                 initial_data["device_type"] = request.GET.get("device_type")
 
-            form = self.form(model, initial=initial_data)
+            form = self.form(model, initial=initial_data, edit_all=edit_all)
             restrict_form_fields(form, request.user)
 
         # Retrieve objects being edited
-        table = self.table(self.queryset.filter(pk__in=pk_list), orderable=False)
-        if not table.rows:
-            messages.warning(request, f"No {model._meta.verbose_name_plural} were selected.")
-            return redirect(self.get_return_url(request))
-        # Hide actions column if present
-        if "actions" in table.columns:
-            table.columns.hide("actions")
+        table = None
+        if not edit_all:
+            table = self.table(queryset, orderable=False)
+            if not table.rows:
+                messages.warning(request, f"No {model._meta.verbose_name_plural} were selected.")
+                return redirect(self.get_return_url(request))
+            # Hide actions column if present
+            if "actions" in table.columns:
+                table.columns.hide("actions")
 
         context = {
             "form": form,
             "table": table,
             "obj_type_plural": model._meta.verbose_name_plural,
             "return_url": self.get_return_url(request),
+            "objs_count": queryset.count(),
         }
         context.update(self.extra_context())
         return render(request, self.template_name, context)
@@ -1255,7 +1259,7 @@ class BulkRenameView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
         return ""
 
 
-class BulkDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
+class BulkDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, EditAndDeleteAllModelMixin, View):
     """
     Delete objects in bulk.
 
@@ -1278,18 +1282,37 @@ class BulkDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
     def get(self, request):
         return redirect(self.get_return_url(request))
 
-    def post(self, request, **kwargs):
+    def _perform_delete_operation(self, request, queryset, model):
         logger = logging.getLogger(__name__ + ".BulkDeleteView")
+        self.perform_pre_delete(request, queryset)
+        try:
+            _, deleted_info = bulk_delete_with_bulk_change_logging(queryset)
+            deleted_count = deleted_info[model._meta.label]
+        except ProtectedError as e:
+            logger.info("Caught ProtectedError while attempting to delete objects")
+            handle_protectederror(queryset, request, e)
+            return redirect(self.get_return_url(request))
+        msg = f"Deleted {deleted_count} {model._meta.verbose_name_plural}"
+        logger.info(msg)
+        messages.success(request, msg)
+        return redirect(self.get_return_url(request))
+
+    def post(self, request, **kwargs):
+        logger = logging.getLogger(f"{__name__}.BulkDeleteView")
         model = self.queryset.model
 
         # Are we deleting *all* objects in the queryset or just a selected subset?
         if request.POST.get("_all"):
-            if self.filterset is not None:
-                pk_list = list(self.filterset(request.GET, model.objects.only("pk")).qs.values_list("pk", flat=True))
-            else:
-                pk_list = list(model.objects.all().values_list("pk", flat=True))
-        else:
-            pk_list = request.POST.getlist("pk")
+            queryset = self._get_bulk_edit_delete_all_queryset(request)
+
+            if "_confirm" in request.POST:
+                return self._perform_delete_operation(request, queryset, model)
+
+            context = self._bulk_delete_all_context(request, queryset)
+            context.update(self.extra_context())
+            return render(request, self.template_name, context)
+
+        pk_list = request.POST.getlist("pk")
 
         form_cls = self.get_form()
 
@@ -1300,20 +1323,7 @@ class BulkDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
 
                 # Delete objects
                 queryset = self.queryset.filter(pk__in=pk_list)
-
-                self.perform_pre_delete(request, queryset)
-                try:
-                    _, deleted_info = bulk_delete_with_bulk_change_logging(queryset)
-                    deleted_count = deleted_info[model._meta.label]
-                except ProtectedError as e:
-                    logger.info("Caught ProtectedError while attempting to delete objects")
-                    handle_protectederror(queryset, request, e)
-                    return redirect(self.get_return_url(request))
-                msg = f"Deleted {deleted_count} {model._meta.verbose_name_plural}"
-                logger.info(msg)
-                messages.success(request, msg)
-                return redirect(self.get_return_url(request))
-
+                return self._perform_delete_operation(request, queryset, model)
             else:
                 logger.debug("Form validation failed")
 
@@ -1342,6 +1352,7 @@ class BulkDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
             "obj_type_plural": model._meta.verbose_name_plural,
             "table": table,
             "return_url": self.get_return_url(request),
+            "total_objs_to_delete": len(table.rows),
         }
         context.update(self.extra_context())
         return render(request, self.template_name, context)