nautobot 2.3.7__py3-none-any.whl → 2.3.9__py3-none-any.whl

nautobot/extras/plugins/views.py

@@ -30,6 +30,21 @@ class InstalledAppsView(GenericView):
         data = []
         for app in apps.get_app_configs():
             if app.name in settings.PLUGINS:
+                try:
+                    reverse(app.home_view_name)
+                    home_url = app.home_view_name
+                except NoReverseMatch:
+                    home_url = None
+                try:
+                    reverse(app.config_view_name)
+                    config_url = app.config_view_name
+                except NoReverseMatch:
+                    config_url = None
+                try:
+                    reverse(app.docs_view_name)
+                    docs_url = app.docs_view_name
+                except NoReverseMatch:
+                    docs_url = None
                 data.append(
                     {
                         "name": app.verbose_name,
@@ -40,9 +55,9 @@ class InstalledAppsView(GenericView):
                         "description": app.description,
                         "version": app.version,
                         "actions": {
-                            "home": app.home_view_name,
-                            "configure": app.config_view_name,
-                            "docs": app.docs_view_name,
+                            "home": home_url,
+                            "configure": config_url,
+                            "docs": docs_url,
                         },
                     }
                 )

nautobot/extras/templates/extras/plugin_detail.html

@@ -277,6 +277,39 @@
                                     {% endif %}
                                 </td>
                             </tr>
+                            <tr>
+                                <td>Table Extensions</td>
+                                <td>
+                                    {% if features.table_extensions %}
+                                        {% if features.table_extensions.columns %}
+                                        <b>Custom Columns</b>
+                                        <ul class="list-unstyled">
+                                            {% for column in features.table_extensions.columns %}
+                                                <li><code>{{ column }}</code></li>
+                                            {% endfor %}
+                                        </ul>
+                                        {% endif %}
+                                        {% if features.table_extensions.add_to_default_columns %}
+                                        <b>Additional Default Columns</b>
+                                        <ul class="list-unstyled">
+                                            {% for column in features.table_extensions.add_to_default_columns %}
+                                                <li><code>{{ column }}</code></li>
+                                            {% endfor %}
+                                        </ul>
+                                        {% endif %}
+                                        {% if features.table_extensions.remove_from_default_columns %}
+                                        <b>Remove from Default Columns</b>
+                                        <ul class="list-unstyled">
+                                            {% for column in features.table_extensions.remove_from_default_columns %}
+                                                <li><code>{{ column }}</code></li>
+                                            {% endfor %}
+                                        </ul>
+                                        {% endif %}
+                                    {% else %}
+                                        {% include 'utilities/render_boolean.html' with value=features.table_extensions %}
+                                    {% endif %}
+                                </td>
+                            </tr>
                             <tr>
                                 <td>Views/URLs</td>
                                 <td>

nautobot/extras/tests/test_context_managers.py

@@ -5,7 +5,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.test import TestCase
 
 from nautobot.core.celery import app
-from nautobot.core.testing import TransactionTestCase
+from nautobot.core.testing import get_job_class_and_model, TransactionTestCase
 from nautobot.core.utils.lookup import get_changes_for_model
 from nautobot.dcim.models import (
     DeviceType,
@@ -22,7 +22,7 @@ from nautobot.extras.context_managers import (
     deferred_change_logging_for_bulk_operation,
     web_request_context,
 )
-from nautobot.extras.models import Status, Webhook
+from nautobot.extras.models import JobHook, Status, Webhook
 from nautobot.extras.utils import bulk_delete_with_bulk_change_logging
 
 # Use the proper swappable User model
@@ -74,7 +74,7 @@ class WebRequestContextTestCase(TestCase):
         self.assertEqual(oc_list[0].changed_object, location)
         self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_CREATE)
 
