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

nautobot/core/views/generic.py

@@ -1,7 +1,6 @@
 from copy import deepcopy
 import logging
 import re
-from typing import ClassVar, Optional
 
 from django.conf import settings
 from django.contrib import messages
@@ -9,11 +8,12 @@ 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 Model, ProtectedError, Q, QuerySet
+from django.db.models import ManyToManyField, ProtectedError, Q
 from django.forms import Form, ModelMultipleChoiceField, MultipleHiddenInput
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404, redirect, render
@@ -22,8 +22,7 @@ from django.utils.encoding import iri_to_uri
 from django.utils.html import format_html
 from django.utils.http import url_has_allowed_host_and_scheme
 from django.views.generic import View
-from django_filters import FilterSet
-from django_tables2 import RequestConfig, Table
+from django_tables2 import RequestConfig
 
 from nautobot.core.api.utils import get_serializer_for_model
 from nautobot.core.constants import MAX_PAGE_SIZE_DEFAULT
@@ -48,7 +47,7 @@ from nautobot.core.utils.requests import (
     get_filterable_params_from_filter_params,
     normalize_querydict,
 )
-from nautobot.core.views.mixins import BulkEditAndBulkDeleteModelMixin, 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,
@@ -59,7 +58,9 @@ 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):
@@ -78,8 +79,8 @@ class ObjectView(ObjectPermissionRequiredMixin, View):
     template_name: Name of the template to use
     """
 
-    queryset: ClassVar[QuerySet]
-    template_name: ClassVar[Optional[str]] = None
+    queryset = None
+    template_name = None
     object_detail_content = None
 
     def get_required_permission(self):
@@ -141,10 +142,10 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
     non_filter_params: List of query parameters that are **not** used for queryset filtering
     """
 
