nautobot 2.0.0a2__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/core/views/generic.py

@@ -1,4 +1,5 @@
 from copy import deepcopy
+from io import BytesIO
 import logging
 import re
 
@@ -12,16 +13,18 @@ from django.core.exceptions import (
 )
 from django.db import transaction, IntegrityError
 from django.db.models import ManyToManyField, ProtectedError
-from django.forms import Form, ModelMultipleChoiceField, MultipleHiddenInput, Textarea
-from django.http import HttpResponse
+from django.forms import Form, ModelMultipleChoiceField, MultipleHiddenInput
+from django.http import HttpResponse, JsonResponse
 from django.shortcuts import get_object_or_404, redirect, render
-from django.urls import NoReverseMatch, reverse
 from django.utils.html import escape
 from django.utils.http import is_safe_url
 from django.utils.safestring import mark_safe
 from django.views.generic import View
 from django_tables2 import RequestConfig
+from rest_framework.exceptions import ParseError
 
+from nautobot.core.api.parsers import NautobotCSVParser
+from nautobot.core.api.utils import get_serializer_for_model
 from nautobot.core.forms import SearchForm
 from nautobot.core.exceptions import AbortTransaction
 from nautobot.core.forms import (
@@ -36,7 +39,6 @@ from nautobot.core.forms import (
 )
 from nautobot.core.forms.forms import DynamicFilterFormSet
 from nautobot.core.templatetags.helpers import bettertitle, validated_viewname
-from nautobot.core.utils.lookup import get_route_for_model
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.core.utils.requests import (
     convert_querydict_to_factory_formset_acceptable_querydict,
@@ -45,9 +47,13 @@ from nautobot.core.utils.requests import (
 )
 from nautobot.core.views.paginator import EnhancedPaginator, get_paginate_count
 from nautobot.core.views.mixins import GetReturnURLMixin, ObjectPermissionRequiredMixin
-from nautobot.core.views.utils import check_filter_for_display, csv_format, handle_protectederror, prepare_cloned_fields
-from nautobot.extras.models import CustomField, ExportTemplate
-from nautobot.extras.models.change_logging import ChangeLoggedModel
+from nautobot.core.views.utils import (
+    check_filter_for_display,
+    get_csv_form_fields_from_serializer_class,
+    handle_protectederror,
+    prepare_cloned_fields,
+)
+from nautobot.extras.models import ExportTemplate
 from nautobot.extras.utils import remove_prefix_from_cf_key
 
 
@@ -61,6 +67,7 @@ class ObjectView(ObjectPermissionRequiredMixin, View):
 
     queryset = None
     template_name = None
+    use_new_ui = True
 
     def get_required_permission(self):
         return get_permission_for_model(self.queryset.model, "view")
@@ -89,55 +96,41 @@ class ObjectView(ObjectPermissionRequiredMixin, View):
             "active_tab": request.GET.get("tab", "main"),
         }
 
-    # 2.0 TODO: Remove this method in 2.0. Can be retrieved from instance itself now
-    # instance.get_changelog_url()
-    # Only available on models that support changelogs
-    def get_changelog_url(self, instance):
-        """Return the changelog URL for a given instance."""
-        meta = self.queryset.model._meta
-
-        # Don't try to generate a changelog_url for an ObjectChange.
-        if meta.model_name == "objectchange":
-            return None
-
-        route = get_route_for_model(instance, "changelog")
-
-        # Iterate the pk-like fields and try to get a URL, or return None.
-        fields = ["pk", "slug"]
-        for field in fields:
-            if not hasattr(instance, field):
-                continue
-
-            try:
-                return reverse(route, kwargs={field: getattr(instance, field)})
-            except NoReverseMatch:
-                continue
-
-        # This object likely doesn't have a changelog route defined.
-        return None
-
     def get(self, request, *args, **kwargs):
         """
         Generic GET handler for accessing an object by PK or slug
         """
         instance = get_object_or_404(self.queryset, **kwargs)
 
-        changelog_url = None
-
-        if isinstance(instance, ChangeLoggedModel):
-            changelog_url = instance.get_changelog_url()
+        # TODO: this feels inelegant - should the tabs lookup be a dedicated endpoint rather than piggybacking
+        # on the object-retrieve endpoint?
+        # TODO: similar functionality probably needed in NautobotUIViewSet as well, not currently present
+        if request.GET.get("viewconfig", None) == "true":
+            # TODO: we shouldn't be importing a private-named function from another module. Should it be renamed?
+            from nautobot.extras.templatetags.plugins import _get_registered_content
 
-        return render(
-            request,
-            self.get_template_name(),
-            {
+            temp_fake_context = {
                 "object": instance,
-                "verbose_name": self.queryset.model._meta.verbose_name,
-                "verbose_name_plural": self.queryset.model._meta.verbose_name_plural,
-                "changelog_url": changelog_url,  # 2.0 TODO: Remove in 2.0. This information can be retrieved from the object itself now.
-                **self.get_extra_context(request, instance),
-            },
-        )
+                "request": request,
+                "settings": {},
+                "csrf_token": "",
+                "perms": {},
+            }
+
+            plugin_tabs = _get_registered_content(instance, "detail_tabs", temp_fake_context, return_html=False)
+            resp = {"tabs": plugin_tabs}
+            return JsonResponse(resp)
+        else:
+            return render(
+                request,
+                self.get_template_name(),
+                {
+                    "object": instance,
+                    "verbose_name": self.queryset.model._meta.verbose_name,
+                    "verbose_name_plural": self.queryset.model._meta.verbose_name_plural,
+                    **self.get_extra_context(request, instance),
+                },
+            )
 
 
 class ObjectListView(ObjectPermissionRequiredMixin, View):
@@ -165,15 +158,17 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
         "per_page",  # used by get_paginate_count
         "sort",  # table sorting
     )