-    @mock.patch("nautobot.extras.jobs.enqueue_job_hooks")
+    @mock.patch("nautobot.extras.jobs.enqueue_job_hooks", return_value=True)
     @mock.patch("nautobot.extras.context_managers.enqueue_webhooks")
     def test_create_then_delete(self, mock_enqueue_webhooks, mock_enqueue_job_hooks):
         """Test that a create followed by a delete is logged as two changes"""
@@ -88,11 +88,13 @@ class WebRequestContextTestCase(TestCase):
 
         location = Location.objects.filter(pk=location_pk)
         self.assertFalse(location.exists())
-        oc_list = get_changes_for_model(Location).filter(changed_object_id=location_pk)
+        oc_list = get_changes_for_model(Location).filter(changed_object_id=location_pk).order_by("time")
         self.assertEqual(len(oc_list), 2)
-        self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_DELETE)
-        self.assertEqual(oc_list[1].action, ObjectChangeActionChoices.ACTION_CREATE)
-        mock_enqueue_job_hooks.assert_has_calls([mock.call(oc_list[0]), mock.call(oc_list[1])])
+        self.assertEqual(oc_list[0].action, ObjectChangeActionChoices.ACTION_CREATE)
+        self.assertEqual(oc_list[1].action, ObjectChangeActionChoices.ACTION_DELETE)
+        mock_enqueue_job_hooks.assert_has_calls(
+            [mock.call(oc_list[0], may_reload_jobs=True), mock.call(oc_list[1], may_reload_jobs=False)],
+        )
         mock_enqueue_webhooks.assert_has_calls([mock.call(oc_list[0]), mock.call(oc_list[1])])
 
     def test_update_then_delete(self):
@@ -307,6 +309,13 @@ class BulkEditDeleteChangeLogging(TestCase):
             for i in range(1, 4)
         ]
         Location.objects.bulk_create(locations)
+        # Create a JobHook that applies to Locations
+        _, job_model = get_job_class_and_model("job_hook_receiver", "TestJobHookReceiverLog")
+        mock_import_jobs.assert_called_once()
+        mock_import_jobs.reset_mock()
+        job_hook = JobHook.objects.create(name="JobHookTest", type_update=True, job=job_model)
+        job_hook.content_types.set([ContentType.objects.get_for_model(Location)])
+
         pk_list = []
         with web_request_context(self.user):
             with deferred_change_logging_for_bulk_operation():

nautobot/extras/tests/test_datasources.py

@@ -412,7 +412,7 @@ class GitTest(TransactionTestCase):
 
     def test_pull_git_repository_and_refresh_data_with_bad_data(self):
         """
-        The test_pull_git_repository_and_refresh_data job should gracefully handle bad data in the Git repository
+        The test_pull_git_repository_and_refresh_data job should gracefully handle bad data in the Git repository.
         """
         with tempfile.TemporaryDirectory() as tempdir:
             with self.settings(GIT_ROOT=tempdir):
@@ -433,6 +433,18 @@ class GitTest(TransactionTestCase):
                     job_result.result,
                 )
 
+                # Due to transaction rollback on failure, the database should still/again match the pre-sync state, of
+                # no records owned by the repository.
+                self.assertFalse(ConfigContextSchema.objects.filter(owner_object_id=self.repo.id).exists())
+                self.assertFalse(ConfigContext.objects.filter(owner_object_id=self.repo.id).exists())
+                self.assertFalse(ExportTemplate.objects.filter(owner_object_id=self.repo.id).exists())
+                self.assertFalse(Job.objects.filter(module_name__startswith=f"{self.repo.slug}.").exists())
+                device = Device.objects.get(name=self.device.name)
+                self.assertIsNone(device.local_config_context_data)
+                self.assertIsNone(device.local_config_context_data_owner)
+                self.repo.refresh_from_db()
+                self.assertEqual(self.repo.current_head, "")
+
                 # Check for specific log messages
                 log_entries = JobLogEntry.objects.filter(job_result=job_result)
                 warning_logs = log_entries.filter(log_level=LogLevelChoices.LOG_WARNING)
