nautobot 2.2.1__tar.gz → 2.2.2__tar.gz

{nautobot-2.2.1 → nautobot-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nautobot
-Version: 2.2.1
+Version: 2.2.2
 Summary: Source of truth and network automation platform.
 Home-page: https://nautobot.com
 License: Apache-2.0

{nautobot-2.2.1 → nautobot-2.2.2}/nautobot/core/tests/test_views.py

@@ -90,7 +90,8 @@ class HomeViewTestCase(TestCase):
         difference = [model for model in existing_models if model not in global_searchable_models]
         if difference:
             self.fail(
-                f'Existing model/models {",".join(difference)} are not included in the searchable_models attribute of the app config.\nIf you do not want the models to be searchable, please include them in the GLOBAL_SEARCH_EXCLUDE_LIST constant in nautobot.core.constants.'
+                f'Existing model/models {",".join(difference)} are not included in the searchable_models attribute of the app config.\n'
+                'If you do not want the models to be searchable, please include them in the GLOBAL_SEARCH_EXCLUDE_LIST constant in nautobot.core.constants.'
             )
 
     def make_request(self):

{nautobot-2.2.1 → nautobot-2.2.2}/nautobot/core/views/generic.py

@@ -54,9 +54,10 @@ from nautobot.core.views.utils import (
     import_csv_helper,
     prepare_cloned_fields,
 )
+from nautobot.extras.context_managers import deferred_change_logging_for_bulk_operation
 from nautobot.extras.models import ContactAssociation, ExportTemplate
 from nautobot.extras.tables import AssociatedContactsTable
-from nautobot.extras.utils import remove_prefix_from_cf_key
+from nautobot.extras.utils import bulk_delete_with_bulk_change_logging, remove_prefix_from_cf_key
 
 
 class GenericView(LoginRequiredMixin, View):
@@ -988,7 +989,7 @@ class BulkEditView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
                 nullified_fields = request.POST.getlist("_nullify")
 
                 try:
-                    with transaction.atomic():
+                    with deferred_change_logging_for_bulk_operation():
                         updated_objects = []
                         for obj in self.queryset.filter(pk__in=form.cleaned_data["pk"]):
                             obj = self.alter_obj(obj, request, [], kwargs)
@@ -1252,13 +1253,12 @@ class BulkDeleteView(GetReturnURLMixin, ObjectPermissionRequiredMixin, View):
 
                 self.perform_pre_delete(request, queryset)
                 try:
-                    _, deleted_info = queryset.delete()
+                    _, 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)

{nautobot-2.2.1 → nautobot-2.2.2}/nautobot/core/views/mixins.py

@@ -45,10 +45,11 @@ from nautobot.core.views.utils import (
     import_csv_helper,
     prepare_cloned_fields,
 )
+from nautobot.extras.context_managers import deferred_change_logging_for_bulk_operation
 from nautobot.extras.forms import NoteForm
 from nautobot.extras.models import ExportTemplate
 from nautobot.extras.tables import NoteTable, ObjectChangeTable
-from nautobot.extras.utils import remove_prefix_from_cf_key
+from nautobot.extras.utils import bulk_delete_with_bulk_change_logging, remove_prefix_from_cf_key
 
 PERMISSIONS_ACTION_MAP = {
     "list": "view",
@@ -846,7 +847,7 @@ class ObjectBulkDestroyViewMixin(NautobotViewSetMixin, BulkDestroyModelMixin):
 
         try:
             with transaction.atomic():
-                deleted_count = queryset.delete()[1][model._meta.label]
+                deleted_count = bulk_delete_with_bulk_change_logging(queryset)[1][model._meta.label]
                 msg = f"Deleted {deleted_count} {model._meta.verbose_name_plural}"
                 self.logger.info(msg)
                 self.success_url = self.get_return_url(request)
@@ -978,7 +979,7 @@ class ObjectBulkUpdateViewMixin(NautobotViewSetMixin, BulkUpdateModelMixin):
             if field not in form_custom_fields + form_relationships + ["pk"] + ["object_note"]
         ]
         nullified_fields = request.POST.getlist("_nullify")