+    use_new_ui = True
 
     def get_filter_params(self, request):
         """Helper function - take request.GET and discard any parameters that are not used for queryset filtering."""
         filter_params = request.GET.copy()
-        return get_filterable_params_from_filter_params(filter_params, self.non_filter_params, self.filterset)
+        return get_filterable_params_from_filter_params(filter_params, self.non_filter_params, self.filterset())
 
     def get_required_permission(self):
         return get_permission_for_model(self.queryset.model, "view")
 
+    # TODO: remove this as well?
     def queryset_to_yaml(self):
         """
         Export the queryset of objects as concatenated YAML documents.
@@ -182,35 +177,6 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
 
         return "---\n".join(yaml_data)
 
-    def queryset_to_csv(self):
-        """
-        Export the queryset of objects as comma-separated value (CSV), using the model's to_csv() method.
-        """
-        csv_data = []
-        custom_field_keys = []
-
-        # Start with the column headers
-        headers = self.queryset.model.csv_headers.copy()
-
-        # Add custom field headers, if any
-        if hasattr(self.queryset.model, "_custom_field_data"):
-            for custom_field in CustomField.objects.get_for_model(self.queryset.model):
-                headers.append(custom_field.add_prefix_to_cf_key())
-                custom_field_keys.append(custom_field.key)
-
-        csv_data.append(",".join(headers))
-
-        # Iterate through the queryset appending each object
-        for obj in self.queryset:
-            data = obj.to_csv()
-
-            for custom_field_key in custom_field_keys:
-                data += (obj.cf.get(custom_field_key, ""),)
-
-            csv_data.append(csv_format(data))
-
-        return "\n".join(csv_data)
-
     def validate_action_buttons(self, request):
         """Verify actions in self.action_buttons are valid view actions."""
 
@@ -240,7 +206,6 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
         if self.filterset:
             filter_params = self.get_filter_params(request)
             filterset = self.filterset(filter_params, self.queryset)
-            filterset_filters = filterset.get_filters()
             self.queryset = filterset.qs
             if not filterset.is_valid():
                 messages.error(
@@ -250,17 +215,17 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
                 self.queryset = self.queryset.none()
 
             display_filter_params = [
-                check_filter_for_display(filterset_filters, field_name, values)
+                check_filter_for_display(filterset.filters, field_name, values)
                 for field_name, values in filter_params.items()
             ]
 
             if request.GET:
                 factory_formset_params = convert_querydict_to_factory_formset_acceptable_querydict(
-                    request.GET, self.filterset
+                    request.GET, filterset
                 )
-                dynamic_filter_form = DynamicFilterFormSet(filterset_class=self.filterset, data=factory_formset_params)
+                dynamic_filter_form = DynamicFilterFormSet(filterset=filterset, data=factory_formset_params)
             else:
-                dynamic_filter_form = DynamicFilterFormSet(filterset_class=self.filterset)
+                dynamic_filter_form = DynamicFilterFormSet(filterset=filterset)
 
             if self.filterset_form:
                 filter_form = self.filterset_form(filter_params, label_suffix="")
@@ -287,13 +252,6 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
             response["Content-Disposition"] = f'attachment; filename="{filename}"'
             return response
 
-        # Fall back to built-in CSV formatting if export requested but no template specified
-        elif "export" in request.GET and hasattr(model, "to_csv"):
-            response = HttpResponse(self.queryset_to_csv(), content_type="text/csv")
-            filename = f"{settings.BRANDING_PREPENDED_FILENAME}{self.queryset.model._meta.verbose_name_plural}.csv"
-            response["Content-Disposition"] = f'attachment; filename="{filename}"'
-            return response
-
         # Provide a hook to tweak the queryset based on the request immediately prior to rendering the object list
         self.queryset = self.alter_queryset(request)
 
@@ -468,10 +426,58 @@ class ObjectEditView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
                 else:
                     return redirect(self.get_return_url(request, obj))
 
-            except ObjectDoesNotExist:
-                msg = "Object save failed due to object-level permissions violation"
-                logger.debug(msg)
+            # TODO(jathan): This is a temporary workaround for legacy generic views in support of
+            # PrefixEditView/PrefixForm where `unique_together` constraint raises an IntegrityError
+            # because `network` & `prefix_length` are excluded from the form and are therefore not
+            # passed to `full_clean()`. This results in `form.is_valid()` always returning `True`,
+            # and any exceptions end up getting bubbled up when `form.save()` is called. Therefore
+            # the error(s) have to be handled here.
+            #
+            # The problem is that the error from `IntegrityError` is hideous, and looks like this:
+            #
+            # IntegrityError: duplicate key value violates unique constraint "ipam_prefix_namespace_id_network_prefix_length_b2dd8b57_uniq"
+            # DETAIL:  Key (namespace_id, network, prefix_length)=(e0b0aa8d-d24d-4312-a2e5-f185c41281e6, \x0a000000, 8) already exists.
+            #
+            # So, there is a `pre_save` signal handler to forcibly call `Prefix.full_clean` without
+            # field exclusions which results in a `ValidationError` that looks pretty, like so:
+            #
+            # ValidationError: {'__all__': ['Prefix with this Namespace, Network and Prefix length already exists.']}
+            #
+            # No extra work shall be spent on this as the form validation is being replaced with
+            # JSON schema forms in the v2 UI and all of this should go away because validation will
+            # be performed by serializers instead. When `serializer.is_valid()` is called, it
+            # actually returns `False` and properly shows the errors:
+            #
+            # >>> serializer.is_valid()
+            # False
+            #
+            # >>> serializer.errors
+            # {'__all__': [ErrorDetail(string='Prefix with this Namespace, Network and Prefix length already exists.', code='unique_together')]}
+            except ValidationError as err:
+                logger.exception(err)
+                for field, errors in err.message_dict.items():
+                    if field == "__all__":
+                        field = None
+                    for error in errors:
+                        form.add_error(field, error)
+            # This is necessary due to the uniqueness constraint from the database for `ipam.Prefix`
+            # bubbling up. Just a quick fix for the time being without debugging too hard, to know
+            # that this at least surfaces the (ugly) error in the UI.
+            except IntegrityError as err:
+                logger.exception(err)
+                models = ", ".join(o.replace("_", " ").title() for o in obj._meta.unique_together[0])
+                model_name = obj._meta.verbose_name.title()
+                msg = f"{model_name} with this {models} already exists."
                 form.add_error(None, msg)
+            except ObjectDoesNotExist as err:
+                if self.queryset.model._meta.model_name == "ipaddress":
+                    msg = str(err) + "! Does it exist?"
+                    field = "address"
+                else:
+                    msg = "Object save failed due to object-level permissions violation"
+                    field = None
+                logger.debug(msg)
+                form.add_error(field, msg)
 
         else:
             logger.debug("Form validation failed")
@@ -824,31 +830,31 @@ class BulkImportView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
     Import objects in bulk (CSV format).
 
     queryset: Base queryset for the model
-    model_form: The form used to create each imported object
     table: The django-tables2 Table used to render the list of imported objects
     template_name: The name of the template
-    widget_attrs: A dict of attributes to apply to the import widget (e.g. to require a session key)
     """
 
     queryset = None