@@ -592,6 +604,81 @@ class GitTest(TransactionTestCase):
 
                 self.assert_job_exists(installed=False)
 
+    def test_git_repository_sync_rollback(self):
+        """
+        Once a "known-good" sync state is achieved, resync to a new "bad" head commit should fail and be rolled back.
+        """
+        with tempfile.TemporaryDirectory() as tempdir:
+            with self.settings(GIT_ROOT=tempdir):
+                # Initially have a successful sync to a good commit that provides data
+                self.repo.branch = "valid-files"  # actually a tag
+                self.repo.save()
+                job_model = GitRepositorySync().job_model
+                job_result = run_job_for_testing(job=job_model, repository=self.repo.pk)
+                job_result.refresh_from_db()
+                self.assertEqual(
+                    job_result.status,
+                    JobResultStatusChoices.STATUS_SUCCESS,
+                    (job_result.traceback, list(job_result.job_log_entries.values_list("message", flat=True))),
+                )
+
+                self.assert_explicit_config_context_exists("Frobozz 1000 NTP servers")
+                self.assert_implicit_config_context_exists("Location context")
+                self.assert_config_context_schema_record_exists("Config Context Schema 1")
+                self.assert_device_exists(self.device.name)
+                self.assert_export_template_device("template.j2")
+                self.assert_export_template_html_exist("template2.html")
+                self.assert_export_template_vlan_exists("template.j2")
+                self.assert_job_exists(name="MyJob")
+                self.assert_job_exists(name="MyJobButtonReceiver")
+                self.assert_job_exists(name="MyJobHookReceiver")
+
+                # Create JobButton and JobHook
+                JobButton.objects.create(
+                    name="MyJobButton", enabled=True, text="Click me", job=Job.objects.get(name="MyJobButtonReceiver")
+                )
+                JobHook.objects.create(name="MyJobHook", enabled=True, job=Job.objects.get(name="MyJobHookReceiver"))
+
+                self.repo.refresh_from_db()
+                self.assertNotEqual(self.repo.current_head, "")
+                good_current_head = self.repo.current_head
+
+                # Now change to the `main` branch (which includes the current commit, followed by a "bad" commit)
+                self.repo.branch = "main"
+                self.repo.save()
+
+                # Resync, attempting and failing to update to the new commit
+                job_result = run_job_for_testing(job=job_model, repository=self.repo.pk)
+                job_result.refresh_from_db()
+                self.assertEqual(
+                    job_result.status,
+                    JobResultStatusChoices.STATUS_FAILURE,
+                    job_result.result,
+                )
+                log_entries = JobLogEntry.objects.filter(job_result=job_result)
+
+                # Assert database changes were rolled back
+                self.repo.refresh_from_db()
+                try:
+                    self.assertEqual(self.repo.current_head, good_current_head)
+                    self.assert_explicit_config_context_exists("Frobozz 1000 NTP servers")
+                    self.assert_implicit_config_context_exists("Location context")
+                    self.assert_config_context_schema_record_exists("Config Context Schema 1")
+                    self.assert_device_exists(self.device.name)
+                    self.assert_export_template_device("template.j2")
+                    self.assert_export_template_html_exist("template2.html")
+                    self.assert_export_template_vlan_exists("template.j2")
+                    self.assert_job_exists(name="MyJob")
+                    self.assert_job_exists(name="MyJobButtonReceiver")
+                    self.assert_job_exists(name="MyJobHookReceiver")
+                    self.assertTrue(JobButton.objects.get(name="MyJobButton").enabled)
+                    self.assertTrue(JobHook.objects.get(name="MyJobHook").enabled)
+                except Exception:
+                    for log in log_entries:
+                        print(log.message)
+                    print(job_result.traceback)
+                    raise
+
     def test_git_dry_run(self):
         with tempfile.TemporaryDirectory() as tempdir:
             with self.settings(GIT_ROOT=tempdir):