-    queryset: QuerySet
-    filterset: Optional[type[FilterSet]] = None
-    filterset_form: Optional[type[Form]] = None
-    table: Optional[type[Table]] = None
+    queryset = None
+    filterset = None
+    filterset_form = None
+    table = None
     template_name = "generic/object_list.html"
     action_buttons = ("add", "import", "export")
     non_filter_params = (
@@ -161,11 +162,7 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
     def get_filter_params(self, request):
         """Helper function - take request.GET and discard any parameters that are not used for queryset filtering."""
         params = request.GET.copy()
-        filter_params = get_filterable_params_from_filter_params(
-            params,
-            self.non_filter_params,
-            self.filterset(),  # pylint: disable=not-callable  # this fn is only called if filterset is not None
-        )
+        filter_params = get_filterable_params_from_filter_params(params, self.non_filter_params, self.filterset())
         if params.get("saved_view") and not filter_params and not params.get("all_filters_removed"):
             return SavedView.objects.get(pk=params.get("saved_view")).config.get("filter_params", {})
         return filter_params
@@ -239,9 +236,9 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
             except ObjectDoesNotExist:
                 pass
 
-        if self.filterset is not None:
+        if self.filterset:
             filter_params = self.get_filter_params(request)
-            filterset = self.filterset(filter_params, self.queryset)  # pylint:disable=not-callable  # only if not None
+            filterset = self.filterset(filter_params, self.queryset)
             self.queryset = filterset.qs
             if not filterset.is_valid():
                 messages.error(
@@ -269,7 +266,7 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
             else:
                 dynamic_filter_form = DynamicFilterFormSet(filterset=filterset)
 
-            if self.filterset_form is not None:
+            if self.filterset_form:
                 filter_form = self.filterset_form(filter_params, label_suffix="")
 
         # Check for export template rendering
@@ -329,14 +326,14 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
                 messages.error(request, f"Saved view {current_saved_view_pk} not found")
 
         # Construct the objects table
-        if self.table is not None:
+        if self.table:
             if self.request.GET.getlist("sort") or (
                 current_saved_view is not None and current_saved_view.config.get("sort_order")
             ):
                 hide_hierarchy_ui = True  # hide tree hierarchy if custom sort is used
             table_changes_pending = self.request.GET.get("table_changes_pending", False)
 
-            table = self.table(  # pylint: disable=not-callable  # we confirmed that self.table is not None
+            table = self.table(
                 self.queryset,
                 table_changes_pending=table_changes_pending,
                 saved_view=current_saved_view,
@@ -413,8 +410,8 @@ class ObjectEditView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
     template_name: The name of the template
     """
 
-    queryset: QuerySet
-    model_form: type[Form]
+    queryset = None
+    model_form = None
     template_name = "generic/object_create.html"
 
     def get_required_permission(self):
@@ -556,7 +553,7 @@ class ObjectDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
     template_name: The name of the template
     """
 
-    queryset: QuerySet
+    queryset = None
     template_name = "generic/object_delete.html"
 
     def get_required_permission(self):
@@ -636,9 +633,9 @@ class BulkCreateView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
     template_name: The name of the template
     """
 
-    queryset: QuerySet
-    form: type[Form]
-    model_form: type[Form]
+    queryset = None
+    form = None
+    model_form = None
     pattern_target = ""
     template_name = None
 
@@ -745,8 +742,8 @@ class ObjectImportView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
     template_name: The name of the template
     """
 
-    queryset: QuerySet
-    model_form: type[Form]
+    queryset = None
+    model_form = None
     related_object_forms = {}
     template_name = "generic/object_import.html"
 
@@ -890,8 +887,8 @@ class BulkImportView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):  #
     template_name: The name of the template
     """
 
-    queryset: QuerySet
-    table: type[Table]
+    queryset = None
+    table = None
     template_name = "generic/object_bulk_import.html"
 
     def __init__(self, *args, **kwargs):
@@ -985,7 +982,7 @@ class BulkImportView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):  #
         )
 
 
-class BulkEditView(GetReturnURLMixin, ObjectPermissionRequiredMixin, BulkEditAndBulkDeleteModelMixin, View):
+class BulkEditView(GetReturnURLMixin, ObjectPermissionRequiredMixin, EditAndDeleteAllModelMixin, View):
     """
     Edit objects in bulk.
 
@@ -996,10 +993,10 @@ class BulkEditView(GetReturnURLMixin, ObjectPermissionRequiredMixin, BulkEditAnd
     template_name: The name of the template
     """
 
-    queryset: QuerySet
-    filterset: Optional[type[FilterSet]] = None
-    table: type[Table]
-    form: type[Form]
+    queryset = None
+    filterset = None
+    table = None
+    form = None
     template_name = "generic/object_bulk_edit.html"
 
     def get_required_permission(self):
@@ -1035,7 +1032,93 @@ class BulkEditView(GetReturnURLMixin, ObjectPermissionRequiredMixin, BulkEditAnd
 
             if form.is_valid():
                 logger.debug("Form validation was successful")
-                return self.send_bulk_edit_objects_to_job(request, form, model)
+                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)
+
             else:
                 logger.debug("Form validation failed")
 
@@ -1084,7 +1167,7 @@ class BulkRenameView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
     An extendable view for renaming objects in bulk.
     """
 
-    queryset: QuerySet
+    queryset = None
     template_name = "generic/object_bulk_rename.html"
 
     def __init__(self, *args, **kwargs):
@@ -1179,7 +1262,7 @@ class BulkRenameView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
         return ""
 
 
-class BulkDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, BulkEditAndBulkDeleteModelMixin, View):
+class BulkDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, EditAndDeleteAllModelMixin, View):
     """
     Delete objects in bulk.
 
@@ -1190,10 +1273,10 @@ class BulkDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, BulkEditA
     template_name: The name of the template
     """
 
-    queryset: QuerySet
-    filterset: Optional[type[FilterSet]] = None
-    table: type[Table]
-    form: Optional[type[Form]] = None
+    queryset = None
+    filterset = None
+    table = None
+    form = None
     template_name = "generic/object_bulk_delete.html"
 
     def get_required_permission(self):
@@ -1202,30 +1285,48 @@ class BulkDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, BulkEditA
     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 delete_all:
+        if request.POST.get("_all"):
             queryset = self._get_bulk_edit_delete_all_queryset(request)
-            pk_list = []
-        else:
-            pk_list = request.POST.getlist("pk")
-            queryset = self.queryset.filter(pk__in=pk_list)
+
+            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()
 
         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")
-                return self.send_bulk_delete_objects_to_job(request, pk_list, model, delete_all)
+
+                # Delete objects
+                queryset = self.queryset.filter(pk__in=pk_list)
+                return self._perform_delete_operation(request, queryset, model)
             else:
                 logger.debug("Form validation failed")
 
@@ -1238,26 +1339,23 @@ class BulkDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, BulkEditA
             )
 
         # Retrieve objects being deleted
-        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")
+        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")
 
         context = {
             "form": form,
             "obj_type_plural": model._meta.verbose_name_plural,
             "table": table,
             "return_url": self.get_return_url(request),
-            "total_objs_to_delete": queryset.count(),
-            "delete_all": delete_all,
+            "total_objs_to_delete": len(table.rows),
         }
         context.update(self.extra_context())
         return render(request, self.template_name, context)
@@ -1293,9 +1391,9 @@ class ComponentCreateView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View
     Add one or more components (e.g. interfaces, console ports, etc.) to a Device or VirtualMachine.
     """
 
-    queryset: QuerySet
-    form: type[Form]
-    model_form: type[Form]
+    queryset = None
+    form = None
+    model_form = None
     template_name = "dcim/device_component_add.html"
 
     def get_required_permission(self):
@@ -1395,13 +1493,13 @@ class BulkComponentCreateView(GetReturnURLMixin, ObjectPermissionRequiredMixin,
     Add one or more components (e.g. interfaces, console ports, etc.) to a set of Devices or VirtualMachines.
     """
 
-    parent_model: type[Model]
+    parent_model = None
     parent_field = None
-    form: type[Form]
-    queryset: QuerySet
-    model_form: type[Form]
-    filterset: Optional[type[FilterSet]] = None
-    table: type[Table]
+    form = None
+    queryset = None
+    model_form = None
+    filterset = None
+    table = None
     template_name = "generic/object_bulk_add_component.html"
 
     def get_required_permission(self):
@@ -1415,7 +1513,7 @@ class BulkComponentCreateView(GetReturnURLMixin, ObjectPermissionRequiredMixin,
 
         # Are we editing *all* objects in the queryset or just a selected subset?
         if request.POST.get("_all") and self.filterset is not None:
-            pk_list = [obj.pk for obj in self.filterset(request.GET, self.parent_model.objects.only("pk")).qs]  # pylint: disable=not-callable
+            pk_list = [obj.pk for obj in self.filterset(request.GET, self.parent_model.objects.only("pk")).qs]
         else:
             pk_list = request.POST.getlist("pk")