-        with transaction.atomic():
+        with deferred_change_logging_for_bulk_operation():
             updated_objects = []
             for obj in queryset.filter(pk__in=form.cleaned_data["pk"]):
                 self.obj = obj

{nautobot-2.2.1 → nautobot-2.2.2}/nautobot/core/wsgi.py

@@ -1,11 +1,18 @@
 import logging
-import os
 
 from django.core import cache
 from django.core.wsgi import get_wsgi_application
 from django.db import connections
 
-os.environ["DJANGO_SETTINGS_MODULE"] = "nautobot_config"
+import nautobot
+
+# This is the Django default left here for visibility on how the Nautobot pattern
+# differs.
+# os.environ.setdefault("DJANGO_SETTINGS_MODULE", "nautobot.core.settings")
+
+# Instead of just pointing to `DJANGO_SETTINGS_MODULE` and letting Django run with it,
+# we're using the custom Nautobot loader code to read environment or config path for us.
+nautobot.setup()
 
 # Use try/except because we might not be running uWSGI. If `settings.WEBSERVER_WARMUP` is `True`,
 # will first call `get_internal_wsgi_application` which does not have `uwsgi` module loaded

{nautobot-2.2.1 → nautobot-2.2.2}/nautobot/dcim/forms.py

@@ -55,7 +55,7 @@ from nautobot.extras.forms import (
 )
 from nautobot.extras.models import ExternalIntegration, SecretsGroup, Status
 from nautobot.ipam.constants import BGP_ASN_MAX, BGP_ASN_MIN
-from nautobot.ipam.models import IPAddress, IPAddressToInterface, VLAN, VRF
+from nautobot.ipam.models import IPAddress, IPAddressToInterface, VLAN, VLANLocationAssignment, VRF
 from nautobot.tenancy.forms import TenancyFilterForm, TenancyForm
 from nautobot.tenancy.models import Tenant, TenantGroup
 from nautobot.virtualization.models import Cluster, ClusterGroup, VirtualMachine
@@ -194,8 +194,13 @@ class InterfaceCommonForm(forms.Form):
         # TODO: after Location model replaced Site, which was not a hierarchical model, should we allow users to add a VLAN
         # belongs to the parent Location or the child location of the parent device to the `tagged_vlan` field of the interface?
         elif mode == InterfaceModeChoices.MODE_TAGGED:
-            valid_locations = [None, self.cleaned_data[parent_field].location]
-            invalid_vlans = [str(v) for v in tagged_vlans if v.location not in valid_locations]
+            valid_location = self.cleaned_data[parent_field].location
+            invalid_vlans = [
+                str(v)
+                for v in tagged_vlans
+                if v.locations.without_tree_fields().exists()
+                and not VLANLocationAssignment.objects.filter(location=valid_location, vlan=v).exists()
+            ]
 
             if invalid_vlans:
                 raise forms.ValidationError(

{nautobot-2.2.1 → nautobot-2.2.2}/nautobot/dcim/templates/dcim/device/lldp_neighbors.html

@@ -65,7 +65,7 @@ var ready = (callback) => {
 };
 
 function getAttribute(node, querySelector, attribute) {
-    if (node === null or node.querySelector(querySelector) === null) {
+    if (node === null || node.querySelector(querySelector) === null) {
         return "";
     }
     return node.querySelector(querySelector).getAttribute(attribute) || "";
@@ -131,4 +131,4 @@ ready(() => {
 });
 
 </script>
-{% endblock %}
+{% endblock %}

{nautobot-2.2.1 → nautobot-2.2.2}/nautobot/dcim/templates/dcim/devicefamily_retrieve.html

@@ -20,7 +20,7 @@
                 </tr>
                 <tr>
                     <td>Total Devices</td>
-                    <td>{{ total_devices }}</td>
+                    <td><a href="{% url 'dcim:device_list' %}?device_family={{ object.name }}">{{ total_devices }}</a></td>
                 </tr>
             </table>
         </div>

{nautobot-2.2.1 → nautobot-2.2.2}/nautobot/dcim/tests/test_forms.py

@@ -1,8 +1,8 @@
 from django.test import TestCase
 
 from nautobot.core.testing.forms import FormTestCases
-from nautobot.dcim.choices import DeviceFaceChoices, InterfaceTypeChoices, RackWidthChoices
-from nautobot.dcim.forms import DeviceFilterForm, DeviceForm, InterfaceCreateForm, RackForm
+from nautobot.dcim.choices import DeviceFaceChoices, InterfaceModeChoices, InterfaceTypeChoices, RackWidthChoices
+from nautobot.dcim.forms import DeviceFilterForm, DeviceForm, InterfaceCreateForm, InterfaceForm, RackForm
 from nautobot.dcim.models import (
     Device,
     DeviceType,
@@ -14,6 +14,7 @@ from nautobot.dcim.models import (
     Rack,
 )
 from nautobot.extras.models import Role, SecretsGroup, Status
+from nautobot.ipam.models import VLAN
 from nautobot.tenancy.models import Tenant
 from nautobot.virtualization.models import Cluster, ClusterGroup, ClusterType
 
@@ -263,3 +264,49 @@ class RackTestCase(TestCase):
         }
         form = RackForm(data=data, instance=racks[0])
         self.assertTrue(form.is_valid())
+
+
+class InterfaceTestCase(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        cls.device = Device.objects.first()
+        status = Status.objects.get_for_model(Interface).first()
+        cls.interface = Interface.objects.create(
+            device=cls.device,
+            name="test interface form 0.0",
+            type=InterfaceTypeChoices.TYPE_2GFC_SFP,
+            status=status,
+        )
+        cls.vlan = VLAN.objects.first()
+        cls.data = {
+            "device": cls.device.pk,
+            "name": "test interface form 0.0",
+            "type": InterfaceTypeChoices.TYPE_2GFC_SFP,
+            "status": status.pk,
+            "mode": InterfaceModeChoices.MODE_TAGGED,
+            "tagged_vlans": [cls.vlan.pk],
+        }
+
+    def test_interface_form_clean_vlan_location_fail(self):
+        """Assert that form validation fails when no matching locations are associated to tagged VLAN"""
+        self.vlan.locations.set(list(Location.objects.exclude(pk=self.device.location.pk))[:2])
+        form = InterfaceForm(data=self.data, instance=self.interface)
+        self.assertFalse(form.is_valid())
+
+    def test_interface_vlan_location_clean_multiple_locations_pass(self):
+        """Assert that form validation passes when multiple locations are associated to tagged VLAN with one matching"""
+        self.vlan.locations.add(self.device.location)
+        form = InterfaceForm(data=self.data, instance=self.interface)
+        self.assertTrue(form.is_valid())
+
+    def test_interface_vlan_location_clean_single_location_pass(self):
+        """Assert that form validation passes when a single location is associated to tagged VLAN"""
+        self.vlan.locations.set([self.device.location])
+        form = InterfaceForm(data=self.data, instance=self.interface)
+        self.assertTrue(form.is_valid())
+
+    def test_interface_vlan_location_clean_no_locations_pass(self):
+        """Assert that form validation passes when no locations are associated to tagged VLAN"""
+        self.vlan.locations.clear()
+        form = InterfaceForm(data=self.data, instance=self.interface)
+        self.assertTrue(form.is_valid())

{nautobot-2.2.1 → nautobot-2.2.2}/nautobot/extras/context_managers.py

@@ -3,9 +3,11 @@ import uuid
 
 from django.contrib.auth import get_user_model
 from django.contrib.auth.models import AnonymousUser
+from django.db import transaction
 from django.test.client import RequestFactory
 
 from nautobot.extras.choices import ObjectChangeEventContextChoices
+from nautobot.extras.constants import CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL
 from nautobot.extras.models import ObjectChange
 from nautobot.extras.signals import change_context_state, get_user_if_authenticated
 from nautobot.extras.webhooks import enqueue_webhooks
@@ -25,9 +27,12 @@ class ChangeContext:
     :param change_id: Optional uuid object to uniquely identify the transaction. One will be generated if not supplied
     """
 
+    defer_object_changes = False  # advanced usage, for creating object changes in bulk
+
     def __init__(self, user=None, request=None, context=None, context_detail="", change_id=None):
         self.request = request
         self.user = user
+        self.reset_deferred_object_changes()
 
         if self.request is None and self.user is None:
             raise TypeError("Either user or request must be provided")
@@ -63,6 +68,36 @@ class ChangeContext:
         }
         return context
 
+    def _object_change_batch(self, n):
+        # Return first n keys from the self.deferred_object_changes dict
+        keys = []
+        for i, k in enumerate(self.deferred_object_changes.keys()):
+            if i >= n:
+                return keys
+            keys.append(k)
+        return keys
+
+    def reset_deferred_object_changes(self):
+        self.deferred_object_changes = {}
+
+    def flush_deferred_object_changes(self, batch_size=1000):
+        if self.defer_object_changes:
+            self.create_object_changes(batch_size=batch_size)
+
+    def create_object_changes(self, batch_size=1000):
+        while self.deferred_object_changes:
+            create_object_changes = []
+            for key in self._object_change_batch(batch_size):
+                for entry in self.deferred_object_changes[key]:
+                    objectchange = entry["instance"].to_objectchange(entry["action"])
+                    objectchange.user = entry["user"]
+                    objectchange.request_id = self.change_id
+                    objectchange.change_context = self.context
+                    objectchange.change_context_detail = self.context_detail[:CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL]
+                    create_object_changes.append(objectchange)
+                self.deferred_object_changes.pop(key, None)
+            ObjectChange.objects.bulk_create(create_object_changes, batch_size=batch_size)
+
 
 class JobChangeContext(ChangeContext):
     """ChangeContext for changes made by jobs"""
@@ -163,3 +198,24 @@ def web_request_context(
         for object_change in ObjectChange.objects.filter(request_id=change_context.change_id).iterator():
             enqueue_job_hooks(object_change)
             enqueue_webhooks(object_change)
+
+
+@contextmanager
+def deferred_change_logging_for_bulk_operation():
+    """
+    Defers change logging until the end of the context manager to improve performance. For use with bulk edit views. This
+    context manager is wrapped in an atomic transaction.
+    """
+
+    change_context = change_context_state.get()
+    if change_context is None:
+        raise ValueError("Change logging must be enabled before using deferred_change_logging_for_bulk_operation")
+
+    with transaction.atomic():
+        try:
+            change_context.defer_object_changes = True
+            yield
+            change_context.flush_deferred_object_changes()
+        finally:
+            change_context.defer_object_changes = False
+            change_context.reset_deferred_object_changes()

{nautobot-2.2.1 → nautobot-2.2.2}/nautobot/extras/signals.py

@@ -103,7 +103,9 @@ def _handle_changed_object(sender, instance, raw=False, **kwargs):
     if raw:
         return
 
-    if change_context_state.get() is None:
+    change_context = change_context_state.get()
+
+    if change_context is None:
         return
 
     # Determine the type of change being made
@@ -119,36 +121,49 @@ def _handle_changed_object(sender, instance, raw=False, **kwargs):
 
     # Record an ObjectChange if applicable
     if hasattr(instance, "to_objectchange"):
-        user = change_context_state.get().get_user(instance)
+        user = change_context.get_user(instance)
         # save a copy of this instance's field cache so it can be restored after serialization
         # to prevent unexpected behavior when chaining multiple signal handlers
         original_cache = instance._state.fields_cache.copy()
 
+        changed_object_type = ContentType.objects.get_for_model(instance)
+        changed_object_id = instance.id
+
+        # Generate a unique identifier for this change to stash in the change context
+        # This is used for deferred change logging and for looking up related changes without querying the database
+        unique_object_change_id = f"{changed_object_type.pk}__{changed_object_id}__{user.pk}"
+
         # If a change already exists for this change_id, user, and object, update it instead of creating a new one.
         # If the object was deleted then recreated with the same pk (don't do this), change the action to update.
-        related_changes = ObjectChange.objects.filter(
-            changed_object_type=ContentType.objects.get_for_model(instance),
-            changed_object_id=instance.pk,
-            user=user,
-            request_id=change_context_state.get().change_id,
-        )
-        objectchange = instance.to_objectchange(action)
-        if related_changes.exists():
-            most_recent_change = related_changes.order_by("-time").first()
-            if most_recent_change.action == ObjectChangeActionChoices.ACTION_DELETE:
-                most_recent_change.action = ObjectChangeActionChoices.ACTION_UPDATE
-            most_recent_change.object_data = objectchange.object_data
-            most_recent_change.object_data_v2 = objectchange.object_data_v2
-            most_recent_change.save()
-            objectchange = most_recent_change
+        if unique_object_change_id in change_context.deferred_object_changes:
+            related_changes = ObjectChange.objects.filter(
+                changed_object_type=changed_object_type,
+                changed_object_id=changed_object_id,
+                user=user,
+                request_id=change_context.change_id,
+            )
+
+            # Skip the database check when deferring object changes
+            if not change_context.defer_object_changes and related_changes.exists():
+                objectchange = instance.to_objectchange(action)
+                most_recent_change = related_changes.order_by("-time").first()
+                if most_recent_change.action == ObjectChangeActionChoices.ACTION_DELETE:
+                    most_recent_change.action = ObjectChangeActionChoices.ACTION_UPDATE
+                most_recent_change.object_data = objectchange.object_data
+                most_recent_change.object_data_v2 = objectchange.object_data_v2
+                most_recent_change.save()
+
         else:
-            objectchange.user = user
-            objectchange.request_id = change_context_state.get().change_id
-            objectchange.change_context = change_context_state.get().context
-            objectchange.change_context_detail = change_context_state.get().context_detail[
-                :CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL
+            change_context.deferred_object_changes[unique_object_change_id] = [
+                {"action": action, "instance": instance, "user": user}
             ]
-            objectchange.save()
+            if not change_context.defer_object_changes:
+                objectchange = instance.to_objectchange(action)
+                objectchange.user = user
+                objectchange.request_id = change_context.change_id
+                objectchange.change_context = change_context.context
+                objectchange.change_context_detail = change_context.context_detail[:CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL]
+                objectchange.save()
 
         # restore field cache
         instance._state.fields_cache = original_cache
@@ -171,7 +186,9 @@ def _handle_deleted_object(sender, instance, **kwargs):
     """
     Fires when an object is deleted.
     """
-    if change_context_state.get() is None:
+    change_context = change_context_state.get()
+
+    if change_context is None:
         return
 
     if isinstance(instance, BaseModel):
@@ -186,41 +203,58 @@ def _handle_deleted_object(sender, instance, **kwargs):
 
     # Record an ObjectChange if applicable
     if hasattr(instance, "to_objectchange"):
-        user = change_context_state.get().get_user(instance)
+        user = change_context.get_user(instance)
 
         # save a copy of this instance's field cache so it can be restored after serialization
         # to prevent unexpected behavior when chaining multiple signal handlers
         original_cache = instance._state.fields_cache.copy()
 
+        changed_object_type = ContentType.objects.get_for_model(instance)
+        changed_object_id = instance.id
+
+        # Generate a unique identifier for this change to stash in the change context
+        # This is used for deferred change logging and for looking up related changes without querying the database
+        unique_object_change_id = f"{changed_object_type.pk}__{changed_object_id}__{user.pk}"
+        save_new_objectchange = True
+
         # if a change already exists for this change_id, user, and object, update it instead of creating a new one
         # except in the case that the object was created and deleted in the same change_id
         # we don't want to create a delete change for an object that never existed
-        related_changes = ObjectChange.objects.filter(
-            changed_object_type=ContentType.objects.get_for_model(instance),
-            changed_object_id=instance.pk,
-            user=user,
-            request_id=change_context_state.get().change_id,
-        )
-        objectchange = instance.to_objectchange(ObjectChangeActionChoices.ACTION_DELETE)
-        save_new_objectchange = True
-        if related_changes.exists():
-            most_recent_change = related_changes.order_by("-time").first()
-            if most_recent_change.action != ObjectChangeActionChoices.ACTION_CREATE:
-                most_recent_change.action = ObjectChangeActionChoices.ACTION_DELETE
-                most_recent_change.object_data = objectchange.object_data
-                most_recent_change.object_data_v2 = objectchange.object_data_v2
-                most_recent_change.save()
-                objectchange = most_recent_change
+        if unique_object_change_id in change_context.deferred_object_changes:
+            cached_related_change = change_context.deferred_object_changes[unique_object_change_id][-1]
+            if cached_related_change["action"] != ObjectChangeActionChoices.ACTION_CREATE:
+                cached_related_change["action"] = ObjectChangeActionChoices.ACTION_DELETE
                 save_new_objectchange = False
 
+            related_changes = ObjectChange.objects.filter(
+                changed_object_type=changed_object_type,
+                changed_object_id=changed_object_id,
+                user=user,
+                request_id=change_context.change_id,
+            )
+
+            # Skip the database check when deferring object changes
+            if not change_context.defer_object_changes and related_changes.exists():
+                objectchange = instance.to_objectchange(ObjectChangeActionChoices.ACTION_DELETE)
+                most_recent_change = related_changes.order_by("-time").first()
+                if most_recent_change.action != ObjectChangeActionChoices.ACTION_CREATE:
+                    most_recent_change.action = ObjectChangeActionChoices.ACTION_DELETE
+                    most_recent_change.object_data = objectchange.object_data
+                    most_recent_change.object_data_v2 = objectchange.object_data_v2
+                    most_recent_change.save()
+                    save_new_objectchange = False
+
         if save_new_objectchange:
-            objectchange.user = user
-            objectchange.request_id = change_context_state.get().change_id
-            objectchange.change_context = change_context_state.get().context
-            objectchange.change_context_detail = change_context_state.get().context_detail[
-                :CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL
-            ]
-            objectchange.save()
+            change_context.deferred_object_changes.setdefault(unique_object_change_id, []).append(
+                {"action": ObjectChangeActionChoices.ACTION_DELETE, "instance": instance, "user": user}
+            )
+            if not change_context.defer_object_changes:
+                objectchange = instance.to_objectchange(ObjectChangeActionChoices.ACTION_DELETE)
+                objectchange.user = user
+                objectchange.request_id = change_context.change_id
+                objectchange.change_context = change_context.context
+                objectchange.change_context_detail = change_context.context_detail[:CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL]
+                objectchange.save()
 
         # restore field cache
         instance._state.fields_cache = original_cache

{nautobot-2.2.1 → nautobot-2.2.2}/nautobot/extras/tests/test_context_managers.py

@@ -7,7 +7,10 @@ from nautobot.core.testing import TransactionTestCase
 from nautobot.core.utils.lookup import get_changes_for_model
 from nautobot.dcim.models import Location, LocationType
 from nautobot.extras.choices import ObjectChangeActionChoices, ObjectChangeEventContextChoices
-from nautobot.extras.context_managers import web_request_context
+from nautobot.extras.context_managers import (
+    deferred_change_logging_for_bulk_operation,
+    web_request_context,
+)
 from nautobot.extras.models import Status, Webhook
 
 # Use the proper swappable User model
@@ -193,3 +196,97 @@ class WebRequestContextTransactionTestCase(TransactionTestCase):
             Status.objects.create(name="Test Status 2")
 
         self.assertEqual(get_changes_for_model(Status).count(), 2)
+
+
+class BulkEditDeleteChangeLogging(TestCase):
+    def setUp(self):
+        self.user = User.objects.create_user(
+            username="jacob",
+            email="jacob@example.com",
+            password="top_secret",  # noqa: S106  # hardcoded-password-func-arg -- ok as this is test code only
+        )
+
+    def test_change_log_created(self):
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with web_request_context(self.user):
+            with deferred_change_logging_for_bulk_operation():
+                location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+                location.save()
+
+        location = Location.objects.get(name="Test Location 1")
+        oc_list = get_changes_for_model(location).order_by("pk")
+        self.assertEqual(len(oc_list), 1)
+        self.assertEqual(oc_list[0].changed_object, location)
+        self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_CREATE)
+
+    def test_delete(self):
+        """Test that deletes raise an exception"""
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with self.assertRaises(ValueError):
+            with web_request_context(self.user):
+                with deferred_change_logging_for_bulk_operation():
+                    location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+                    location.save()
+                    location.delete()
+
+    def test_create_then_update(self):
+        """Test that a create followed by an update is logged as a single create"""
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with web_request_context(self.user):
+            with deferred_change_logging_for_bulk_operation():
+                location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+                location.save()
+                location.description = "changed"
+                location.save()
+
+        oc_list = get_changes_for_model(location)
+        self.assertEqual(len(oc_list), 1)
+        self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_CREATE)
+        snapshots = oc_list[0].get_snapshots()
+        self.assertIsNone(snapshots["prechange"])
+        self.assertIsNotNone(snapshots["postchange"])
+        self.assertIsNone(snapshots["differences"]["removed"])
+        self.assertEqual(snapshots["differences"]["added"]["description"], "changed")
+
+    def test_bulk_edit(self):
+        """Test that edits to multiple objects are correctly logged"""
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        locations = [
+            Location(name=f"Test Location {i}", location_type=location_type, status=location_status)
+            for i in range(1, 4)
+        ]
+        Location.objects.bulk_create(locations)
+        with web_request_context(self.user):
+            with deferred_change_logging_for_bulk_operation():
+                for location in locations:
+                    location.description = "changed"
+                    location.save()
+
+        oc_list = get_changes_for_model(Location)
+        self.assertEqual(len(oc_list), 3)
+        for oc in oc_list:
+            self.assertEqual(oc.action, ObjectChangeActionChoices.ACTION_UPDATE)
+            snapshots = oc.get_snapshots()
+            self.assertIsNone(snapshots["prechange"])
+            self.assertIsNotNone(snapshots["postchange"])
+            self.assertIsNone(snapshots["differences"]["removed"])
+            self.assertEqual(snapshots["differences"]["added"]["description"], "changed")
+
+    def test_change_log_context(self):
+        location_type = LocationType.objects.get(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        with web_request_context(self.user, context_detail="test_change_log_context"):
+            with deferred_change_logging_for_bulk_operation():
+                location = Location(name="Test Location 1", location_type=location_type, status=location_status)
+                location.save()
+
+        location = Location.objects.get(name="Test Location 1")
+        oc_list = get_changes_for_model(location)
+        with self.subTest():
+            self.assertEqual(oc_list[0].change_context, ObjectChangeEventContextChoices.CONTEXT_ORM)
+        with self.subTest():
+            self.assertEqual(oc_list[0].change_context_detail, "test_change_log_context")

{nautobot-2.2.1 → nautobot-2.2.2}/nautobot/extras/utils.py

@@ -19,7 +19,9 @@ from nautobot.core.choices import ColorChoices
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
 from nautobot.core.models.managers import TagsManager
 from nautobot.core.models.utils import find_models_with_matching_fields
+from nautobot.extras.choices import ObjectChangeActionChoices
 from nautobot.extras.constants import (
+    CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL,
     EXTRAS_FEATURES,
     JOB_MAX_NAME_LENGTH,
     JOB_OVERRIDABLE_FIELDS,
@@ -610,3 +612,38 @@ def migrate_role_data(
             model_to_migrate._meta.label,
             to_role_field_name,
         )
+
+
+def bulk_delete_with_bulk_change_logging(qs, batch_size=1000):
+    """
+    Deletes objects in the provided queryset and creates ObjectChange instances in bulk to improve performance.
+    For use with bulk delete views. This operation is wrapped in an atomic transaction.
+    """
+    from nautobot.extras.models import ObjectChange
+    from nautobot.extras.signals import change_context_state
+
+    change_context = change_context_state.get()
+    if change_context is None:
+        raise ValueError("Change logging must be enabled before using bulk_delete_with_bulk_change_logging")
+
+    with transaction.atomic():
+        try:
+            queued_object_changes = []
+            change_context.defer_object_changes = True
+            for obj in qs.iterator():
+                if not hasattr(obj, "to_objectchange"):
+                    break
+                if len(queued_object_changes) >= batch_size:
+                    ObjectChange.objects.bulk_create(queued_object_changes)
+                    queued_object_changes = []
+                oc = obj.to_objectchange(ObjectChangeActionChoices.ACTION_DELETE)
+                oc.user = change_context.user
+                oc.request_id = change_context.change_id
+                oc.change_context = change_context.context
+                oc.change_context_detail = change_context.context_detail[:CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL]
+                queued_object_changes.append(oc)
+            ObjectChange.objects.bulk_create(queued_object_changes)
+            return qs.delete()
+        finally:
+            change_context.defer_object_changes = False
+            change_context.reset_deferred_object_changes()