nautobot 2.4.2__py3-none-any.whl → 2.4.4__py3-none-any.whl

nautobot/dcim/templates/dcim/poweroutlet.html

@@ -8,8 +8,13 @@
                 </div>
                 <table class="table table-hover panel-body attr-table">
                     <tr>
-                        <td>Device</td>
-                        <td>{{ object.device|hyperlinked_object }}</td>
+                        {% if object.device %}
+                            <td>Device</td>
+                            <td>{{ object.device|hyperlinked_object }}</td>
+                        {% else %}
+                            <td>Module</td>
+                            <td>{{ object.module|hyperlinked_object }}</td>
+                        {% endif %}
                     </tr>
                     <tr>
                         <td>Name</td>
@@ -57,8 +62,13 @@
                         </tr>
                         {% if object.connected_endpoint %}
                             <tr>
-                                <td>Device</td>
-                                <td>{{ object.connected_endpoint.device|hyperlinked_object }}</td>
+                                {% if object.connected_endpoint.device %}
+                                    <td>Device</td>
+                                    <td>{{ object.connected_endpoint.device|hyperlinked_object }}</td>
+                                {% else %}
+                                    <td>Module</td>
+                                    <td>{{ object.connected_endpoint.module|hyperlinked_object }}</td>
+                                {% endif %}
                             </tr>
                             <tr>
                                 <td>Power Port</td>

nautobot/dcim/templates/dcim/powerport.html

@@ -8,8 +8,13 @@
                 </div>
                 <table class="table table-hover panel-body attr-table">
                     <tr>
-                        <td>Device</td>
-                        <td>{{ object.device|hyperlinked_object }}</td>
+                        {% if object.device %}
+                            <td>Device</td>
+                            <td>{{ object.device|hyperlinked_object }}</td>
+                        {% else %}
+                            <td>Module</td>
+                            <td>{{ object.module|hyperlinked_object }}</td>
+                        {% endif %}
                     </tr>
                     <tr>
                         <td>Name</td>
@@ -57,8 +62,13 @@
                         </tr>
                         {% if object.connected_endpoint %}
                             <tr>
-                                <td>Device</td>
-                                <td>{{ object.connected_endpoint.device|hyperlinked_object }}</td>
+                                {% if object.connected_endpoint.device %}
+                                    <td>Device</td>
+                                    <td>{{ object.connected_endpoint.device|hyperlinked_object }}</td>
+                                {% else %}
+                                    <td>Module</td>
+                                    <td>{{ object.connected_endpoint.module|hyperlinked_object }}</td>
+                                {% endif %}
                             </tr>
                             <tr>
                                 <td>Power Outlet / Feed</td>

nautobot/dcim/templates/dcim/rearport.html

@@ -8,8 +8,13 @@
                 </div>
                 <table class="table table-hover panel-body attr-table">
                     <tr>
-                        <td>Device</td>
-                        <td>{{ object.device|hyperlinked_object }}</td>
+                        {% if object.device %}
+                            <td>Device</td>
+                            <td>{{ object.device|hyperlinked_object }}</td>
+                        {% else %}
+                            <td>Module</td>
+                            <td>{{ object.module|hyperlinked_object }}</td>
+                        {% endif %}
                     </tr>
                     <tr>
                         <td>Name</td>

nautobot/dcim/templates/dcim/virtualdevicecontext_retrieve.html

@@ -4,65 +4,3 @@
 {% block extra_breadcrumbs %}
     <li><a href="{% url 'dcim:device' pk=object.device.pk %}">{{ object.device }}</a></li>
 {% endblock extra_breadcrumbs %}
