nautobot 2.3.16__py3-none-any.whl → 2.4.0__py3-none-any.whl

nautobot/core/ui/utils.py

@@ -0,0 +1,36 @@
+from django.template import Context
+from django.template.loader import get_template
+
+
+def flatten_context(context) -> dict:
+    """
+    If the given context is already a dict, return it unmodified; if it is a Context, flatten it to a dict.
+
+    This is working around a bug (not sure if in Django or in our code) where, if a `Context`'s `dicts` contain
+    a `RequestContext`, calling `Context.flatten()` throws an exception.
+    """
+    if isinstance(context, dict):
+        return context
+    flat = {}
+    for d in context.dicts:
+        if isinstance(d, dict):
+            flat.update(d)
+        else:
+            flat.update(flatten_context(d))
+    return flat
+
+
+def render_component_template(template_path: str, context: Context, **kwargs) -> str:
+    """
+    Render the template located at the given path with the given context, possibly augmented via additional kwargs.
+
+    Args:
+        template_path (str): Path to the template to render, for example `"components/tab/label_wrapper.html"`.
+        context (Context): Rendering context for the template
+        **kwargs (dict): Additional key/value pairs to extend the context with for this specific template.
+
+    Examples:
+        >>> render_component_template(self.label_wrapper_template_path, context, tab_id=self.tab_id, label="Hello")
+    """
+    with context.update(kwargs):
+        return get_template(template_path).render(flatten_context(context))

nautobot/core/urls.py