nautobot/extras/tests/test_dynamicgroups.py

@@ -304,6 +304,10 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         sg.add_members(Prefix.objects.filter(ip_version=4))
         self.assertIsInstance(sg.members, PrefixQuerySet)
         self.assertQuerysetEqualAndNotEmpty(sg.members, Prefix.objects.filter(ip_version=4))
+        # test cumulative construction and alternate code path
+        sg.add_members(list(Prefix.objects.filter(ip_version=6)))
+        self.assertQuerysetEqualAndNotEmpty(sg.members, Prefix.objects.all())
+        self.assertEqual(sg.static_group_associations.count(), Prefix.objects.all().count())
         # test duplicate objects aren't re-added
         sg.add_members(Prefix.objects.all())
         self.assertQuerysetEqualAndNotEmpty(sg.members, Prefix.objects.all())
@@ -321,10 +325,18 @@ class DynamicGroupModelTest(DynamicGroupTestBase):  # TODO: BaseModelTestCase mi
         sg.remove_members(list(Prefix.objects.filter(ip_version=4)))
         self.assertQuerysetEqualAndNotEmpty(sg.members, Prefix.objects.filter(ip_version=6))
         self.assertEqual(sg.static_group_associations.count(), Prefix.objects.filter(ip_version=6).count())
+        # test cumulative removal and alternate code path
+        sg.remove_members(list(Prefix.objects.filter(ip_version=6)))
+        self.assertQuerysetEqual(sg.members, Prefix.objects.none())
+        self.assertEqual(sg.static_group_associations.count(), 0)
 
         # test property setter
         sg.members = Prefix.objects.filter(ip_version=4)
         self.assertQuerysetEqualAndNotEmpty(sg.members, Prefix.objects.filter(ip_version=4))
+        sg.members = Prefix.objects.filter(ip_version=6)
+        self.assertQuerysetEqualAndNotEmpty(sg.members, Prefix.objects.filter(ip_version=6))
+        sg.members = list(Prefix.objects.filter(ip_version=4))
+        self.assertQuerysetEqualAndNotEmpty(sg.members, Prefix.objects.filter(ip_version=4))
         sg.members = list(Prefix.objects.filter(ip_version=6))
         self.assertQuerysetEqualAndNotEmpty(sg.members, Prefix.objects.filter(ip_version=6))
 

nautobot/extras/tests/test_plugins.py

@@ -6,12 +6,15 @@ from django.core.exceptions import ValidationError
 from django.template import engines
 from django.test import override_settings
 from django.urls import NoReverseMatch, reverse
+import django_tables2 as tables
 import netaddr
 
 from nautobot.circuits.models import Circuit, CircuitType, Provider
 from nautobot.core.testing import APIViewTestCases, disable_warnings, extract_page_body, TestCase, ViewTestCases
+from nautobot.core.utils.lookup import get_table_for_model
 from nautobot.dcim.models import Device, DeviceType, Location, LocationType, Manufacturer
 from nautobot.dcim.tests.test_views import create_test_device
+from nautobot.extras import plugins
 from nautobot.extras.choices import CustomFieldTypeChoices, RelationshipTypeChoices
 from nautobot.extras.jobs import get_job
 from nautobot.extras.models import CustomField, Relationship, RelationshipAssociation, Role, Secret, Status
@@ -647,6 +650,97 @@ class FilterExtensionTest(TestCase):
         self.assertIn("example_app_description", form.fields.keys())
 
 