-    model_form = None
     table = None
     template_name = "generic/object_bulk_import.html"
-    widget_attrs = {}
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.serializer_class = get_serializer_for_model(self.queryset.model)
+        self.fields = get_csv_form_fields_from_serializer_class(self.serializer_class)
+        self.required_field_names = [
+            field["name"]
+            for field in get_csv_form_fields_from_serializer_class(self.serializer_class)
+            if field["required"]
+        ]
 
     def _import_form(self, *args, **kwargs):
         class CSVImportForm(BootstrapMixin, Form):
-            csv_data = CSVDataField(from_form=self.model_form, widget=Textarea(attrs=self.widget_attrs))
-            csv_file = CSVFileField(from_form=self.model_form)
+            csv_data = CSVDataField(required_field_names=self.required_field_names)
+            csv_file = CSVFileField()
 
         return CSVImportForm(*args, **kwargs)
 
-    def _save_obj(self, obj_form, request):
-        """
-        Provide a hook to modify the object immediately before saving it (e.g. to encrypt secret data).
-        """
-        return obj_form.save()
-
     def get_required_permission(self):
         return get_permission_for_model(self.queryset.model, "add")
 
@@ -858,8 +864,8 @@ class BulkImportView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
             self.template_name,
             {
                 "form": self._import_form(),
-                "fields": self.model_form().fields,
-                "obj_type": self.model_form._meta.model._meta.verbose_name,
+                "fields": self.fields,
+                "obj_type": self.queryset.model._meta.verbose_name,
                 "return_url": self.get_return_url(request),
                 "active_tab": "csv-data",
             },
