nautobot 2.4.3__py3-none-any.whl → 2.4.5__py3-none-any.whl

nautobot/ipam/tests/test_api.py

@@ -13,7 +13,15 @@ from rest_framework import status
 from nautobot.core.testing import APITestCase, APIViewTestCases, disable_warnings
 from nautobot.core.testing.api import APITransactionTestCase
 from nautobot.dcim.choices import InterfaceTypeChoices
-from nautobot.dcim.models import Device, DeviceType, Interface, Location, LocationType, Manufacturer
+from nautobot.dcim.models import (
+    Device,
+    DeviceType,
+    Interface,
+    Location,
+    LocationType,
+    Manufacturer,
+    VirtualDeviceContext,
+)
 from nautobot.extras.models import CustomField, Role, Status
 from nautobot.ipam import choices
 from nautobot.ipam.models import (
@@ -118,6 +126,7 @@ class VRFDeviceAssignmentTest(APIViewTestCases.APIViewTestCase):
     def setUpTestData(cls):
         cls.vrfs = VRF.objects.all()
         cls.devices = Device.objects.all()
+        cls.vdcs = VirtualDeviceContext.objects.all()
         locations = Location.objects.filter(location_type__name="Campus")
         cluster_type = ClusterType.objects.create(name="Test Cluster Type")
         clusters = (
@@ -154,25 +163,42 @@ class VRFDeviceAssignmentTest(APIViewTestCases.APIViewTestCase):
             virtual_machine=cls.test_vm,
             rd="65000:4",
         )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            virtual_device_context=cls.vdcs[0],
+            name="VRFDeviceAssignment 1",
+            rd="65000:5",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            virtual_device_context=cls.vdcs[1],
+        )
+
+        cls.update_data = {
+            "name": "VRFDeviceAssignment 2",
+            "rd": "65000:7",
+        }
 
         cls.create_data = [
             {
                 "vrf": cls.vrfs[2].pk,
                 "device": cls.devices[4].pk,
-                "virtual_machine": None,
-                "rd": "65000:4",
+                "rd": "65000:7",
             },
             {
                 "vrf": cls.vrfs[3].pk,
-                "device": None,
                 "virtual_machine": cls.test_vm.pk,
-                "rd": "65000:5",
+                "rd": "65000:8",
             },
             {
                 "vrf": cls.vrfs[4].pk,
                 "device": cls.devices[6].pk,
-                "virtual_machine": None,
-                "rd": "65000:6",
+                "name": "VRFDeviceAssignment 3",
+                "rd": "65000:9",
+            },
+            {
+                "vrf": cls.vrfs[4].pk,
+                "virtual_device_context": cls.vdcs[0].pk,
             },
         ]
         cls.bulk_update_data = {
@@ -181,39 +207,66 @@ class VRFDeviceAssignmentTest(APIViewTestCases.APIViewTestCase):
 
     def test_creating_invalid_vrf_device_assignments(self):
         # Add object-level permission
-        duplicate_device_create_data = {
-            "vrf": self.vrfs[0].pk,
-            "device": self.devices[1].pk,
-            "virtual_machine": None,
-            "rd": "65000:6",
-        }
-        duplicate_vm_create_data = {
-            "vrf": self.vrfs[1].pk,
-            "device": None,
-            "virtual_machine": self.test_vm.pk,
-            "rd": "65000:6",
-        }
-        invalid_create_data = {
-            "vrf": self.vrfs[2].pk,
-            "device": self.devices[6].pk,
-            "virtual_machine": self.test_vm.pk,
-            "rd": "65000:6",
-        }
         self.add_permissions("ipam.add_vrfdeviceassignment")
-        response = self.client.post(self._get_list_url(), duplicate_device_create_data, format="json", **self.header)
-        self.assertContains(
-            response, "The fields device, vrf must make a unique set.", status_code=status.HTTP_400_BAD_REQUEST
-        )
-        response = self.client.post(self._get_list_url(), duplicate_vm_create_data, format="json", **self.header)
-        self.assertContains(
-            response, "The fields virtual_machine, vrf must make a unique set.", status_code=status.HTTP_400_BAD_REQUEST
-        )
-        response = self.client.post(self._get_list_url(), invalid_create_data, format="json", **self.header)
-        self.assertContains(
-            response,
-            "A VRF cannot be associated with both a device and a virtual machine.",
-            status_code=status.HTTP_400_BAD_REQUEST,
-        )
+        duplicate_create_data = [
+            {
+                "vrf": self.vrfs[0].pk,
+                "device": self.devices[1].pk,
+                "rd": "65000:6",
+            },
+            {
+                "vrf": self.vrfs[1].pk,
+                "virtual_machine": self.test_vm.pk,
+                "rd": "65000:6",
+            },
+            {
+                "vrf": self.vrfs[0].pk,
+                "virtual_device_context": self.vdcs[1].pk,
+                "rd": "65000:6",
+            },
+        ]
+        expected_responses = [
+            "The fields device, vrf must make a unique set.",
+            "The fields virtual_machine, vrf must make a unique set.",
+            "The fields virtual_device_context, vrf must make a unique set.",
+        ]
+        for i, data in enumerate(duplicate_create_data):
+            response = self.client.post(self._get_list_url(), data, format="json", **self.header)
+            self.assertContains(response, expected_responses[i], status_code=status.HTTP_400_BAD_REQUEST)
+
+        # Test VRFDeviceAssignment model clean() code paths
+        vrf = VRF.objects.create(name="New VRF ", namespace=Namespace.objects.first())
+        invalid_create_data = [
+            {
+                "vrf": vrf.pk,
+                "device": self.devices[6].pk,
+                "virtual_machine": self.test_vm.pk,
+            },
+            {
+                "vrf": vrf.pk,
+                "device": self.devices[7].pk,
+                "virtual_device_context": self.vdcs[2].pk,
+            },
+            {
+                "vrf": vrf.pk,
+                "virtual_machine": self.test_vm.pk,
+                "virtual_device_context": self.vdcs[3].pk,
+            },
+            {
+                "vrf": vrf.pk,
+                "name": "VRFDeviceAssignment 5",
+                "rd": "65000:6",
+            },
+        ]
+        expected_responses = [
+            "A VRFDeviceAssignment entry cannot be associated with both a device and a virtual machine.",
+            "A VRFDeviceAssignment entry cannot be associated with both a device and a virtual device context.",
+            "A VRFDeviceAssignment entry cannot be associated with both a virtual machine and a virtual device context.",
+            "A VRFDeviceAssignment entry must be associated with a device, a virtual machine, or a virtual device context.",
+        ]
+        for i, data in enumerate(invalid_create_data):
+            response = self.client.post(self._get_list_url(), data, format="json", **self.header)
+            self.assertContains(response, expected_responses[i], status_code=status.HTTP_400_BAD_REQUEST)
 
 
 class VRFPrefixAssignmentTest(APIViewTestCases.APIViewTestCase):
@@ -221,50 +274,38 @@ class VRFPrefixAssignmentTest(APIViewTestCases.APIViewTestCase):
 
     @classmethod
     def setUpTestData(cls):
+        cls.namespace = (
+            Namespace.objects.annotate(prefixes_count=Count("prefixes")).filter(prefixes_count__gte=3).first()
+        )
         cls.vrfs = (
-            VRF.objects.annotate(prefixes_count=Count("namespace__prefixes")).filter(prefixes_count__gte=2).distinct()
+            VRF.objects.create(name="TEST VRF 1", namespace=cls.namespace),
+            VRF.objects.create(name="TEST VRF 2", namespace=cls.namespace),
         )
-        cls.prefixes = Prefix.objects.all()
+        cls.prefixes = Prefix.objects.filter(namespace=cls.namespace)
 
-        VRFPrefixAssignment.objects.create(
-            vrf=cls.vrfs[0],
-            prefix=cls.prefixes.filter(namespace=cls.vrfs[0].namespace)[0],
-        )
-        VRFPrefixAssignment.objects.create(
-            vrf=cls.vrfs[0],
-            prefix=cls.prefixes.filter(namespace=cls.vrfs[0].namespace)[1],
-        )
-        VRFPrefixAssignment.objects.create(
-            vrf=cls.vrfs[1],
-            prefix=cls.prefixes.filter(namespace=cls.vrfs[1].namespace)[0],
-        )
-        VRFPrefixAssignment.objects.create(
-            vrf=cls.vrfs[1],
-            prefix=cls.prefixes.filter(namespace=cls.vrfs[1].namespace)[1],
-        )
         cls.create_data = [
             {
-                "vrf": cls.vrfs[2].pk,
-                "prefix": cls.prefixes.filter(namespace=cls.vrfs[2].namespace).exclude(vrfs=cls.vrfs[2])[0].pk,
+                "vrf": cls.vrfs[0].pk,
+                "prefix": cls.prefixes.first().pk,
             },
             {
-                "vrf": cls.vrfs[3].pk,
-                "prefix": cls.prefixes.filter(namespace=cls.vrfs[3].namespace).exclude(vrfs=cls.vrfs[3])[0].pk,
+                "vrf": cls.vrfs[0].pk,
+                "prefix": cls.prefixes.last().pk,
             },
             {
-                "vrf": cls.vrfs[4].pk,
-                "prefix": cls.prefixes.filter(namespace=cls.vrfs[4].namespace).exclude(vrfs=cls.vrfs[4])[0].pk,
+                "vrf": cls.vrfs[1].pk,
+                "prefix": cls.prefixes.first().pk,
             },
         ]
 
     def test_creating_invalid_vrf_prefix_assignments(self):
         duplicate_create_data = {
-            "vrf": self.vrfs[0].pk,
-            "prefix": self.prefixes.filter(namespace=self.vrfs[0].namespace)[0].pk,
+            "vrf": VRFPrefixAssignment.objects.first().vrf.pk,
+            "prefix": VRFPrefixAssignment.objects.first().prefix.pk,
         }
         wrong_namespace_create_data = {
             "vrf": self.vrfs[0].pk,
-            "prefix": self.prefixes.exclude(namespace=self.vrfs[0].namespace)[0].pk,
+            "prefix": Prefix.objects.exclude(namespace=self.namespace)[0].pk,
         }
         missing_field_create_data = {
             "vrf": self.vrfs[0].pk,

nautobot/ipam/tests/test_filters.py

@@ -10,6 +10,7 @@ from nautobot.dcim.models import (
     Location,
     LocationType,
     Manufacturer,
+    VirtualDeviceContext,
 )
 from nautobot.extras.models import Role, Status, Tag
 from nautobot.ipam.choices import PrefixTypeChoices, ServiceProtocolChoices
@@ -24,7 +25,9 @@ from nautobot.ipam.filters import (
     VLANFilterSet,
     VLANGroupFilterSet,
     VLANLocationAssignmentFilterSet,
+    VRFDeviceAssignmentFilterSet,
     VRFFilterSet,
+    VRFPrefixAssignmentFilterSet,
 )
 from nautobot.ipam.models import (
     IPAddress,
@@ -39,6 +42,8 @@ from nautobot.ipam.models import (
     VLANGroup,
     VLANLocationAssignment,
     VRF,
+    VRFDeviceAssignment,
+    VRFPrefixAssignment,
 )
 from nautobot.tenancy.models import Tenant
 from nautobot.virtualization.models import (
@@ -66,12 +71,19 @@ class VRFTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterT
     # skip testing "rd" attribute for generic q filter test as it's not trivially modifiable
     exclude_q_filter_predicates = ["rd"]
     generic_filter_tests = (
+        # ("device", "devices__id"),
+        # ("device", "devices__name"),
         ("export_targets", "export_targets__id"),
         ("export_targets", "export_targets__name"),
         ("import_targets", "import_targets__id"),
         ("import_targets", "import_targets__name"),
+        ("prefix", "prefixes__id"),
         ("name",),
+        ("namespace", "namespace__id"),
+        ("namespace", "namespace__name"),
         ("rd",),
+        # ("virtual_machines", "virtual_machines__id"),
+        # ("virtual_machines", "virtual_machines__name"),
     )
 
     @classmethod
@@ -79,6 +91,36 @@ class VRFTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterT
         instance = cls.queryset.first()
         instance.tags.set(Tag.objects.all()[:2])
 
+    def test_prefix_filter_by_string(self):
+        """Test filtering by prefix strings as an alternative to pk."""
+        prefix = self.queryset.filter(prefixes__isnull=False).first().prefixes.first()
+        params = {"prefix": [prefix.prefix]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(prefixes__network=prefix.network, prefixes__prefix_length=prefix.prefix_length),
+            ordered=False,
+        )
+
+
+class VRFPrefixAssignmentTestCase(FilterTestCases.FilterTestCase):
+    queryset = VRFPrefixAssignment.objects.all()
+    filterset = VRFPrefixAssignmentFilterSet
+    generic_filter_tests = (
+        ("prefix", "prefix__id"),
+        ("vrf", "vrf__id"),
+        ("vrf", "vrf__name"),
+    )
+
+    def test_prefix_filter_by_string(self):
+        """Test filtering by prefix strings as an alternative to pk."""
+        prefix = self.queryset.first().prefix
+        params = {"prefix": [prefix.prefix]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(prefix__network=prefix.network, prefix__prefix_length=prefix.prefix_length),
+            ordered=False,
+        )
+
 
 class RouteTargetTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
     queryset = RouteTarget.objects.all()
@@ -190,15 +232,32 @@ class PrefixLocationAssignmentTestCase(FilterTestCases.FilterTestCase):
     # )
 
     def test_prefix(self):
-        ipv4_prefix = str(self.queryset.filter(prefix__ip_version=4).first().prefix)
-        ipv6_prefix = str(self.queryset.filter(prefix__ip_version=6).first().prefix)
+        ipv4_prefix = self.queryset.filter(prefix__ip_version=4).first().prefix
+        ipv6_prefix = self.queryset.filter(prefix__ip_version=6).first().prefix
+
+        params = {"prefix": [ipv4_prefix.prefix, ipv6_prefix.pk]}
+
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(prefix=ipv6_prefix)
+            | self.queryset.filter(
+                prefix__network=ipv4_prefix.network,
+                prefix__prefix_length=ipv4_prefix.prefix_length,
+                prefix__broadcast=ipv4_prefix.broadcast,
+            ),
+            ordered=False,
+        )
 
-        params = {"prefix": [ipv4_prefix, ipv6_prefix]}
-        prefix_queryset = Prefix.objects.net_equals(ipv4_prefix, ipv6_prefix)
+        params = {"prefix": [ipv4_prefix.pk, ipv6_prefix.prefix]}
 
         self.assertQuerysetEqualAndNotEmpty(
             self.filterset(params, self.queryset).qs,
-            self.queryset.filter(prefix__in=prefix_queryset),
+            self.queryset.filter(prefix=ipv4_prefix)
+            | self.queryset.filter(
+                prefix__network=ipv6_prefix.network,
+                prefix__prefix_length=ipv6_prefix.prefix_length,
+                prefix__broadcast=ipv6_prefix.broadcast,
+            ),
             ordered=False,
         )
 
@@ -289,11 +348,21 @@ class PrefixFilterCustomDataTestCase(TestCase):
         self.assertQuerysetEqualAndNotEmpty(
             self.filterset(params, self.queryset).qs, self.queryset.filter(parent=parent4)
         )
+        params = {"parent": ["10.0.0.0/16"]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(parent__network="10.0.0.0", parent__prefix_length=16),
+        )
         parent6 = Prefix.objects.get(prefix="2001:db8::/32", namespace=self.namespace)
         params = {"parent": [str(parent6.pk)]}
         self.assertQuerysetEqualAndNotEmpty(
             self.filterset(params, self.queryset).qs, self.queryset.filter(parent=parent6)
         )
+        params = {"parent": ["2001:db8::/32"]}
+        self.assertQuerysetEqualAndNotEmpty(
+            self.filterset(params, self.queryset).qs,
+            self.queryset.filter(parent__network="2001:db8::", parent__prefix_length=32),
+        )
 
     def test_ip_version(self):
         params = {"ip_version": "6"}
@@ -980,6 +1049,77 @@ class IPAddressToInterfaceTestCase(FilterTestCases.FilterTestCase):
                 )
 
 
+class VRFDeviceAssignmentTestCase(FilterTestCases.FilterTestCase):
+    queryset = VRFDeviceAssignment.objects.all()
+    filterset = VRFDeviceAssignmentFilterSet
+    generic_filter_tests = (
+        ["vrf", "vrf__id"],
+        ["vrf", "vrf__name"],
+        ["device", "device__id"],
+        ["device", "device__name"],
+        ["virtual_machine", "virtual_machine__id"],
+        ["virtual_machine", "virtual_machine__name"],
+        ["virtual_device_context", "virtual_device_context__id"],
+        ["virtual_device_context", "virtual_device_context__name"],
+        ["name"],
+        ["rd"],
+    )
+
+    @classmethod
+    def setUpTestData(cls):
+        # Creating VRFDeviceAssignment instances manually until VRFFactory is enhanced to generate VRFDeviceAssignments
+        cls.vrfs = VRF.objects.all()
+        cls.devices = Device.objects.all()
+        cls.vdcs = VirtualDeviceContext.objects.all()
+        locations = Location.objects.filter(location_type__name="Campus")
+        cluster_type = ClusterType.objects.create(name="Test Cluster Type")
+        cluster = Cluster.objects.create(name="Cluster 1", cluster_type=cluster_type, location=locations[0])
+        vm_status = Status.objects.get_for_model(VirtualMachine).first()
+        vm_role = Role.objects.get_for_model(VirtualMachine).first()
+        cls.test_vm_1 = VirtualMachine.objects.create(
+            cluster=cluster,
+            name="VM 1",
+            role=vm_role,
+            status=vm_status,
+        )
+        cls.test_vm_2 = VirtualMachine.objects.create(
+            cluster=cluster,
+            name="VM 2",
+            role=vm_role,
+            status=vm_status,
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            device=cls.devices[0],
+            rd="65000:1",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            device=cls.devices[1],
+            rd="65000:2",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            virtual_machine=cls.test_vm_1,
+            rd="65000:3",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[1],
+            virtual_machine=cls.test_vm_2,
+            rd="65000:4",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            virtual_device_context=cls.vdcs[0],
+            name="VRFDeviceAssignment 1",
+            rd="65000:5",
+        )
+        VRFDeviceAssignment.objects.create(
+            vrf=cls.vrfs[0],
+            virtual_device_context=cls.vdcs[1],
+        )
+
+
 class VLANGroupTestCase(FilterTestCases.FilterTestCase):
     queryset = VLANGroup.objects.all()
     filterset = VLANGroupFilterSet

nautobot/ipam/tests/test_models.py

@@ -1301,6 +1301,22 @@ class TestIPAddress(ModelTestCases.BaseModelTestCase):
                 str(err.exception),
             )
 
+    def test_get_or_create_address_kwarg(self):
+        status = Status.objects.get(name="Active")
+        namespace = Namespace.objects.create(name="Test IPAddress get_or_create with address kwarg")
+        Prefix.objects.create(prefix="10.0.0.0/24", namespace=namespace, status=status)
+        ip_address, created = IPAddress.objects.get_or_create(
+            address="10.0.0.40/32", namespace=namespace, defaults={"status": status}
+        )
+        self.assertEqual(ip_address.host, "10.0.0.40")
+        self.assertEqual(ip_address.mask_length, 32)
+        self.assertTrue(created)
+        _, created = IPAddress.objects.get_or_create(
+            address="10.0.0.40/32", namespace=namespace, defaults={"status": status}
+        )
+        self.assertFalse(created)
+        self.assertTrue(IPAddress.objects.filter(address="10.0.0.40/32", parent__namespace=namespace).exists())
+
     def test_create_field_population(self):
         """Test that the various ways of creating an IPAddress result in correctly populated fields."""
         if self.namespace != get_default_namespace():

nautobot/ipam/tests/test_views.py

@@ -2,6 +2,7 @@ import datetime
 import random
 
 from django.contrib.contenttypes.models import ContentType
+from django.db.models import Count
 from django.test import override_settings
 from django.urls import reverse
 from django.utils.html import strip_tags
@@ -13,7 +14,15 @@ from nautobot.core.templatetags.helpers import hyperlinked_object, queryset_to_p
 from nautobot.core.testing import ModelViewTestCase, post_data, ViewTestCases
 from nautobot.core.testing.utils import extract_page_body
 from nautobot.core.utils.lookup import get_route_for_model
-from nautobot.dcim.models import Device, DeviceType, Interface, Location, LocationType, Manufacturer
+from nautobot.dcim.models import (
+    Device,
+    DeviceType,
+    Interface,
+    Location,
+    LocationType,
+    Manufacturer,
+    VirtualDeviceContext,
+)
 from nautobot.extras.choices import CustomFieldTypeChoices, RelationshipTypeChoices
 from nautobot.extras.models import (
     CustomField,
@@ -72,8 +81,9 @@ class VRFTestCase(ViewTestCases.PrimaryObjectViewTestCase):
     @classmethod
     def setUpTestData(cls):
         tenants = Tenant.objects.all()[:2]
-        namespace = Prefix.objects.first().namespace
+        namespace = Namespace.objects.annotate(prefix_count=Count("prefixes")).filter(prefix_count__gt=2).first()
         prefixes = Prefix.objects.filter(namespace=namespace)
+        vdcs = VirtualDeviceContext.objects.all()
         vrf_statuses = Status.objects.get_for_model(VRF)
 
         cls.form_data = {
@@ -85,6 +95,7 @@ class VRFTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "prefixes": [prefixes[1].id],
             "tags": [t.pk for t in Tag.objects.get_for_model(VRF)],
             "status": vrf_statuses.first().pk,
+            "virtual_device_contexts": [vdcs[0].id, vdcs[1].id],
         }
 
         cls.bulk_edit_data = {
@@ -94,6 +105,8 @@ class VRFTestCase(ViewTestCases.PrimaryObjectViewTestCase):
             "namespace": prefixes[0].namespace.id,
             "add_prefixes": [prefixes[0].id],
             "remove_prefixes": [prefixes[1].id],
+            "add_virtual_device_contexts": [vdcs[2].id, vdcs[3].id],
+            "remove_virtual_device_contexts": [vdcs[0].id],
         }
 
 

nautobot/ipam/urls.py

@@ -7,7 +7,6 @@ from . import views
 from .models import (
     IPAddress,
     Prefix,
-    RIR,
     Service,
     VLAN,
     VLANGroup,
@@ -20,28 +19,9 @@ router.register("ip-address-to-interface", views.IPAddressToInterfaceUIViewSet)
 router.register("namespaces", views.NamespaceUIViewSet)
 router.register("route-targets", views.RouteTargetUIViewSet)
 router.register("vrfs", views.VRFUIViewSet)
+router.register("rirs", views.RIRUIViewSet)
 
 urlpatterns = [
-    # RIRs
-    path("rirs/", views.RIRListView.as_view(), name="rir_list"),
-    path("rirs/add/", views.RIREditView.as_view(), name="rir_add"),
-    path("rirs/import/", views.RIRBulkImportView.as_view(), name="rir_import"),  # 3.0 TODO: remove, unused
-    path("rirs/delete/", views.RIRBulkDeleteView.as_view(), name="rir_bulk_delete"),
-    path("rirs/<uuid:pk>/", views.RIRView.as_view(), name="rir"),
-    path("rirs/<uuid:pk>/edit/", views.RIREditView.as_view(), name="rir_edit"),
-    path("rirs/<uuid:pk>/delete/", views.RIRDeleteView.as_view(), name="rir_delete"),
-    path(
-        "rirs/<uuid:pk>/changelog/",
-        ObjectChangeLogView.as_view(),
-        name="rir_changelog",
-        kwargs={"model": RIR},
-    ),
-    path(
-        "rirs/<uuid:pk>/notes/",
-        ObjectNotesView.as_view(),
-        name="rir_notes",
-        kwargs={"model": RIR},
-    ),
     # Namespaces
     path(
         "namespaces/<uuid:pk>/ip-addresses/",

nautobot/ipam/views.py

@@ -325,49 +325,32 @@ class RouteTargetUIViewSet(NautobotUIViewSet):
 #
 
 
-class RIRListView(generic.ObjectListView):
+class RIRUIViewSet(NautobotUIViewSet):
+    bulk_update_form_class = forms.RIRBulkEditForm
+    filterset_class = filters.RIRFilterSet
+    filterset_form_class = forms.RIRFilterForm
+    form_class = forms.RIRForm
     queryset = RIR.objects.all()
-    filterset = filters.RIRFilterSet
-    filterset_form = forms.RIRFilterForm
-    table = tables.RIRTable
+    serializer_class = serializers.RIRSerializer
+    table_class = tables.RIRTable
 
-
-class RIRView(generic.ObjectView):
-    queryset = RIR.objects.all()
-
-    def get_extra_context(self, request, instance):
-        # Prefixes
-        assigned_prefixes = Prefix.objects.restrict(request.user, "view").filter(rir=instance).select_related("tenant")
-
-        assigned_prefix_table = tables.PrefixTable(assigned_prefixes, hide_hierarchy_ui=True)
-
-        paginate = {
-            "paginator_class": EnhancedPaginator,
-            "per_page": get_paginate_count(request),
-        }
-        RequestConfig(request, paginate).configure(assigned_prefix_table)
-
-        return {"assigned_prefix_table": assigned_prefix_table, **super().get_extra_context(request, instance)}
-
-
-class RIREditView(generic.ObjectEditView):
-    queryset = RIR.objects.all()
-    model_form = forms.RIRForm
-
-
-class RIRDeleteView(generic.ObjectDeleteView):
-    queryset = RIR.objects.all()
-
-
-class RIRBulkImportView(generic.BulkImportView):  # 3.0 TODO: remove, unused
-    queryset = RIR.objects.all()
-    table = tables.RIRTable
-
-
-class RIRBulkDeleteView(generic.BulkDeleteView):
-    queryset = RIR.objects.all()
-    filterset = filters.RIRFilterSet
-    table = tables.RIRTable
+    object_detail_content = object_detail.ObjectDetailContent(
+        panels=(
+            object_detail.ObjectFieldsPanel(
+                section=SectionChoices.LEFT_HALF,
+                weight=100,
+                fields="__all__",
+            ),
+            object_detail.ObjectsTablePanel(
+                section=SectionChoices.FULL_WIDTH,
+                weight=100,
+                table_title="Assigned Prefixes",
+                table_class=tables.PrefixTable,
+                table_filter="rir",
+                hide_hierarchy_ui=True,
+            ),
+        ),
+    )
 
 
 #

nautobot/project-static/css/base.css

@@ -1022,3 +1022,14 @@ a.tile.clickable:visited {
     text-decoration: none;
     background-color: #646464;
 }
+
+/* Monaco Editor container */
+.editor-container {
+    display: flex;  /* Use flexbox for layout */
+    flex-direction: column;
+    flex: 1;  /* Allow container to grow */
+    min-height: 100px;
+    position: relative;  /* Required for Monaco's absolute positioning */
+    overflow: hidden;  /* Let Monaco handle scrolling */
+}
+

nautobot/project-static/css/dark.css

@@ -21,7 +21,8 @@ html[data-theme="dark"] .color-block,                     /* Colored choices, li
 html[data-theme="dark"] .select2-selection__choice,       /* Colored choices, like statuses */
 html[data-theme="dark"] #select2-id_color-results,        /* Colored choices, like statuses */
 html[data-theme="dark"] #select2-id_color-container,      /* Colored choices, like statuses */
-html[data-theme="dark"] .hljs {                           /* highlight.js maintains its own dark theme */
+html[data-theme="dark"] .hljs,                            /* highlight.js maintains its own dark theme */
+html[data-theme="dark"] .editor-container {               /* Monaco editor maintains its own dark theme */
   filter: invert(1) hue-rotate(180deg);
 }