-
-
-{% block content_left_page %}
-    <div class="panel panel-default">
-        <div class="panel-heading">
-            <strong>Virtual Device Context</strong>
-        </div>
-        <table class="table table-hover panel-body attr-table">
-            <tr>
-                <td>Name</td>
-                <td>
-                    {{ object.name }}
-                </td>
-            </tr>
-            <tr>
-                <td>Identifier</td>
-                <td>
-                    {{ object.identifier }}
-                </td>
-            </tr>
-            <tr>
-                <td>Role</td>
-                <td>
-                    {{ object.role| hyperlinked_object_with_color }}
-                </td>
-            </tr>
-            <tr>
-                <td>Status</td>
-                <td>
-                    {{ object.status| hyperlinked_object_with_color }}
-                </td>
-            </tr>
-            <tr>
-                <td>Device</td>
-                <td>
-                    {{ object.device|hyperlinked_object }}
-                </td>
-            </tr>
-            <tr>
-                <td>Primary IPv4</td>
-                <td>
-                    {{ object.primary_ip4|hyperlinked_object }}
-                </td>
-            </tr>
-            <tr>
-                <td>Primary IPv6</td>
-                <td>
-                    {{ object.primary_ip6|hyperlinked_object }}
-                </td>
-            </tr>
-            {% include 'inc/tenant_table_row.html' %}
-            <tr>
-                <td>Description</td>
-                <td>{{ object.description|placeholder }}</td>
-            </tr>
-        </table>
-    </div>
-{% endblock content_left_page %}
-
-{% block content_full_width_page %}
-    {% include 'panel_table.html' with table=interfaces_table heading="Interfaces" %}
-{% endblock content_full_width_page %}

nautobot/dcim/templates/dcim/virtualdevicecontext_update.html

@@ -23,6 +23,12 @@
             {% endif %}
         </div>
     </div>
+    <div class="panel panel-default">
+        <div class="panel-heading"><strong>VRF Assignments</strong></div>
+        <div class="panel-body">
+            {% render_field form.vrfs %}
+        </div>
+    </div>
     {% include 'inc/tenancy_form_panel.html' %}
     {% include 'inc/extras_features_edit_form_fields.html' %}
 {% endblock %}

nautobot/dcim/tests/integration/test_fileinputpicker.py

@@ -0,0 +1,87 @@
+from django.urls import reverse
+
+from nautobot.core.testing.integration import SeleniumTestCase, WebDriverWait
+from nautobot.dcim.models import Location, LocationType
+from nautobot.extras.models import Job, Status
+
+
+class ClearableFileInputTestCase(SeleniumTestCase):
+    def setUp(self):
+        super().setUp()
+        self.user.is_superuser = True
+        self.user.save()
+        self.login(self.user.username, self.password)
+
+    def tearDown(self):
+        self.logout()
+        super().tearDown()
+
+    def _assert_file_picker(self, uri_to_visit: str, page_loaded_confirmation: str, file_input_selector_id: str):
+        """
+        Ensure clearable input file type has working clear and info display.
+        """
+        self.browser.visit(f"{self.live_server_url}{uri_to_visit}")
+        WebDriverWait(self.browser, 10).until(lambda driver: driver.is_text_present(page_loaded_confirmation))
+
+        # Find the first file input button and scroll to it
+        front_image_button = self.browser.find_by_css("span.group-span-filestyle.input-group-btn").first
+        front_image_button.scroll_to()
+
+        # cancel button is NOT visible initially
+        self.assertFalse(self.browser.find_by_css("button.clear-button").first.visible)
+
+        # Test file text changes after selecting a file
+        file_selection_indicator_css = "div.bootstrap-filestyle input[type='text'].form-control"
+        self.assertEqual(self.browser.find_by_css(file_selection_indicator_css).first.value, "")
+        front_image_file_input = self.browser.find_by_id(file_input_selector_id).first
+        front_image_file_input.value = "/dev/null"
+        self.assertEqual(self.browser.find_by_css(file_selection_indicator_css).first.value, "null")
+
+        # clear button is now visible
+        clear_button = self.browser.find_by_css("button.clear-button").first
+        self.assertTrue(clear_button.visible)
+
+        # clicking clearbutton should hide the button, and wipe the file input value
+        clear_button.click()
+        self.assertFalse(clear_button.visible)
+        self.assertEqual(front_image_file_input.value, "")
+
+    def test_add_device_page(self):
+        """
+        Confirm device type add page input is working correctly.
+        """
+        self._assert_file_picker(
+            uri_to_visit=reverse("dcim:devicetype_add"),
+            page_loaded_confirmation="Device Type",
+            file_input_selector_id="id_front_image",
+        )
+
+    def test_job_runner_page(self):
+        """
+        Confirm job run page file input is working correctly.
+        """
+        example_job = Job.objects.get(name="Example File Input/Output job").pk
+        job_example_file_uri = reverse("extras:job_run", kwargs={"pk": example_job})
+        self._assert_file_picker(
+            uri_to_visit=job_example_file_uri,
+            page_loaded_confirmation="Example File",
+            file_input_selector_id="id_input_file",
+        )
+
+    def test_location_image_attachment_view(self):
+        """
+        Confirm location image attachment page is working correctly.
+        """
+        location_type, _ = LocationType.objects.get_or_create(name="Campus")
+        location_status = Status.objects.get_for_model(Location).first()
+        location, _ = Location.objects.get_or_create(
+            name="Test Location 1", location_type=location_type, status=location_status
+        )
+        location_image_attach_uri = reverse(
+            "dcim:location_add_image", kwargs={"object_id": location.id, "model": Location}
+        )
+        self._assert_file_picker(
+            uri_to_visit=location_image_attach_uri,
+            page_loaded_confirmation="Image attachment",
+            file_input_selector_id="id_image",
+        )