@@ -880,18 +886,24 @@ class BulkImportView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
                         field_name = "csv_file"
                     else:
                         field_name = "csv_data"
-                    headers, records = form.cleaned_data[field_name]
-                    for row, data in enumerate(records, start=1):
-                        obj_form = self.model_form(data, headers=headers)
-                        restrict_form_fields(obj_form, request.user)
-
-                        if obj_form.is_valid():
-                            obj = self._save_obj(obj_form, request)
-                            new_objs.append(obj)
+                    csvtext = form.cleaned_data[field_name]
+
+                    try:
+                        data = NautobotCSVParser().parse(
+                            stream=BytesIO(csvtext.encode("utf-8")),
+                            parser_context={"request": request, "serializer_class": self.serializer_class},
+                        )
+                        serializer = self.serializer_class(data=data, context={"request": request}, many=True)
+                        if serializer.is_valid():
+                            new_objs = serializer.save()
                         else:
-                            for field, err in obj_form.errors.items():
-                                form.add_error(field_name, f"Row {row} {field}: {err[0]}")
+                            for row, errors in enumerate(serializer.errors, start=1):
+                                for field, err in errors.items():
+                                    form.add_error(field_name, f"Row {row}: {field}: {err[0]}")
                             raise ValidationError("")
+                    except ParseError as exc:
+                        form.add_error(None, str(exc))
+                        raise ValidationError("")
 
                     # Enforce object-level permissions
                     if self.queryset.filter(pk__in=[obj.pk for obj in new_objs]).count() != len(new_objs):
@@ -930,8 +942,8 @@ class BulkImportView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
             self.template_name,
             {
                 "form": form,
-                "fields": self.model_form().fields,
-                "obj_type": self.model_form._meta.model._meta.verbose_name,
+                "fields": self.fields,
+                "obj_type": self.queryset.model._meta.verbose_name,
                 "return_url": self.get_return_url(request),
                 "active_tab": "csv-file" if form.has_error("csv_file") else "csv-data",
             },

nautobot/core/views/mixins.py

@@ -1,3 +1,4 @@
+from io import BytesIO
 import logging
 
 from django.contrib import messages
@@ -11,7 +12,7 @@ from django.core.exceptions import (
 )
 from django.db import transaction
 from django.db.models import ManyToManyField, ProtectedError
-from django.forms import Form, ModelMultipleChoiceField, MultipleHiddenInput, Textarea
+from django.forms import Form, ModelMultipleChoiceField, MultipleHiddenInput
 from django.http import HttpResponse
 from django.shortcuts import get_object_or_404, redirect
 from django.template.loader import select_template, TemplateDoesNotExist
@@ -29,7 +30,8 @@ from rest_framework.viewsets import GenericViewSet
 
 from drf_spectacular.utils import extend_schema
 