@@ -5,11 +5,13 @@ from django.views.generic import TemplateView
 from django.views.static import serve
 
 from nautobot.core.views import (
+    AboutView,
     CustomGraphQLView,
     get_file_with_authorization,
     HomeView,
     NautobotMetricsView,
     NautobotMetricsViewAuth,
+    RenderJinjaView,
     SearchView,
     StaticMediaFailureView,
     ThemePreviewView,
@@ -27,6 +29,7 @@ from .admin import admin_site
 urlpatterns = [
     # Base views
     path("", HomeView.as_view(), name="home"),
+    path("about/", AboutView.as_view(), name="about"),
     path("search/", SearchView.as_view(), name="search"),
     # Login/logout
     path("login/", LoginView.as_view(), name="login"),
@@ -42,6 +45,7 @@ urlpatterns = [
     path("user/", include("nautobot.users.urls")),
     path("users/", include("nautobot.users.urls", "users")),
     path("virtualization/", include("nautobot.virtualization.urls")),
+    path("wireless/", include("nautobot.wireless.urls")),
     # API
     path("api/", include("nautobot.core.api.urls")),
     # GraphQL
@@ -69,6 +73,8 @@ urlpatterns = [
     ),
     # Celery worker status page
     path("worker-status/", WorkerStatusView.as_view(), name="worker_status"),
+    # Jinja template renderer tool
+    path("render-jinja-template/", RenderJinjaView.as_view(), name="render_jinja_template"),
     # Templated css file
     path(
         "template.css", TemplateView.as_view(template_name="template.css", content_type="text/css"), name="template_css"

nautobot/core/utils/config.py

@@ -1,12 +1,39 @@
 """Helper code for loading values that may be defined in settings.py/nautobot_config.py *or* in django-constance."""
 
+import contextlib
+import logging
+
 from constance import config
 from django.conf import settings
+from django.core.exceptions import ObjectDoesNotExist
+from django.db import OperationalError, ProgrammingError
+
+logger = logging.getLogger(__name__)
+
 
+def get_settings_or_config(variable_name, fallback=None):
+    """
+    Get a value from Django settings (if specified there) or Constance configuration (otherwise).
 
-def get_settings_or_config(variable_name):
-    """Get a value from Django settings (if specified there) or Constance configuration (otherwise)."""
+    The fallback value is returned *only* if the requested variable cannot be found at all - this is an error case,
+    and will generate warning logs.
+    """
     # Explicitly set in settings.py or nautobot_config.py takes precedence, for now
     if hasattr(settings, variable_name):
         return getattr(settings, variable_name)
-    return getattr(config, variable_name)
+    # django-constance 4.x removed some built-in error handling here, so we have to do it ourselves now
+    with contextlib.suppress(ObjectDoesNotExist, OperationalError, ProgrammingError):
+        return getattr(config, variable_name)
+    logger.warning(
+        'Configuration "%s" is not in settings, and could not read from the Constance database table '
+        "(perhaps not initialized yet?)",
+        variable_name,
+    )
+    if variable_name in settings.CONSTANCE_CONFIG:
+        default = settings.CONSTANCE_CONFIG[variable_name][0]
+        logger.warning('Using default value of "%s" from Constance configuration for "%s"', default, variable_name)
+        return default
+    logger.warning(
+        'Constance configuration does not include an entry for "%s" - must return %s', variable_name, fallback
+    )
+    return fallback

nautobot/core/utils/lookup.py

@@ -10,6 +10,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.db.models import Model
 from django.urls import get_resolver, resolve, reverse, URLPattern, URLResolver
 from django.utils.module_loading import import_string
+from django.views.generic.base import RedirectView
 
 
 def get_changes_for_model(model):
@@ -315,7 +316,7 @@ def get_created_and_last_updated_usernames_for_model(instance):
     return created_by, last_updated_by
 
 
-def get_url_patterns(urlconf=None, patterns_list=None, base_path="/"):
+def get_url_patterns(urlconf=None, patterns_list=None, base_path="/", ignore_redirects=False):
     """
     Recursively yield a list of registered URL patterns.
 
@@ -326,6 +327,7 @@ def get_url_patterns(urlconf=None, patterns_list=None, base_path="/"):
             Default if unspecified is the `url_patterns` attribute of the given `urlconf` module.
         base_path (str): String to prepend to all URL patterns yielded.
             Default if unspecified is the string `"/"`.
+        ignore_redirects (bool): If True, skip URL patterns that correspond to RedirectViews.
 
     Yields:
         (str): Each URL pattern defined in the given urlconf and its descendants
@@ -384,10 +386,18 @@ def get_url_patterns(urlconf=None, patterns_list=None, base_path="/"):
 
     for item in patterns_list:
         if isinstance(item, URLPattern):
+            if (
+                ignore_redirects
+                and hasattr(item.callback, "view_class")
+                and issubclass(item.callback.view_class, RedirectView)
+            ):
+                continue
             yield base_path + str(item.pattern)
         elif isinstance(item, URLResolver):
             # Recurse!
-            yield from get_url_patterns(urlconf, item.url_patterns, base_path + str(item.pattern))
+            yield from get_url_patterns(
+                urlconf, item.url_patterns, base_path + str(item.pattern), ignore_redirects=ignore_redirects
+            )
 
 
 def get_url_for_url_pattern(url_pattern):

nautobot/core/utils/querysets.py

@@ -0,0 +1,64 @@
+import logging
+
+from django.db import NotSupportedError
+
+logger = logging.getLogger(__name__)
+
+
+def maybe_select_related(queryset, select_fields):
+    """Attempt to perform a select_related() on the given queryset, but fail gracefully if not permitted."""
+    model = queryset.model
+
+    # Django doesn't allow .select_related() on a QuerySet that had .values()/.values_list() applied, or
+    # one that has had union()/intersection()/difference() applied.
+    # We can detect and avoid these cases the same way that Django itself does.
+    if queryset._fields is not None:
+        logger.debug(
+            "NOT applying select_related(%s) to %s QuerySet as it includes .values()/.values_list()",
+            select_fields,
+            model.__name__,
+        )
+    elif queryset.query.combinator:
+        logger.debug(
+            "NOT applying select_related(%s) to %s QuerySet as it is a combinator query",
+            select_fields,
+            model.__name__,
+        )
+    else:
+        logger.debug("Applying .select_related(%s) to %s QuerySet", select_fields, model.__name__)
+        # Belt and suspenders - we should have avoided any error cases above, but be safe anyway:
+        try:
+            queryset = queryset.select_related(*select_fields)
+        except (TypeError, ValueError, NotSupportedError) as exc:
+            logger.warning(
+                "Unexpected error when trying to .select_related() on %s QuerySet: %s",
+                model.__name__,
+                exc,
+            )
+
+    return queryset
+
+
+def maybe_prefetch_related(queryset, prefetch_fields):
+    """Attempt to perform a select_related() on the given queryset, but fail gracefully if not permitted."""
+    model = queryset.model
+
+    if queryset.query.combinator:
+        logger.debug(
+            "NOT applying prefetch_related(%s) to %s QuerySet as it is a combinator query",
+            prefetch_fields,
+            model.__name__,
+        )
+    else:
+        logger.debug("Applying .prefetch_related(%s) to %s QuerySet", prefetch_fields, model.__name__)
+        # Belt and suspenders - we should have avoided any error cases above, but be safe anyway:
+        try:
+            queryset = queryset.prefetch_related(*prefetch_fields)
+        except (AttributeError, TypeError, ValueError, NotSupportedError) as exc:
+            logger.warning(
+                "Unexpected error when trying to .prefetch_related() on %s QuerySet: %s",
+                model.__name__,
+                exc,
+            )
+
+    return queryset

nautobot/core/utils/requests.py

@@ -141,22 +141,35 @@ def get_filterable_params_from_filter_params(filter_params, non_filter_params, f
     return final_filter_params
 
 
-def normalize_querydict(querydict, form_class=None):
+def normalize_querydict(querydict, form_class=None, filterset=None):
     """
-    Convert a QueryDict to a normal, mutable dictionary, preserving list values. For example,
+    Converts a QueryDict into a standard, mutable dictionary while preserving multiple values as lists.
 
-        QueryDict('foo=1&bar=2&bar=3&baz=')
+    Example:
+        A QueryDict like:
+            QueryDict('foo=1&bar=2&bar=3&baz=')
 
-    becomes:
+        Converts to:
+            {'foo': '1', 'bar': ['2', '3'], 'baz': ''}
 
-        {'foo': '1', 'bar': ['2', '3'], 'baz': ''}
+    This function ensures that fields with multiple values are handled correctly, as QueryDict
+    does not inherently preserve multiple values as lists.
 
-    This function is necessary because QueryDict does not provide any built-in mechanism which preserves multiple
-    values.
-
-    A `form_class` can be provided as a way to hint which query parameters should be treated as lists.
+    Args:
+        querydict (QueryDict): The QueryDict to be normalized.
+        form_class (forms.Form, optional): A form class to identify fields that should be treated as
+            lists (e.g., `MultipleChoiceField` or `ModelMultipleChoiceField`).
+        filterset (django_filters.FilterSet, optional): A FilterSet instance to identify filters that
+            should preserve multiple values as lists (e.g., non-single-choice fields).
+
+    Raises:
+        AttributeError: If both `form_class` and `filterset` are provided.
     """
+    if form_class and filterset:
+        raise AttributeError("Either form_class or filterset_class is to be provided not both")
+
     result = {}
+
     if querydict:
         for key, value_list in querydict.lists():
             if len(value_list) > 1:
@@ -171,6 +184,8 @@ def normalize_querydict(querydict, form_class=None):
             ):
                 # Even though there's only a single value in the querydict for this key, the form wants it as a list
                 result[key] = value_list
+            elif filterset is not None and filterset.filters.get(key) and not is_single_choice_field(filterset, key):
+                result[key] = value_list
             else:
                 # Only a single value in the querydict for this key, and no guidance otherwise, so make it single
                 result[key] = value_list[0]

nautobot/core/views/__init__.py

@@ -1,4 +1,5 @@
 import contextlib
+import datetime
 import logging
 import os
 import platform
@@ -45,6 +46,7 @@ from nautobot.core.celery import app
 from nautobot.core.constants import SEARCH_MAX_RESULTS
 from nautobot.core.forms import SearchForm
 from nautobot.core.releases import get_latest_release
+from nautobot.core.utils.config import get_settings_or_config
 from nautobot.core.utils.lookup import get_route_for_model
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.extras.forms import GraphQLQueryForm
@@ -56,7 +58,6 @@ logger = logging.getLogger(__name__)
 
 class HomeView(AccessMixin, TemplateView):
     template_name = "home.html"
-    use_new_ui = True
 
     def render_additional_content(self, request, context, details):
         # Collect all custom data using callback functions.
@@ -479,3 +480,49 @@ def get_file_with_authorization(request, *args, **kwargs):
     get_object_or_404(queryset, file=request.GET.get("name"))
 
     return get_file(request, *args, **kwargs)
+
+
+class AboutView(AccessMixin, TemplateView):
+    """
+    Nautobot About View which displays general information about Nautobot and contact details
+    for Network to Code.
+    """
+
+    template_name = "about.html"
+
+    def get(self, request, *args, **kwargs):
+        # Redirect user to login page if not authenticated
+        if not request.user.is_authenticated:
+            return self.handle_no_permission()
+        # Check whether a new release is available. (Only for staff/superusers.)
+        new_release = None
+        if request.user.is_staff or request.user.is_superuser:
+            latest_release, release_url = get_latest_release()
+            if isinstance(latest_release, version.Version):
+                current_version = version.parse(settings.VERSION)
+                if latest_release > current_version:
+                    new_release = {
+                        "version": str(latest_release),
+                        "url": release_url,
+                    }
+
+        # Support contract state
+        support_expiration_date = get_settings_or_config("NTC_SUPPORT_CONTRACT_EXPIRATION_DATE")
+        support_contract_active = support_expiration_date and support_expiration_date >= datetime.date.today()
+
+        context = self.get_context_data()
+        context.update(
+            {
+                "new_release": new_release,
+                "support_contract_active": support_contract_active,
+                "support_expiration_date": support_expiration_date,
+            }
+        )
+
+        return self.render_to_response(context)
+
+
+class RenderJinjaView(LoginRequiredMixin, TemplateView):
+    """Render a Jinja template with context data."""
+
+    template_name = "utilities/render_jinja2.html"

nautobot/core/views/generic.py

@@ -1,9 +1,7 @@
-from __future__ import annotations  # python 3.8
-
 from copy import deepcopy
 import logging
 import re
-from typing import Optional
+from typing import ClassVar, Optional
 
 from django.conf import settings
 from django.contrib import messages
@@ -11,12 +9,11 @@ from django.contrib.auth.mixins import LoginRequiredMixin
 from django.contrib.auth.models import AnonymousUser
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import (
-    FieldDoesNotExist,
     ObjectDoesNotExist,
     ValidationError,
 )
 from django.db import IntegrityError, transaction
-from django.db.models import ManyToManyField, Model, ProtectedError, Q, QuerySet
+from django.db.models import Model, ProtectedError, Q, QuerySet
 from django.forms import Form, ModelMultipleChoiceField, MultipleHiddenInput
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404, redirect, render
@@ -29,6 +26,7 @@ from django_filters import FilterSet
 from django_tables2 import RequestConfig, Table
 
 from nautobot.core.api.utils import get_serializer_for_model
+from nautobot.core.constants import MAX_PAGE_SIZE_DEFAULT
 from nautobot.core.exceptions import AbortTransaction
 from nautobot.core.forms import (
     BootstrapMixin,
@@ -50,7 +48,7 @@ from nautobot.core.utils.requests import (
     get_filterable_params_from_filter_params,
     normalize_querydict,
 )
-from nautobot.core.views.mixins import EditAndDeleteAllModelMixin, GetReturnURLMixin, ObjectPermissionRequiredMixin
+from nautobot.core.views.mixins import BulkEditAndBulkDeleteModelMixin, GetReturnURLMixin, ObjectPermissionRequiredMixin
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
 from nautobot.core.views.utils import (
     check_filter_for_display,
@@ -61,9 +59,7 @@ from nautobot.core.views.utils import (
     prepare_cloned_fields,
     view_changes_not_saved,
 )
-from nautobot.extras.context_managers import deferred_change_logging_for_bulk_operation
 from nautobot.extras.models import ExportTemplate, SavedView, UserSavedViewAssociation
-from nautobot.extras.utils import bulk_delete_with_bulk_change_logging, remove_prefix_from_cf_key
 
 
 class GenericView(LoginRequiredMixin, View):
@@ -82,8 +78,9 @@ class ObjectView(ObjectPermissionRequiredMixin, View):
     template_name: Name of the template to use
     """
 
-    queryset: QuerySet
-    template_name: Optional[str] = None
+    queryset: ClassVar[QuerySet]
+    template_name: ClassVar[Optional[str]] = None
+    object_detail_content = None
 
     def get_required_permission(self):
         return get_permission_for_model(self.queryset.model, "view")
@@ -123,6 +120,7 @@ class ObjectView(ObjectPermissionRequiredMixin, View):
             "content_type": content_type,
             "verbose_name": self.queryset.model._meta.verbose_name,
             "verbose_name_plural": self.queryset.model._meta.verbose_name_plural,
+            "object_detail_content": self.object_detail_content,
             **common_detail_view_context(request, instance),
             **self.get_extra_context(request, instance),
         }
@@ -355,7 +353,7 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
             }
             RequestConfig(request, paginate).configure(table)
             table_config_form = TableConfigForm(table=table)
-            max_page_size = get_settings_or_config("MAX_PAGE_SIZE")
+            max_page_size = get_settings_or_config("MAX_PAGE_SIZE", fallback=MAX_PAGE_SIZE_DEFAULT)
             if max_page_size and paginate["per_page"] > max_page_size:
                 messages.warning(
                     request,
@@ -987,7 +985,7 @@ class BulkImportView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):  #
         )
 
 
-class BulkEditView(GetReturnURLMixin, ObjectPermissionRequiredMixin, EditAndDeleteAllModelMixin, View):
+class BulkEditView(GetReturnURLMixin, ObjectPermissionRequiredMixin, BulkEditAndBulkDeleteModelMixin, View):
     """
     Edit objects in bulk.
 
@@ -1037,93 +1035,7 @@ class BulkEditView(GetReturnURLMixin, ObjectPermissionRequiredMixin, EditAndDele
 
             if form.is_valid():
                 logger.debug("Form validation was successful")
-                form_custom_fields = getattr(form, "custom_fields", [])
-                form_relationships = getattr(form, "relationships", [])
-                standard_fields = [
-                    field
-                    for field in form.fields
-                    if field not in form_custom_fields + form_relationships + ["pk"] + ["object_note"]
-                ]
-                nullified_fields = request.POST.getlist("_nullify")
-
-                try:
-                    with deferred_change_logging_for_bulk_operation():
-                        updated_objects = []
-                        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.
-                            for name in standard_fields:
-                                try:
-                                    model_field = model._meta.get_field(name)
-                                except FieldDoesNotExist:
-                                    # This form field is used to modify a field rather than set its value directly
-                                    model_field = None
-
-                                # Handle nullification
-                                if name in form.nullable_fields and name in nullified_fields:
-                                    if isinstance(model_field, ManyToManyField):
-                                        getattr(obj, name).set([])
-                                    else:
-                                        setattr(obj, name, None if model_field is not None and model_field.null else "")
-
-                                # ManyToManyFields
-                                elif isinstance(model_field, ManyToManyField):
-                                    if form.cleaned_data[name]:
-                                        getattr(obj, name).set(form.cleaned_data[name])
-                                # Normal fields
-                                elif form.cleaned_data[name] not in (None, ""):
-                                    setattr(obj, name, form.cleaned_data[name])
-
-                            # Update custom fields
-                            for field_name in form_custom_fields:
-                                if field_name in form.nullable_fields and field_name in nullified_fields:
-                                    obj.cf[remove_prefix_from_cf_key(field_name)] = None
-                                elif form.cleaned_data.get(field_name) not in (None, "", []):
-                                    obj.cf[remove_prefix_from_cf_key(field_name)] = form.cleaned_data[field_name]
-
-                            obj.full_clean()
-                            obj.save()
-                            updated_objects.append(obj)
-                            logger.debug(f"Saved {obj} (PK: {obj.pk})")
-
-                            # Add/remove tags
-                            if form.cleaned_data.get("add_tags", None):
-                                obj.tags.add(*form.cleaned_data["add_tags"])
-                            if form.cleaned_data.get("remove_tags", None):
-                                obj.tags.remove(*form.cleaned_data["remove_tags"])
-
-                            if hasattr(form, "save_relationships") and callable(form.save_relationships):
-                                # Add/remove relationship associations
-                                form.save_relationships(instance=obj, nullified_fields=nullified_fields)
-
-                            if hasattr(form, "save_note") and callable(form.save_note):
-                                form.save_note(instance=obj, user=request.user)
-
-                            self.extra_post_save_action(obj, form)
-
-                        # Enforce object-level permissions
-                        if self.queryset.filter(pk__in=[obj.pk for obj in updated_objects]).count() != len(
-                            updated_objects
-                        ):
-                            raise ObjectDoesNotExist
-
-                    if updated_objects:
-                        msg = f"Updated {len(updated_objects)} {model._meta.verbose_name_plural}"
-                        logger.info(msg)
-                        messages.success(self.request, msg)
-
-                    return redirect(self.get_return_url(request))
-
-                except ValidationError as e:
-                    messages.error(self.request, f"{obj} failed validation: {e}")
-
-                except ObjectDoesNotExist:
-                    msg = "Object update failed due to object-level permissions violation"
-                    logger.debug(msg)
-                    form.add_error(None, msg)
-
+                return self.send_bulk_edit_objects_to_job(request, form, model)
             else:
                 logger.debug("Form validation failed")
 
@@ -1267,7 +1179,7 @@ class BulkRenameView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
         return ""
 
 
-class BulkDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, EditAndDeleteAllModelMixin, View):
+class BulkDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, BulkEditAndBulkDeleteModelMixin, View):
     """
     Delete objects in bulk.
 
@@ -1290,48 +1202,30 @@ class BulkDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, EditAndDe
     def get(self, request):
         return redirect(self.get_return_url(request))
 
-    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
+        delete_all = request.POST.get("_all")
 
         # Are we deleting *all* objects in the queryset or just a selected subset?
-        if request.POST.get("_all"):
+        if delete_all:
             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")
+            pk_list = []
+        else:
+            pk_list = request.POST.getlist("pk")
+            queryset = self.queryset.filter(pk__in=pk_list)
 
         form_cls = self.get_form()
 
         if "_confirm" in request.POST:
             form = form_cls(request.POST)
+            # Set pk field requirement here instead of BulkDeleteForm since get_form() may return a different form class
+            if delete_all:
+                form.fields["pk"].required = False
+
             if form.is_valid():
                 logger.debug("Form validation was successful")
-
-                # Delete objects
-                queryset = self.queryset.filter(pk__in=pk_list)
-                return self._perform_delete_operation(request, queryset, model)
+                return self.send_bulk_delete_objects_to_job(request, pk_list, model, delete_all)
             else:
                 logger.debug("Form validation failed")
 
@@ -1344,23 +1238,26 @@ class BulkDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, EditAndDe
             )
 
         # Retrieve objects being deleted
-        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 for deletion.",
-            )
-            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 delete_all:
+            table = self.table(queryset, orderable=False)
+            if not table.rows:
+                messages.warning(
+                    request,
+                    f"No {model._meta.verbose_name_plural} were selected for deletion.",
+                )
+                return redirect(self.get_return_url(request))
+            # Hide actions column if present
+            if "actions" in table.columns:
+                table.columns.hide("actions")
 
         context = {
             "form": form,
             "obj_type_plural": model._meta.verbose_name_plural,
             "table": table,
             "return_url": self.get_return_url(request),
-            "total_objs_to_delete": len(table.rows),
+            "total_objs_to_delete": queryset.count(),
+            "delete_all": delete_all,
         }
         context.update(self.extra_context())
         return render(request, self.template_name, context)