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

nautobot/core/views/mixins.py

@@ -1,4 +1,5 @@
 import logging
+from typing import ClassVar, Optional
 
 from django.contrib import messages
 from django.contrib.auth.mixins import AccessMixin
@@ -22,6 +23,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.edit import FormView
+from django_filters import FilterSet
 from drf_spectacular.utils import extend_schema
 from rest_framework import exceptions, mixins
 from rest_framework.decorators import action as drf_action
@@ -29,6 +31,7 @@ from rest_framework.parsers import FormParser, MultiPartParser
 from rest_framework.response import Response
 from rest_framework.viewsets import GenericViewSet
 
+from nautobot.core import exceptions as core_exceptions
 from nautobot.core.api.views import BulkDestroyModelMixin, BulkUpdateModelMixin
 from nautobot.core.forms import (
     BootstrapMixin,
@@ -37,7 +40,8 @@ from nautobot.core.forms import (
     CSVFileField,
     restrict_form_fields,
 )
-from nautobot.core.utils import lookup, permissions
+from nautobot.core.jobs import BulkDeleteObjects, BulkEditObjects
+from nautobot.core.utils import filtering, lookup, permissions
 from nautobot.core.utils.requests import get_filterable_params_from_filter_params, normalize_querydict
 from nautobot.core.views.renderers import NautobotHTMLRenderer
 from nautobot.core.views.utils import (
@@ -48,7 +52,7 @@ from nautobot.core.views.utils import (
 )
 from nautobot.extras.context_managers import deferred_change_logging_for_bulk_operation
 from nautobot.extras.forms import NoteForm
-from nautobot.extras.models import ExportTemplate, SavedView, UserSavedViewAssociation
+from nautobot.extras.models import ExportTemplate, Job, JobResult, SavedView, UserSavedViewAssociation
 from nautobot.extras.tables import NoteTable, ObjectChangeTable
 from nautobot.extras.utils import bulk_delete_with_bulk_change_logging, get_base_template, remove_prefix_from_cf_key
 
@@ -223,7 +227,7 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
     # filterset and filter_params will be initialized in filter_queryset() in ObjectListViewMixin
     filter_params = None
     filterset = None
-    filterset_class = None
+    filterset_class: Optional[type[FilterSet]] = None
     filterset_form_class = None
     form_class = None
     create_form_class = None
@@ -473,7 +477,11 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
     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_class())
+        filter_params = get_filterable_params_from_filter_params(
+            params,
+            self.non_filter_params,
+            self.filterset_class(),  # pylint: disable=not-callable  # only called if filterset_class is not None
+        )
         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
@@ -579,11 +587,11 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
             if self.action == "bulk_destroy":
                 queryset = self.get_queryset()
                 bulk_delete_all = bool(self.request.POST.get("_all"))
-                if bulk_delete_all:
-                    return ConfirmationForm
 
                 class BulkDestroyForm(ConfirmationForm):
-                    pk = ModelMultipleChoiceField(queryset=queryset, widget=MultipleHiddenInput)
+                    pk = ModelMultipleChoiceField(
+                        queryset=queryset, widget=MultipleHiddenInput, required=not bulk_delete_all
+                    )
 
                 return BulkDestroyForm
             else:
@@ -629,8 +637,8 @@ class ObjectListViewMixin(NautobotViewSetMixin, mixins.ListModelMixin):
     """
 
     action_buttons = ("add", "import", "export")
-    filterset_class = None
-    filterset_form_class = None
+    filterset_class: Optional[type[FilterSet]] = None
+    filterset_form_class: Optional[type[Form]] = None
     hide_hierarchy_ui = False
     non_filter_params = (
         "export",  # trigger for CSV/export-template/YAML export # 3.0 TODO: remove, irrelevant after #4746
@@ -780,7 +788,8 @@ class ObjectDestroyViewMixin(NautobotViewSetMixin, mixins.DestroyModelMixin):
             return self.perform_destroy(request, **kwargs)
         return Response(context)
 
-    def perform_destroy(self, request, **kwargs):
+    # TODO: this conflicts with DRF's DestroyModelMixin.perform_destroy(self, instance) API
+    def perform_destroy(self, request, **kwargs):  # pylint:disable=arguments-renamed
         """
         Function to validate the ObjectDeleteConfirmationForm and to delete the object.
         """
@@ -912,11 +921,13 @@ class ObjectEditViewMixin(NautobotViewSetMixin, mixins.CreateModelMixin, mixins.
             return self.form_invalid(form)
 
 
-class EditAndDeleteAllModelMixin:
+class BulkEditAndBulkDeleteModelMixin:
     """
-    UI mixin to bulk destroy all and bulk edit all model instances.
+    UI mixin to bulk destroy and bulk edit all model instances.
     """
 
+    logger = logging.getLogger(__name__)
+
     def _get_bulk_edit_delete_all_queryset(self, request):
         """
         Retrieve the queryset of model instances to be bulk-deleted or bulk-deleted, filtered based on request parameters.
@@ -934,7 +945,7 @@ class EditAndDeleteAllModelMixin:
             filterset_class = getattr(self, "filterset_class", None)
 
         if request.GET and filterset_class is not None:
-            queryset = filterset_class(request.GET, model.objects.all()).qs
+            queryset = filterset_class(request.GET, model.objects.all()).qs  # pylint: disable=not-callable
             # We take this approach because filterset.qs has already applied .distinct(),
             # and performing a .delete directly on a queryset with .distinct applied is not allowed.
             queryset = self.queryset.filter(pk__in=queryset)
@@ -942,24 +953,91 @@ class EditAndDeleteAllModelMixin:
             queryset = model.objects.all()
         return queryset
 
-    def _bulk_delete_all_context(self, request, queryset):
-        model = queryset.model
-        return {
-            "obj_type_plural": model._meta.verbose_name_plural,
-            "return_url": self.get_return_url(request),
-            "total_objs_to_delete": queryset.count(),
-            "delete_all": True,
-            "table": None,
-        }
+    def send_bulk_delete_objects_to_job(self, request, pk_list, model, delete_all):
+        """Prepare and enqueue bulk delete job."""
+        job_model = Job.objects.get_for_class_path(BulkDeleteObjects.class_path)
+
+        if filterset_class := lookup.get_filterset_for_model(model):
+            filter_query_params = normalize_querydict(request.GET, filterset=filterset_class())
+        else:
+            filter_query_params = {}
+
+        # Discarding non-filter query params
+        new_filter_query_params = {}
+
+        for key, value in filter_query_params.items():
+            try:
+                filtering.get_filterset_field(filterset_class(), key)
+                new_filter_query_params[key] = value
+            except core_exceptions.FilterSetFieldNotFound:
+                self.logger.debug(f"Query parameter `{key}` not found in `{filterset_class}`, discarding it")
+
+        filter_query_params = new_filter_query_params
+
+        job_form = BulkDeleteObjects.as_form(
+            data={
+                "pk_list": pk_list,
+                "content_type": ContentType.objects.get_for_model(model),
+                "delete_all": delete_all,
+                "filter_query_params": filter_query_params,
+            }
+        )
+        # BulkDeleteObjects job form cannot be invalid; Hence no handling of invalid case.
+        job_form.is_valid()
+        job_kwargs = BulkDeleteObjects.prepare_job_kwargs(job_form.cleaned_data)
+        job_result = JobResult.enqueue_job(
+            job_model,
+            request.user,
+            **BulkDeleteObjects.serialize_data(job_kwargs),
+        )
+        return redirect("extras:jobresult", pk=job_result.pk)
+
+    def send_bulk_edit_objects_to_job(self, request, form_data, model):
+        """Prepare and enqueue a bulk edit job."""
+        job_model = Job.objects.get_for_class_path(BulkEditObjects.class_path)
+        if filterset_class := lookup.get_filterset_for_model(model):
+            filter_query_params = normalize_querydict(request.GET, filterset=filterset_class())
+        else:
+            filter_query_params = {}
+
+        # Discarding non-filter query params
+        new_filter_query_params = {}
+
+        for key, value in filter_query_params.items():
+            try:
+                filtering.get_filterset_field(filterset_class(), key)
+                new_filter_query_params[key] = value
+            except core_exceptions.FilterSetFieldNotFound:
+                self.logger.debug(f"Query parameter `{key}` not found in `{filterset_class}`, discarding it")
+
+        filter_query_params = new_filter_query_params
+
+        job_form = BulkEditObjects.as_form(
+            data={
+                "form_data": form_data,
+                "content_type": ContentType.objects.get_for_model(model),
+                "edit_all": request.POST.get("_all") is not None,
+                "filter_query_params": filter_query_params,
+            }
+        )
+        # NOTE: BulkEditObjects cant be invalid, so there is no need for handling invalid error
+        job_form.is_valid()
+        job_kwargs = BulkEditObjects.prepare_job_kwargs(job_form.cleaned_data)
+        job_result = JobResult.enqueue_job(
+            job_model,
+            request.user,
+            **BulkEditObjects.serialize_data(job_kwargs),
+        )
+        return redirect("extras:jobresult", pk=job_result.pk)
 
 
-class ObjectBulkDestroyViewMixin(NautobotViewSetMixin, BulkDestroyModelMixin, EditAndDeleteAllModelMixin):
+class ObjectBulkDestroyViewMixin(NautobotViewSetMixin, BulkDestroyModelMixin, BulkEditAndBulkDeleteModelMixin):
     """
     UI mixin to bulk destroy model instances.
     """
 
-    bulk_destroy_form_class = None
-    filterset_class = None
+    bulk_destroy_form_class: Optional[type[Form]] = None
+    filterset_class: Optional[type[FilterSet]] = None
 
     def _process_bulk_destroy_form(self, form):
         request = self.request
@@ -992,7 +1070,8 @@ class ObjectBulkDestroyViewMixin(NautobotViewSetMixin, BulkDestroyModelMixin, Ed
         """
         return self.perform_bulk_destroy(request, **kwargs)
 
-    def perform_bulk_destroy(self, request, **kwargs):
+    # TODO: this conflicts with BulkDestroyModelMixin.perform_bulk_destroy(self, objects)
+    def perform_bulk_destroy(self, request, **kwargs):  # pylint:disable=arguments-renamed
         """
         request.POST "_delete": Function to render the user selection of objects in a table form/BulkDestroyConfirmationForm via Response that is passed to NautobotHTMLRenderer.
         request.POST "_confirm": Function to validate the table form/BulkDestroyConfirmationForm and to perform the action of bulk destroy. Render the form with errors if exceptions are raised.
@@ -1002,21 +1081,23 @@ class ObjectBulkDestroyViewMixin(NautobotViewSetMixin, BulkDestroyModelMixin, Ed
         data = {}
         # Are we deleting *all* objects in the queryset or just a selected subset?
         if delete_all:
+            self.pk_list = []
             queryset = self._get_bulk_edit_delete_all_queryset(self.request)
-            data = self._bulk_delete_all_context(request, queryset)
         else:
             self.pk_list = list(request.POST.getlist("pk"))
+            queryset = queryset.filter(pk__in=self.pk_list)
 
-        form_class = self.get_form_class(**kwargs)
         if "_confirm" in request.POST:
+            form_class = self.get_form_class(**kwargs)
             form = form_class(request.POST, initial=normalize_querydict(request.GET, form_class=form_class))
             if form.is_valid():
-                return self.form_valid(form)
+                return self.send_bulk_delete_objects_to_job(request, self.pk_list, queryset.model, delete_all)
             else:
                 return self.form_invalid(form)
+        table = None
         if not delete_all:
             table_class = self.get_table_class()
-            table = table_class(queryset.filter(pk__in=self.pk_list), orderable=False)
+            table = table_class(queryset, orderable=False)
             if not table.rows:
                 messages.warning(
                     request,
@@ -1024,7 +1105,13 @@ class ObjectBulkDestroyViewMixin(NautobotViewSetMixin, BulkDestroyModelMixin, Ed
                 )
                 return redirect(self.get_return_url(request))
 
-            data.update({"table": table})
+        data.update(
+            {
+                "table": table,
+                "total_objs_to_delete": queryset.count(),
+                "delete_all": delete_all,
+            }
+        )
         return Response(data)
 
 
@@ -1082,14 +1169,14 @@ class ObjectBulkCreateViewMixin(NautobotViewSetMixin):  # 3.0 TODO: remove, unus
             return self.form_invalid(form)
 
 
-class ObjectBulkUpdateViewMixin(NautobotViewSetMixin, BulkUpdateModelMixin, EditAndDeleteAllModelMixin):
+class ObjectBulkUpdateViewMixin(NautobotViewSetMixin, BulkUpdateModelMixin, BulkEditAndBulkDeleteModelMixin):
     """
     UI mixin to bulk update model instances.
     """
 
-    filterset_class = None
-    bulk_update_form_class = None
+    filterset_class: ClassVar[Optional[type[FilterSet]]] = None
 
+    # NOTE: Performing BulkEdit Objects has been moved to a system job, but the logic remains here to ensure backward compatibility.
     def _process_bulk_update_form(self, form):
         request = self.request
         queryset = self.get_queryset()
@@ -1104,7 +1191,7 @@ class ObjectBulkUpdateViewMixin(NautobotViewSetMixin, BulkUpdateModelMixin, Edit
             for field in form.fields
             if field not in form_custom_fields + form_relationships + ["pk"] + ["object_note"]
         ]
-        nullified_fields = request.POST.getlist("_nullify")
+        nullified_fields = request.POST.getlist("_nullify") or []
         with deferred_change_logging_for_bulk_operation():
             updated_objects = []
             edit_all = self.request.POST.get("_all")
@@ -1123,7 +1210,7 @@ class ObjectBulkUpdateViewMixin(NautobotViewSetMixin, BulkUpdateModelMixin, Edit
                         # 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 name in form.nullable_fields and nullified_fields and name in nullified_fields:
                         if isinstance(model_field, ManyToManyField):
                             getattr(obj, name).set([])
                         else:
@@ -1137,7 +1224,7 @@ class ObjectBulkUpdateViewMixin(NautobotViewSetMixin, BulkUpdateModelMixin, Edit
                         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:
+                    if field_name in form.nullable_fields and nullified_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]
@@ -1200,7 +1287,7 @@ class ObjectBulkUpdateViewMixin(NautobotViewSetMixin, BulkUpdateModelMixin, Edit
             form = form_class(queryset.model, request.POST, edit_all=edit_all)
             restrict_form_fields(form, request.user)
             if form.is_valid():
-                return self.form_valid(form)
+                return self.send_bulk_edit_objects_to_job(self.request, form.cleaned_data, queryset.model)
             else:
                 return self.form_invalid(form)
         table = None
@@ -1224,10 +1311,14 @@ class ObjectBulkUpdateViewMixin(NautobotViewSetMixin, BulkUpdateModelMixin, Edit
 
 class ObjectChangeLogViewMixin(NautobotViewSetMixin):
     """
-    UI mixin to list a model's changelog queryset
+    UI mixin to list a model's changelog queryset.
+
+    base_template: Specify to explicitly identify the base object detail template to render.
+        If not provided, "<app>/<model>.html", "<app>/<model>_retrieve.html", or "generic/object_retrieve.html"
+        will be used, as per `get_base_template()`.
     """
 
-    base_template = None
+    base_template: Optional[str] = None
 
     @drf_action(detail=True)
     def changelog(self, request, *args, **kwargs):
@@ -1242,9 +1333,13 @@ class ObjectChangeLogViewMixin(NautobotViewSetMixin):
 class ObjectNotesViewMixin(NautobotViewSetMixin):
     """
     UI Mixin for an Object's Notes.
+
+    base_template: Specify to explicitly identify the base object detail template to render.
+        If not provided, "<app>/<model>.html", "<app>/<model>_retrieve.html", or "generic/object_retrieve.html"
+        will be used, as per `get_base_template()`.
     """
 
-    base_template = None
+    base_template: Optional[str] = None
 
     @drf_action(detail=True)
     def notes(self, request, *args, **kwargs):

nautobot/core/views/renderers.py

@@ -244,12 +244,11 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
                 restrict_form_fields(form, request.user)
             elif view.action == "bulk_destroy":
                 pk_list = getattr(view, "pk_list", [])
-                if pk_list:
-                    initial = {
-                        "pk": pk_list,
-                        "return_url": return_url,
-                    }
-                    form = form_class(initial=initial)
+                initial = {
+                    "pk": pk_list,
+                    "return_url": return_url,
+                }
+                form = form_class(initial=initial)
                 delete_all = request.POST.get("_all")
                 if not delete_all:
                     table = self.construct_table(view, pk_list=pk_list)
@@ -347,6 +346,7 @@ class NautobotHTMLRenderer(renderers.BrowsableAPIRenderer):
         # Ensure the proper inheritance of context variables is applied: the view's returned data takes priority over the viewset's get_extra_context
         context.update(view.get_extra_context(request, instance))
         context.update(self.get_template_context(data, renderer_context))
+
         return context
 
     def render(self, data, accepted_media_type=None, renderer_context=None):

nautobot/core/views/utils.py

@@ -137,10 +137,10 @@ def get_csv_form_fields_from_serializer_class(serializer_class):
                 elif cf.type == CustomFieldTypeChoices.TYPE_DATE:
                     field_info["format"] = mark_safe("<code>YYYY-MM-DD</code>")  # noqa: S308
                 elif cf.type == CustomFieldTypeChoices.TYPE_SELECT:
-                    field_info["choices"] = {cfc.value: cfc.value for cfc in cf.custom_field_choices.all()}
+                    field_info["choices"] = {value: value for value in cf.choices}
                 elif cf.type == CustomFieldTypeChoices.TYPE_MULTISELECT:
                     field_info["format"] = mark_safe('<code>"value,value"</code>')  # noqa: S308
-                    field_info["choices"] = {cfc.value: cfc.value for cfc in cf.custom_field_choices.all()}
+                    field_info["choices"] = {value: value for value in cf.choices}
                 fields.append(field_info)
             continue