+class TableExtensionTest(TestCase):
+    """Tests for adding table extensions."""
+
+    def test_alter_queryset(self):
+        """Test the 'alter_queryset' method of the TableExtension class."""
+        extension = plugins.TableExtension()
+        queryset = object()
+        result = extension.alter_queryset(queryset)
+        self.assertEqual(result, queryset)
+
+    def test__add_columns_into_model_table(self):
+        """Test the '_add_columns_into_model_table' function."""
+        extension = plugins.TableExtension()
+        extension.model = "tenancy.tenant"
+        extension.table_columns = {
+            "tenant_group": tables.Column(verbose_name="Name conflicts with existing column"),
+            "tenant_success": tables.Column(verbose_name="This name should be registered"),
+        }
+        extension.add_to_default_columns = ["tenant_group", "tenant_success"]
+
+        with self.assertLogs("nautobot.extras.plugins", level="WARNING") as logger:
+            plugins._add_columns_into_model_table(extension, "tenant")
+            table = get_table_for_model(extension.model)
+            expected = [
+                "ERROR:nautobot.extras.plugins:tenant: There was a name conflict with existing "
+                "table column `tenant_group`, the custom column was ignored."
+            ]
+            with self.subTest("error is logged"):
+                self.assertEqual(logger.output, expected)
+
+        with self.subTest("column is added to default_columns"):
+            self.assertIn("tenant_success", table.base_columns)
+
+    def test__add_column_to_table_base_columns(self):
+        """Test the '_add_column_to_table_base_columns' function."""
+        table = get_table_for_model("tenancy.tenant")
+
+        with self.subTest("raises TypeError"):
+            column = object()
+            with self.assertRaises(TypeError) as context:
+                plugins._add_column_to_table_base_columns(table, "test_column", column, "my_app")
+                self.assertEqual(
+                    context.exception, "Custom column `test_column` is not an instance of django_tables2.Column."
+                )
+
+        with self.subTest("raises AttributeError"):
+            column = tables.Column()
+            with self.assertRaises(AttributeError) as context:
+                plugins._add_column_to_table_base_columns(table, "pk", column, "my_app")
+                self.assertEqual(
+                    context.exception, "There was a conflict with table column `pk`, the custom column was ignored."
+                )
+
+        with self.subTest("Adds column to base_columns"):
+            column = tables.Column()
+            plugins._add_column_to_table_base_columns(table, "unique_name", column, "my_app")
+            self.assertIn("unique_name", table.base_columns)
+
+    def test__modify_default_table_columns(self):
+        """Test the '_modify_default_table_columns' function."""
+        extension = plugins.TableExtension()
+        extension.model = "tenancy.tenant"
+        extension.add_to_default_columns = ["new_column"]
+        extension.remove_from_default_columns = ["description"]
+
+        table = get_table_for_model(extension.model)
+        table.base_columns["new_column"] = tables.Column()
+
+        plugins._modify_default_table_columns(extension, "my_app")
+
+        with self.subTest("column is added to default_columns"):
+            self.assertIn("new_column", table.Meta.default_columns)
+
+        with self.subTest("column is removed from default_columns"):
+            self.assertNotIn("description", table.Meta.default_columns)
+
+    def test__validate_is_subclass_of_table_extension(self):
+        """Test the '_validate_is_subclass_of_table_extension' function."""
+        with self.assertRaises(TypeError):
+            plugins._validate_is_subclass_of_table_extension(object)
+
+    def test__validate_table_column_name_is_prefixed_with_app_name(self):
+        """Test the '_validate_table_column_name_is_prefixed_with_app_name' function."""
+        with self.assertRaises(ValueError) as context:
+            plugins._validate_table_column_name_is_prefixed_with_app_name("not_prefixed", "prefix")
+            self.assertEqual(
+                context.exception,
+                "Attempted to create a custom table column `not_prefixed` that did not start with `prefix`",
+            )
+
+
 class LoadPluginTest(TestCase):
     """
     Validate that plugin helpers work as intended.

nautobot/extras/views.py

@@ -737,7 +737,9 @@ class DynamicGroupView(generic.ObjectView):
 
         if table_class is not None:
             # Members table (for display on Members nav tab)
-            members_table = table_class(members.restrict(request.user, "view"), orderable=False)
+            members_table = table_class(
+                members.restrict(request.user, "view"), orderable=False, exclude=["dynamic_group_count"]
+            )
             paginate = {
                 "paginator_class": EnhancedPaginator,
                 "per_page": get_paginate_count(request),

nautobot/ipam/filters.py

@@ -586,13 +586,13 @@ class VLANFilterSet(
         fields = ["id", "name", "tags", "vid"]
 
     def get_for_device(self, queryset, name, value):
-        # TODO: after Location model replaced Site, which was not a hierarchical model, should we consider to include
-        # VLANs that belong to the parent/child locations of the `device.location`?
         """Return all VLANs available to the specified Device(value)."""
         devices = Device.objects.select_related("location").filter(**{f"{name}__in": value})
         if not devices.exists():
             return queryset.none()
         location_ids = list(devices.values_list("location__id", flat=True))
+        for location in Location.objects.filter(pk__in=location_ids):
+            location_ids.extend([ancestor.id for ancestor in location.ancestors()])
         return queryset.filter(Q(locations__isnull=True) | Q(locations__in=location_ids))
 
 

nautobot/ipam/models.py

@@ -890,12 +890,39 @@ class Prefix(PrimaryModel):
         )
         return available_ips
 
+    def get_child_ips(self):
+        """
+        Return IP addresses with this prefix as their *direct* parent.
+
+        Does *not* include IPs that descend from a descendant prefix; if those are desired, use get_all_ips() instead.
+
+        ```
+        Prefix 10.0.0.0/16
+            IPAddress 10.0.0.1/24
+            Prefix 10.0.1.0/24
+                IPAddress 10.0.1.1/24
+        ```
+
+        In the above example, `<Prefix 10.0.0.0/16>.get_child_ips()` will *only* return 10.0.0.1/24,
+        while `<Prefix 10.0.0.0/16>.get_all_ips()` will return *both* 10.0.0.1.24 and 10.0.1.1/24.
+        """
+        return self.ip_addresses.all()
+
     def get_all_ips(self):
         """
         Return all IP addresses contained within this prefix, including child prefixes' IP addresses.
 