nautobot/dcim/tests/test_api.py

@@ -1716,6 +1716,182 @@ class DeviceTest(APIViewTestCases.APIViewTestCase):
         )
         self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
 
+    def _parent_device_test_data(self):
+        location = Location.objects.filter(location_type=LocationType.objects.get(name="Campus")).first()
+        device_status = Status.objects.get_for_model(Device).first()
+        device_role = Role.objects.get_for_model(Device).first()
+        device_type = DeviceType.objects.first()
+
+        device_type_parent = DeviceType.objects.create(
+            manufacturer=device_type.manufacturer,
+            model=f"{device_type.model} Parent",
+            u_height=device_type.u_height,
+            subdevice_role=SubdeviceRoleChoices.ROLE_PARENT,
+        )
+        device_type_child = DeviceType.objects.create(
+            manufacturer=device_type.manufacturer,
+            model=f"{device_type.model} Child",
+            u_height=device_type.u_height,
+            subdevice_role=SubdeviceRoleChoices.ROLE_CHILD,
+        )
+
+        parent_device = Device.objects.create(
+            device_type=device_type_parent,
+            role=device_role,
+            status=device_status,
+            name="Device Parent",
+            location=location,
+        )
+        device_bay_1 = DeviceBay.objects.create(name="db1", device_id=parent_device.pk)
+        device_bay_2 = DeviceBay.objects.create(name="db2", device_id=parent_device.pk)
+
+        return parent_device, device_bay_1, device_bay_2, device_type_child
+
+    def test_creating_device_with_parent_bay(self):
+        # Create test data
+        parent_device, device_bay_1, device_bay_2, device_type_child = self._parent_device_test_data()
+
+        self.add_permissions("dcim.add_device")
+        url = reverse("dcim-api:device-list")
+
+        # Test creating device with parent bay by device bay data
+        data = {
+            "device_type": device_type_child.pk,
+            "role": parent_device.role.pk,
+            "location": parent_device.location.pk,
+            "name": "Device parent bay test #1",
+            "status": parent_device.status.pk,
+            "parent_bay": {"device": {"name": parent_device.name}, "name": device_bay_1.name},
+        }
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+
+        created_device = Device.objects.get(name="Device parent bay test #1")
+        self.assertEqual(created_device.parent_bay.pk, device_bay_1.pk)
+
+        # Test creating device with parent bay by device_bay.pk
+        data = {
+            "device_type": device_type_child.pk,
+            "role": parent_device.role.pk,
+            "location": parent_device.location.pk,
+            "name": "Device parent bay test #2",
+            "status": parent_device.status.pk,
+            "parent_bay": device_bay_2.pk,
+        }
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_201_CREATED)
+
+        created_device = Device.objects.get(name="Device parent bay test #2")
+        self.assertEqual(created_device.parent_bay.pk, device_bay_2.pk)
+
+        # Test creating device with parent bay already taken
+        data = {
+            "device_type": device_type_child.pk,
+            "role": parent_device.role.pk,
+            "location": parent_device.location.pk,
+            "name": "Device parent bay test #3",
+            "status": parent_device.status.pk,
+            "parent_bay": device_bay_1.pk,
+        }
+
+        response = self.client.post(url, data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn("Cannot install device; parent bay is already taken", response.content.decode(response.charset))
+
+        # Assert that on the #1 device, parent bay stayed the same
+        old_device = Device.objects.get(name="Device parent bay test #1")
+        self.assertEqual(old_device.parent_bay.pk, device_bay_1.pk)
+
+    def test_update_device_with_parent_bay(self):
+        # Create test data
+        parent_device, device_bay_1, device_bay_2, device_type_child = self._parent_device_test_data()
+
+        self.add_permissions("dcim.change_device")
+
+        child_device = Device.objects.create(
+            device_type=device_type_child,
+            role=parent_device.role,
+            location=parent_device.location,
+            name="Device parent bay test #4",
+            status=parent_device.status,
+        )
+        # Test setting parent bay during the update
+        patch_data = {"parent_bay": device_bay_1.pk}
+        response = self.client.patch(self._get_detail_url(child_device), patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        updated_device = Device.objects.get(name="Device parent bay test #4")
+        self.assertEqual(updated_device.parent_bay.pk, device_bay_1.pk)
+
+        # Changing the parent bay is not allowed without removing it first
+        patch_data = {"parent_bay": device_bay_2.pk}
+        response = self.client.patch(self._get_detail_url(child_device), patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_400_BAD_REQUEST)
+        self.assertIn(
+            f"Cannot install the specified device; device is already installed in {device_bay_1.name}",
+            response.content.decode(response.charset),
+        )
+
+        # Assert that parent bay stayed the same
+        updated_device = Device.objects.get(name="Device parent bay test #4")
+        self.assertEqual(updated_device.parent_bay.pk, device_bay_1.pk)
+
+    def test_reassign_device_to_parent_bay(self):
+        # Create test data
+        parent_device, device_bay_1, device_bay_2, device_type_child = self._parent_device_test_data()
+        device_name = "Device parent bay test #5"
+        child_device = Device.objects.create(
+            device_type=device_type_child,
+            role=parent_device.role,
+            location=parent_device.location,
+            name=device_name,
+            status=parent_device.status,
+        )
+        device_bay_1.installed_device = child_device
+        device_bay_1.save()
+
+        self.add_permissions("dcim.change_device", "dcim.view_device", "dcim.change_devicebay")
+        child_device_detail_url = self._get_detail_url(child_device)
+
+        response = self.client.get(child_device_detail_url, **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+        self.assertEqual(response.json()["parent_bay"]["id"], str(device_bay_1.pk))
+
+        # Test unassigning parent bay
+        patch_data = {"parent_bay": None}
+        response = self.client.patch(child_device_detail_url, patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        child_device.refresh_from_db()
+        with self.assertRaises(DeviceBay.DoesNotExist):
+            child_device.parent_bay
+
+        # And assign it again
+        patch_data = {"parent_bay": device_bay_2.pk}
+        response = self.client.patch(child_device_detail_url, patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        child_device.refresh_from_db()
+        self.assertEqual(child_device.parent_bay.pk, device_bay_2.pk)
+
+        # Unassign it through device bay
+        patch_data = {"installed_device": None}
+        response = self.client.patch(self._get_detail_url(device_bay_2), patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        child_device.refresh_from_db()
+        self.assertFalse(hasattr(child_device, "parent_bay"))
+
+        # And assign through device bay
+        patch_data = {"installed_device": child_device.pk}
+        response = self.client.patch(self._get_detail_url(device_bay_1), patch_data, format="json", **self.header)
+        self.assertHttpStatus(response, status.HTTP_200_OK)
+
+        child_device.refresh_from_db()
+        self.assertEqual(child_device.parent_bay.pk, device_bay_1.pk)
+
 
 class ModuleTestCase(APIViewTestCases.APIViewTestCase):
     model = Module

nautobot/dcim/tests/test_filters.py

@@ -157,6 +157,8 @@ def common_test_data(cls):
     cls.loc0 = loc0
     cls.loc1 = loc1
     cls.nested_loc = nested_loc
+    cls.loc2 = loc2
+    cls.loc3 = loc3
 
     provider = Provider.objects.first()
     circuit_type = CircuitType.objects.first()
@@ -1150,6 +1152,24 @@ class RackGroupTestCase(FilterTestCases.FilterTestCase):
             name="Rack Group 4",
             location=cls.loc1,
         )
+        RackGroup.objects.create(
+            name="Rack Group 5",
+            location=cls.loc2,
+            description="C",
+        )
+        RackGroup.objects.create(
+            name="Rack Group 6",
+            location=cls.loc2,
+        )
+        RackGroup.objects.create(
+            name="Rack Group 7",
+            location=cls.loc3,
+            description="C",
+        )
+        RackGroup.objects.create(
+            name="Rack Group 8",
+            location=cls.loc3,
+        )
 
     def test_children(self):
         child_groups = RackGroup.objects.filter(name__startswith="Child").filter(parent__isnull=False)[:2]
@@ -1161,6 +1181,24 @@ class RackGroupTestCase(FilterTestCases.FilterTestCase):
             params = {"children": [rack_group_4.pk, rack_group_4.pk]}
             self.assertFalse(self.filterset(params, self.queryset).qs.exists())
 
+    def test_ancestors(self):
+        with self.subTest():
+            pk_list = []
+            parent_locations = self.loc3.ancestors(include_self=True)
+            pk_list.extend([v.pk for v in parent_locations])
+            params = Q(location__pk__in=pk_list)
+            expected_queryset = RackGroup.objects.filter(params)
+            params = {"ancestors": [self.loc3.pk]}
+            self.assertQuerysetEqualAndNotEmpty(self.filterset(params, self.queryset).qs, expected_queryset)
+        with self.subTest():
+            pk_list = []
+            parent_locations = self.loc2.ancestors(include_self=True)
+            pk_list.extend([v.pk for v in parent_locations])
+            params = Q(location__pk__in=pk_list)
+            expected_queryset = RackGroup.objects.filter(params)
+            params = {"ancestors": [self.loc2.pk]}
+            self.assertQuerysetEqualAndNotEmpty(self.filterset(params, self.queryset).qs, expected_queryset)
+
 
 class RackTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFilterTestCaseMixin):
     queryset = Rack.objects.all()
@@ -4188,12 +4226,13 @@ class InterfaceVDCAssignmentTestCase(FilterTestCases.FilterTestCase):
 
     @classmethod
     def setUpTestData(cls):
-        device = Device.objects.first()
+        device_1 = Device.objects.first()
+        device_2 = Device.objects.last()
         vdc_status = Status.objects.get_for_model(VirtualDeviceContext)[0]
         interface_status = Status.objects.get_for_model(Interface)[0]
         interfaces = [
             Interface.objects.create(
-                device=device,
+                device=device_1,
                 type=InterfaceTypeChoices.TYPE_1GE_FIXED,
                 name=f"Interface 00{idx}",
                 status=interface_status,
@@ -4202,7 +4241,7 @@ class InterfaceVDCAssignmentTestCase(FilterTestCases.FilterTestCase):
         ]
         vdcs = [
             VirtualDeviceContext.objects.create(
-                device=device,
+                device=device_1,
                 status=vdc_status,
                 identifier=200 + idx,
                 name=f"Test VDC {idx}",
@@ -4213,3 +4252,17 @@ class InterfaceVDCAssignmentTestCase(FilterTestCases.FilterTestCase):
         InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[1], interface=interfaces[0])
         InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[1], interface=interfaces[1])
         InterfaceVDCAssignment.objects.create(virtual_device_context=vdcs[2], interface=interfaces[2])
+        InterfaceVDCAssignment.objects.create(
+            virtual_device_context=VirtualDeviceContext.objects.create(
+                device=device_2,
+                status=vdc_status,
+                identifier=200,
+                name="Test VDC 0",
+            ),
+            interface=Interface.objects.create(
+                device=device_2,
+                type=InterfaceTypeChoices.TYPE_1GE_FIXED,
+                name="Interface 000",
+                status=interface_status,
+            ),
+        )

nautobot/dcim/tests/test_models.py

@@ -1166,6 +1166,19 @@ class LocationTypeTestCase(TestCase):
         child_loc.delete()
         child.validated_save()
 
+    def test_removing_content_type(self):
+        """Validation check to prevent removing an in-use content type from a LocationType."""
+
+        location_type = LocationType.objects.get(name="Campus")
+        device_ct = ContentType.objects.get_for_model(Device)
+
+        with self.assertRaises(ValidationError) as cm:
+            location_type.content_types.remove(device_ct)
+        self.assertIn(
+            f"Cannot remove the content type {device_ct} as currently at least one device is associated to a location",
+            str(cm.exception),
+        )
+
 
 class LocationTestCase(ModelTestCases.BaseModelTestCase):
     model = Location
@@ -1895,6 +1908,33 @@ class DeviceTestCase(ModelTestCases.BaseModelTestCase):
         parent_device.rack = rack
         parent_device.save()
 
+        # Test assigning a rack in the child location of the parent device location
+        location_status = Status.objects.get_for_model(Location).first()
+        child_location = Location.objects.create(
+            name="Child Location 1",
+            location_type=self.location_type_3,
+            status=location_status,
+            parent=parent_device.location,
+        )
+        child_rack = Rack.objects.create(name="Rack 2", location=child_location, status=self.device_status)
+        parent_device.rack = child_rack
+        parent_device.validated_save()
+
+        # Test assigning a rack outside the child locations of the parent device location
+        new_location = Location.objects.create(
+            name="New Location 1",
+            status=location_status,
+            location_type=self.location_type_3,
+        )
+        invalid_rack = Rack.objects.create(name="Rack 3", location=new_location, status=self.device_status)
+        parent_device.rack = invalid_rack
+        with self.assertRaises(ValidationError) as cm:
+            parent_device.validated_save()
+        self.assertIn(
+            f'Rack "{invalid_rack}" does not belong to location "{parent_device.location}" and its descendants.',
+            str(cm.exception),
+        )
+
         child_mtime_after_parent_rack_update_save = str(Device.objects.get(name="Child Device 1").last_updated)
 
         self.assertNotEqual(child_mtime_after_parent_noop_save, child_mtime_after_parent_rack_update_save)
@@ -2790,7 +2830,7 @@ class ControllerTestCase(ModelTestCases.BaseModelTestCase):
             controller.validated_save()
         self.assertEqual(
             error.exception.message_dict["location"][0],
-            f'Devices may not associate to locations of type "{location_type}".',
+            f'Controllers may not associate to locations of type "{location_type}".',
         )
 
 

nautobot/dcim/views.py

@@ -61,7 +61,7 @@ from nautobot.dcim.utils import get_all_network_driver_mappings, get_network_dri
 from nautobot.extras.models import Contact, ContactAssociation, Role, Status, Team
 from nautobot.extras.views import ObjectChangeLogView, ObjectConfigContextView, ObjectDynamicGroupsView
 from nautobot.ipam.models import IPAddress, Prefix, Service, VLAN
-from nautobot.ipam.tables import InterfaceIPAddressTable, InterfaceVLANTable, VRFDeviceAssignmentTable
+from nautobot.ipam.tables import InterfaceIPAddressTable, InterfaceVLANTable, VRFDeviceAssignmentTable, VRFTable
 from nautobot.virtualization.models import VirtualMachine
 from nautobot.wireless.forms import ControllerManagedDeviceGroupWirelessNetworkFormSet
 from nautobot.wireless.models import (
@@ -1922,7 +1922,7 @@ class DeviceView(generic.ObjectView):
 
         # VRF assignments
         vrf_assignments = instance.vrf_assignments.restrict(request.user, "view")
-        vrf_table = VRFDeviceAssignmentTable(vrf_assignments, exclude=("virtual_machine", "device"))
+        vrf_table = VRFDeviceAssignmentTable(vrf_assignments)
 
         # Software images
         if instance.software_version is not None:
@@ -4513,15 +4513,25 @@ class VirtualDeviceContextUIViewSet(NautobotUIViewSet):
     queryset = VirtualDeviceContext.objects.all()
     serializer_class = serializers.VirtualDeviceContextSerializer
     table_class = tables.VirtualDeviceContextTable
-
-    def get_extra_context(self, request, instance):
-        if self.action == "retrieve":
-            interfaces_table = tables.InterfaceTable(
-                instance.interfaces.restrict(request.user, "view"), orderable=False, exclude=("device",)
-            )
-
-            return {
-                "interfaces_table": interfaces_table,
-                **super().get_extra_context(request, instance),
-            }
-        return super().get_extra_context(request, instance)
+    object_detail_content = object_detail.ObjectDetailContent(
+        panels=(
+            object_detail.ObjectFieldsPanel(
+                section=SectionChoices.LEFT_HALF,
+                weight=100,
+                fields="__all__",
+            ),
+            object_detail.ObjectsTablePanel(
+                weight=200,
+                table_class=tables.InterfaceTable,
+                table_attribute="interfaces",
+                section=SectionChoices.FULL_WIDTH,
+                exclude_columns=["device"],
+            ),
+            object_detail.ObjectsTablePanel(
+                weight=300,
+                table_class=VRFTable,
+                table_attribute="vrfs",
+                section=SectionChoices.FULL_WIDTH,
+            ),
+        ),
+    )

nautobot/extras/api/mixins.py

@@ -37,7 +37,7 @@ class TaggedModelSerializerMixin(BaseModelSerializer):
 
     def _save_tags(self, instance, tags):
         if tags:
-            instance.tags.set([t.name for t in tags])
+            instance.tags.set(tags)
         else:
             instance.tags.clear()