-from nautobot.core.api.views import BulkCreateModelMixin, BulkDestroyModelMixin, BulkUpdateModelMixin
+from nautobot.core.api.parsers import NautobotCSVParser
+from nautobot.core.api.views import BulkDestroyModelMixin, BulkUpdateModelMixin
 from nautobot.core.forms import (
     BootstrapMixin,
     ConfirmationForm,
@@ -40,8 +42,12 @@ from nautobot.core.forms import (
 from nautobot.core.utils import lookup, permissions
 from nautobot.core.views.renderers import NautobotHTMLRenderer
 from nautobot.core.utils.requests import get_filterable_params_from_filter_params
-from nautobot.core.views.utils import csv_format, handle_protectederror, prepare_cloned_fields
-from nautobot.extras.models import CustomField, ExportTemplate
+from nautobot.core.views.utils import (
+    get_csv_form_fields_from_serializer_class,
+    handle_protectederror,
+    prepare_cloned_fields,
+)
+from nautobot.extras.models import ExportTemplate
 from nautobot.extras.forms import NoteForm
 from nautobot.extras.tables import ObjectChangeTable, NoteTable
 from nautobot.extras.utils import remove_prefix_from_cf_key
@@ -179,8 +185,12 @@ class GetReturnURLMixin:
         # Note that the use of both `obj.present_in_database` and `obj.pk` is correct here because this conditional
         # handles all three of the create, update, and delete operations. When Django deletes an instance
         # from the DB, it sets the instance's PK field to None, regardless of the use of a UUID.
-        if obj is not None and obj.present_in_database and obj.pk and hasattr(obj, "get_absolute_url"):
-            return obj.get_absolute_url()
+        try:
+            if obj is not None and obj.present_in_database and obj.pk:
+                return obj.get_absolute_url()
+        except AttributeError:
+            # Model has no get_absolute_url() method or no reverse match
+            pass
 
         # Fall back to the default URL (if specified) for the view.
         if self.default_return_url is not None:
@@ -205,7 +215,6 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
 
     renderer_classes = [NautobotHTMLRenderer]
     logger = logging.getLogger(__name__)
-    lookup_field = "slug"
     # Attributes that need to be specified: form_class, queryset, serializer_class, table_class for most mixins.
     # filterset and filter_params will be initialized in filter_queryset() in ObjectListViewMixin
     filter_params = None
@@ -448,7 +457,7 @@ 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."""
         filter_params = request.GET.copy()
-        return get_filterable_params_from_filter_params(filter_params, self.non_filter_params, self.filterset_class)
+        return get_filterable_params_from_filter_params(filter_params, self.non_filter_params, self.filterset_class())
 
     def get_queryset(self):
         """
@@ -522,12 +531,15 @@ class NautobotViewSetMixin(GenericViewSet, AccessMixin, GetReturnURLMixin, FormV
         if self.action in ["create", "update"]:
             form_class = getattr(self, "form_class", None)
         elif self.action == "bulk_create":
+            required_field_names = [
+                field["name"]
+                for field in get_csv_form_fields_from_serializer_class(self.serializer_class)
+                if field["required"]
+            ]
 
             class BulkCreateForm(BootstrapMixin, Form):
-                csv_data = CSVDataField(
-                    from_form=self.bulk_create_form_class, widget=Textarea(attrs=self.bulk_create_widget_attrs)
-                )
-                csv_file = CSVFileField(from_form=self.bulk_create_form_class)
+                csv_data = CSVDataField(required_field_names=required_field_names)
+                csv_file = CSVFileField()
 
             form_class = BulkCreateForm
         else:
@@ -566,6 +578,17 @@ class ObjectDetailViewMixin(NautobotViewSetMixin, mixins.RetrieveModelMixin):
     UI mixin to retrieve a model instance.
     """
 
+    def retrieve(self, request, *args, **kwargs):
+        """
+        Retrieve a model instance.
+        """
+        instance = self.get_object()
+        serializer = self.get_serializer(instance)
+
+        context = serializer.data
+        context["use_new_ui"] = True
+        return Response(context)
+
 
 class ObjectListViewMixin(NautobotViewSetMixin, mixins.ListModelMixin):
     """
@@ -622,13 +645,6 @@ class ObjectListViewMixin(NautobotViewSetMixin, mixins.ListModelMixin):
             response["Content-Disposition"] = f'attachment; filename="{filename}"'
             return response
 
-        # Fall back to built-in CSV formatting if export requested but no template specified
-        elif "export" in request.GET and hasattr(model, "to_csv"):
-            response = HttpResponse(self.queryset_to_csv(), content_type="text/csv")
-            filename = f"nautobot_{queryset.model._meta.verbose_name_plural}.csv"
-            response["Content-Disposition"] = f'attachment; filename="{filename}"'
-            return response
-
         return None
 
     def queryset_to_yaml(self):
@@ -640,40 +656,11 @@ class ObjectListViewMixin(NautobotViewSetMixin, mixins.ListModelMixin):
 
         return "---\n".join(yaml_data)
 
-    def queryset_to_csv(self):
-        """
-        Export the queryset of objects as comma-separated value (CSV), using the model's to_csv() method.
-        """
-        queryset = self.filter_queryset(self.get_queryset())
-        csv_data = []
-        custom_fields = []
-        # Start with the column headers
-        headers = queryset.model.csv_headers.copy()
-
-        # Add custom field headers, if any
-        if hasattr(queryset.model, "_custom_field_data"):
-            for custom_field in CustomField.objects.get_for_model(queryset.model):
-                headers.append(custom_field.add_prefix_to_cf_key())
-                custom_fields.append(custom_field.key)
-
-        csv_data.append(",".join(headers))
-
-        # Iterate through the queryset appending each object
-        for obj in queryset:
-            data = obj.to_csv()
-
-            for custom_field in custom_fields:
-                data += (obj.cf.get(custom_field, ""),)
-
-            csv_data.append(csv_format(data))
-
-        return "\n".join(csv_data)
-
     def list(self, request, *args, **kwargs):
         """
         List the model instances.
         """
-        context = {}
+        context = {"use_new_ui": True}
         if "export" in request.GET:
             queryset = self.get_queryset()
             model = queryset.model
@@ -895,14 +882,12 @@ class ObjectBulkDestroyViewMixin(NautobotViewSetMixin, BulkDestroyModelMixin):
         return Response(data)
 
 
-class ObjectBulkCreateViewMixin(NautobotViewSetMixin, BulkCreateModelMixin):
+class ObjectBulkCreateViewMixin(NautobotViewSetMixin):
     """
     UI mixin to bulk create model instances.
     """
 
     bulk_create_active_tab = "csv-data"
-    bulk_create_form_class = None
-    bulk_create_widget_attrs = {}
 
     def _process_bulk_create_form(self, form):
         # Iterate through CSV data and bind each row to a new model form instance.
@@ -918,18 +903,24 @@ class ObjectBulkCreateViewMixin(NautobotViewSetMixin, BulkCreateModelMixin):
                 self.bulk_create_active_tab = "csv-file"
             else:
                 field_name = "csv_data"
-            headers, records = form.cleaned_data[field_name]
-            for row, data in enumerate(records, start=1):
-                obj_form = self.bulk_create_form_class(data, headers=headers)
-                restrict_form_fields(obj_form, request.user)
-
-                if obj_form.is_valid():
-                    obj = self.form_save(obj_form)
-                    new_objs.append(obj)
+
+            csvtext = form.cleaned_data[field_name]
+            try:
+                data = NautobotCSVParser().parse(
+                    stream=BytesIO(csvtext.encode("utf-8")),
+                    parser_context={"request": request, "serializer_class": self.serializer_class},
+                )
+                serializer = self.serializer_class(data=data, context={"request": request}, many=True)
+                if serializer.is_valid():
+                    new_objs = serializer.save()
                 else:
-                    for field, err in obj_form.errors.items():
-                        form.add_error(field_name, f"Row {row} {field}: {err[0]}")
+                    for row, errors in enumerate(serializer.errors, start=1):
+                        for field, err in errors.items():
+                            form.add_error(field_name, f"Row {row}: {field}: {err[0]}")
                     raise ValidationError("")
+            except exceptions.ParseError as exc:
+                form.add_error(None, str(exc))
+                raise ValidationError("")
 
             # Enforce object-level permissions
             if queryset.filter(pk__in=[obj.pk for obj in new_objs]).count() != len(new_objs):

nautobot/core/views/paginator.py

@@ -24,7 +24,6 @@ class EnhancedPaginator(Paginator):
 
 class EnhancedPage(Page):
     def smart_pages(self):
-
         # When dealing with five or fewer pages, simply return the whole list.
         if self.paginator.num_pages <= 5:
             return self.paginator.page_range