-        Returns:
-            IPAddress QuerySet
+        This is distinct from the behavior of `get_child_ips()` and in *most* cases is probably preferred.
+
+        ```
+        Prefix 10.0.0.0/16
+            IPAddress 10.0.0.1/24
+            Prefix 10.0.1.0/24
+                IPAddress 10.0.1.1/24
+        ```
+
+        In the above example, `<Prefix 10.0.0.0/16>.get_child_ips()` will *only* return 10.0.0.1/24,
+        while `<Prefix 10.0.0.0/16>.get_all_ips()` will return *both* 10.0.0.1.24 and 10.0.1.1/24.
         """
         return IPAddress.objects.filter(
             parent__namespace=self.namespace, host__gte=self.network, host__lte=self.broadcast

nautobot/ipam/templates/ipam/ipaddress.html

@@ -150,9 +150,9 @@
                 </tr>
             </table>
         </div>
-        {% include 'panel_table.html' with table=parent_prefixes_table heading='Parent Prefixes' %}
 {% endblock content_right_page %}
 
 {% block content_full_width_page %}
-        {% include 'utilities/obj_table.html' with table=related_ips_table table_template='panel_table.html' heading='Related IP Addresses' panel_class='default' %}
+    {% include 'utilities/obj_table.html' with table=parent_prefixes_table table_template='panel_table.html' heading='Parent Prefixes' %}
+    {% include 'utilities/obj_table.html' with table=related_ips_table table_template='panel_table.html' heading='Related IP Addresses' %}
 {% endblock content_full_width_page %}

nautobot/ipam/templates/ipam/ipaddress_interfaces.html

@@ -21,6 +21,9 @@
             {% render_table interface_table 'inc/table.html' %}
         </div>
     </form>
+    {% if interface_table.paginator.num_pages > 1 %}
+        {% include "inc/paginator.html" with paginator=interface_table.paginator page=interface_table.page %}
+    {% endif %}
     {% table_config_form interface_table %}
 {% endblock content %}
 

nautobot/ipam/templates/ipam/ipaddress_vm_interfaces.html

@@ -21,6 +21,9 @@
             {% render_table vm_interface_table 'inc/table.html' %}
         </div>
     </form>
+    {% if vm_interface_table.paginator.num_pages > 1 %}
+        {% include "inc/paginator.html" with paginator=vm_interface_table.paginator page=vm_interface_table.page %}
+    {% endif %}
     {% table_config_form vm_interface_table %}
 {% endblock content %}
 

nautobot/ipam/templates/ipam/prefix.html

@@ -117,7 +117,7 @@
 {% endblock content_left_page %}
 
 {% block content_right_page %}
-            {% include 'panel_table.html' with table=parent_prefix_table heading='Parent Prefixes' panel_class='default' %}
-            {% include "utilities/obj_table.html" with table=vrf_table table_template="panel_table.html" heading="Assigned VRFs" disable_pagination=False %}
-            {% include "utilities/obj_table.html" with table=cloud_network_table table_template="panel_table.html" heading="Assigned Cloud Networks" disable_pagination=False %}
+    {% include "utilities/obj_table.html" with table=parent_prefix_table table_template="panel_table.html" heading="Parent Prefixes" %}
+    {% include "utilities/obj_table.html" with table=vrf_table table_template="panel_table.html" heading="Assigned VRFs" %}
+    {% include "utilities/obj_table.html" with table=cloud_network_table table_template="panel_table.html" heading="Assigned Cloud Networks" %}
 {% endblock content_right_page %}

nautobot/ipam/templates/ipam/routetarget.html

@@ -24,6 +24,6 @@
 {% endblock content_left_page %}
 
 {% block content_right_page %}
-        {% include 'panel_table.html' with table=importing_vrfs_table heading="Importing VRFs" %}
-        {% include 'panel_table.html' with table=exporting_vrfs_table heading="Exporting VRFs" %}
+    {% include 'utilities/obj_table.html' with table=importing_vrfs_table table_template='panel_table.html' heading="Importing VRFs" %}
+    {% include 'utilities/obj_table.html' with table=exporting_vrfs_table table_template='panel_table.html' heading="Exporting VRFs" %}
 {% endblock content_right_page %}

nautobot/ipam/templates/ipam/vlan.html

@@ -86,4 +86,7 @@
                     </div>
                 {% endif %}
             </div>
+            {% if prefix_table.paginator.num_pages > 1 %}
+                {% include "inc/paginator.html" with paginator=prefix_table.paginator page=prefix_table.page %}
+            {% endif %}
 {% endblock content_full_width_page %}

nautobot/ipam/templates/ipam/vrf.html

@@ -38,8 +38,11 @@
 {% endblock content_left_page %}
 
 {% block content_right_page %}
-        {% include 'panel_table.html' with table=import_targets_table heading="Import Route Targets" %}
-        {% include 'panel_table.html' with table=export_targets_table heading="Export Route Targets" %}
-	{% include 'panel_table.html' with table=prefix_table heading="Assigned Prefixes" %}
-	{% include 'panel_table.html' with table=device_table heading="Assigned Devices" %}
+    {% include 'utilities/obj_table.html' with table=import_targets_table table_template='panel_table.html' heading="Import Route Targets" %}
+    {% include 'utilities/obj_table.html' with table=export_targets_table table_template='panel_table.html' heading="Export Route Targets" %}
 {% endblock content_right_page %}
+
+{% block content_full_width_page %}
+	{% include 'utilities/obj_table.html' with table=prefix_table table_template='panel_table.html' heading="Assigned Prefixes" %}
+	{% include 'utilities/obj_table.html' with table=device_table table_template='panel_table.html' heading="Assigned Devices" %}
+{% endblock content_full_width_page %}