nautobot 2.0.5__py3-none-any.whl → 2.1.0b1__py3-none-any.whl

nautobot/core/tests/test_graphql.py

@@ -47,6 +47,8 @@ from nautobot.dcim.models import (
     DeviceType,
     FrontPort,
     Interface,
+    InterfaceRedundancyGroup,
+    InterfaceRedundancyGroupAssociation,
     Location,
     LocationType,
     PowerFeed,
@@ -70,7 +72,16 @@ from nautobot.extras.models import (
 )
 from nautobot.extras.registry import registry
 from nautobot.ipam.factory import VLANGroupFactory
-from nautobot.ipam.models import IPAddress, VLAN, Namespace, Prefix
+from nautobot.ipam.models import (
+    IPAddress,
+    IPAddressToInterface,
+    Namespace,
+    Prefix,
+    VLAN,
+    VRF,
+    VRFDeviceAssignment,
+    VRFPrefixAssignment,
+)
 from nautobot.users.models import ObjectPermission, Token
 from nautobot.tenancy.models import Tenant
 from nautobot.virtualization.factory import ClusterTypeFactory
@@ -834,9 +845,55 @@ class GraphQLQueryTest(TestCase):
             device=cls.device1,
             status=interface_status,
         )
+        cls.namespace = Namespace.objects.first()
+        cls.intr_group_status = Status.objects.get_for_model(InterfaceRedundancyGroup).first()
+        cls.interface_redundancy_group_1 = InterfaceRedundancyGroup.objects.create(
+            name="IRGroup 1",
+            status=cls.intr_group_status,
+        )
+        cls.interface_redundancy_group_2 = InterfaceRedundancyGroup.objects.create(
+            name="IRGroup 2",
+            status=cls.intr_group_status,
+        )
+        cls.interface_redundancy_group_3 = InterfaceRedundancyGroup.objects.create(
+            name="IRGroup 3",
+            status=cls.intr_group_status,
+        )
+        cls.irg_associations = (
+            InterfaceRedundancyGroupAssociation.objects.create(
+                interface_redundancy_group=cls.interface_redundancy_group_1,
+                interface=cls.interface11,
+                priority=123,
+            ),
+            InterfaceRedundancyGroupAssociation.objects.create(
+                interface_redundancy_group=cls.interface_redundancy_group_2,
+                interface=cls.interface12,
+                priority=456,
+            ),
+            InterfaceRedundancyGroupAssociation.objects.create(
+                interface_redundancy_group=cls.interface_redundancy_group_3,
+                interface=cls.interface11,
+                priority=789,
+            ),
+            InterfaceRedundancyGroupAssociation.objects.create(
+                interface_redundancy_group=cls.interface_redundancy_group_3,
+                interface=cls.interface12,
+                priority=789,
+            ),
+        )
+        prefixes = Prefix.objects.all()[:2]
+        cls.namespace = prefixes[0].namespace
+        vrfs = (
+            VRF.objects.create(name="VRF 1", rd="65000:100", namespace=cls.namespace),
+            VRF.objects.create(name="VRF 2", rd="65000:200", namespace=cls.namespace),
+        )
+        prefixes[0].vrfs.add(vrfs[0])
+        prefixes[0].vrfs.add(vrfs[1])
+        prefixes[1].vrfs.add(vrfs[0])
+        prefixes[1].vrfs.add(vrfs[1])
+
         cls.ip_statuses = list(Status.objects.get_for_model(IPAddress))[:2]
         cls.prefix_statuses = list(Status.objects.get_for_model(Prefix))[:2]
-        cls.namespace = Namespace.objects.first()
         cls.prefix1 = Prefix.objects.create(
             prefix="10.0.1.0/24", namespace=cls.namespace, status=cls.prefix_statuses[0]
         )
@@ -855,6 +912,10 @@ class GraphQLQueryTest(TestCase):
             tenant=cls.tenant2,
             face="rear",
         )
+        cls.device2.vrfs.add(vrfs[0])
+        cls.device2.vrfs.add(vrfs[1])
+        cls.device2.vrfs.add(vrfs[0])
+        cls.device2.vrfs.add(vrfs[1])
 
         cls.interface21 = Interface.objects.create(
             name="Int1",
@@ -1178,6 +1239,108 @@ query {
             # Assert GraphQL returned properties match those expected
             self.assertEqual(console_port_entry["connected_console_server_port"], connected_console_server_port)
 
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_interface_redundancy_group_associations(self):
+        """Test graphql functionality for InterfaceRedundancyGroupAssociation"""
+
+        query = """\
+query {
+    interface_redundancy_group_associations {
+        id
+        interface { id }
+        interface_redundancy_group { id }
+        priority
+    }
+}"""
+
+        result = self.execute_query(query)
+        self.assertIsNone(result.errors)
+        self.assertEqual(
+            len(InterfaceRedundancyGroupAssociation.objects.all()),
+            len(result.data["interface_redundancy_group_associations"]),
+        )
+        for association in result.data["interface_redundancy_group_associations"]:
+            association_obj = InterfaceRedundancyGroupAssociation.objects.get(id=association["id"])
+            # Assert GraphQL returned properties match those expected
+            self.assertEqual(association["interface"]["id"], str(association_obj.interface.pk))
+            self.assertEqual(
+                association["interface_redundancy_group"]["id"], str(association_obj.interface_redundancy_group.pk)
+            )
+            self.assertEqual(association["priority"], association_obj.priority)
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_ip_address_to_interface(self):
+        """Test graphql functionality for IPAddressToInterface"""
+
+        query = """\
+query {
+    ip_address_assignments {
+        id
+        interface { id }
+        vm_interface { id }
+        ip_address { id }
+    }
+}"""
+
+        result = self.execute_query(query)
+        self.assertIsNone(result.errors)
+        self.assertEqual(
+            len(IPAddressToInterface.objects.all()),
+            len(result.data["ip_address_assignments"]),
+        )
+        for association in result.data["ip_address_assignments"]:
+            association_obj = IPAddressToInterface.objects.get(id=association["id"])
+            # Assert GraphQL returned properties match those expected
+            if association_obj.interface:
+                self.assertEqual(association["interface"]["id"], str(association_obj.interface.pk))
+            else:
+                self.assertEqual(association["interface"], None)
+            if association_obj.vm_interface:
+                self.assertEqual(association["vm_interface"]["id"], str(association_obj.vm_interface.pk))
+            else:
+                self.assertEqual(association["vm_interface"], None)
+            self.assertEqual(association["ip_address"]["id"], str(association_obj.ip_address.pk))
+
+    @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
+    def test_vrf_assignments(self):
+        """Test graphql functionality for VRFDeviceAssignment and VRFPrefixAssignment"""
+
+        query = """\
+query {
+    vrf_device_assignments {
+        id
+        vrf { id }
+        device { id }
+    }
+    vrf_prefix_assignments {
+        id
+        vrf { id }
+        prefix { id }
+    }
+}"""
+
+        result = self.execute_query(query)
+        self.assertIsNone(result.errors)
+        self.assertEqual(
+            len(VRFDeviceAssignment.objects.all()),
+            len(result.data["vrf_device_assignments"]),
+        )
+        self.assertEqual(
+            len(VRFPrefixAssignment.objects.all()),
+            len(result.data["vrf_prefix_assignments"]),
+        )
+        for assignment in result.data["vrf_device_assignments"]:
+            assignment_obj = VRFDeviceAssignment.objects.get(id=assignment["id"])
+            # Assert GraphQL returned properties match those expected
+            self.assertEqual(assignment["vrf"]["id"], str(assignment_obj.vrf.pk))
+            self.assertEqual(assignment["device"]["id"], str(assignment_obj.device.pk))
+
+        for assignment in result.data["vrf_prefix_assignments"]:
+            assignment_obj = VRFPrefixAssignment.objects.get(id=assignment["id"])
+            # Assert GraphQL returned properties match those expected
+            self.assertEqual(assignment["vrf"]["id"], str(assignment_obj.vrf.pk))
+            self.assertEqual(assignment["prefix"]["id"], str(assignment_obj.prefix.pk))
+
     @override_settings(EXEMPT_VIEW_PERMISSIONS=["*"])
     def test_query_console_server_ports_cable_peer(self):
         """Test querying console server port terminations for their cable peers"""

nautobot/core/tests/test_jobs.py

@@ -0,0 +1,112 @@
+from pathlib import Path
+
+from django.contrib.contenttypes.models import ContentType
+import yaml
+
+from nautobot.core.testing import TransactionTestCase, create_job_result_and_run_job
+from nautobot.dcim.models import DeviceType, Manufacturer
+from nautobot.extras.choices import JobResultStatusChoices, LogLevelChoices
+from nautobot.extras.models import ExportTemplate, JobLogEntry, Status
+from nautobot.users.models import ObjectPermission
+
+
+class ExportObjectListTest(TransactionTestCase):
+    """
+    Test the ExportObjectList system job.
+    """
+
+    databases = ("default", "job_logs")
+
+    def test_export_without_permission(self):
+        """Job should enforce user permissions on the content-type being asked for export."""
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs",
+            "ExportObjectList",
+            username=self.user.username,  # otherwise run_job_for_testing defaults to a superuser account
+            content_type=ContentType.objects.get_for_model(Status).pk,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        log_error = JobLogEntry.objects.get(job_result=job_result, log_level=LogLevelChoices.LOG_ERROR)
+        self.assertEqual(log_error.message, f'User "{self.user}" does not have permission to view status objects')
+        self.assertFalse(job_result.files.exists())
+
+    def test_export_with_constrained_permission(self):
+        """Job should only allow the user to export objects they have permission to view."""
+        instance1, instance2 = Status.objects.all()[:2]
+        obj_perm = ObjectPermission(
+            name="Test permission",
+            constraints={"pk": instance1.pk},
+            actions=["view"],
+        )
+        obj_perm.save()
+        obj_perm.users.add(self.user)
+        obj_perm.object_types.add(ContentType.objects.get_for_model(Status))
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs",
+            "ExportObjectList",
+            username=self.user.username,  # otherwise run_job_for_testing defaults to a superuser account
+            content_type=ContentType.objects.get_for_model(Status).pk,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertTrue(job_result.files.exists())
+        self.assertEqual(Path(job_result.files.first().file.name).name, "nautobot_statuses.csv")
+        csv_data = job_result.files.first().file.read().decode("utf-8")
+        self.assertIn(str(instance1.pk), csv_data)
+        self.assertNotIn(str(instance2.pk), csv_data)
+
+    def test_export_all_to_csv(self):
+        """By default, job should export all instances to CSV."""
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs",
+            "ExportObjectList",
+            content_type=ContentType.objects.get_for_model(Status).pk,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertTrue(job_result.files.exists())
+        self.assertEqual(Path(job_result.files.first().file.name).name, "nautobot_statuses.csv")
+        csv_data = job_result.files.first().file.read().decode("utf-8")
+        # May be more than one line per Status if they have newlines in their description strings
+        self.assertGreaterEqual(len(csv_data.split("\n")), Status.objects.count() + 1, csv_data)  # +1 for CSV header
+
+    def test_export_all_via_export_template(self):
+        """When an export-template is specified, it should be used."""
+        et = ExportTemplate.objects.create(
+            content_type=ContentType.objects.get_for_model(Status),
+            name="Simple Export Template",
+            template_code="{% for obj in queryset %}{{ obj.name }}\n{% endfor %}",
+            file_extension="txt",
+        )
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs",
+            "ExportObjectList",
+            content_type=ContentType.objects.get_for_model(Status).pk,
+            export_template=et.pk,
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertTrue(job_result.files.exists())
+        self.assertEqual(Path(job_result.files.first().file.name).name, "nautobot_statuses.txt")
+        text_data = job_result.files.first().file.read().decode("utf-8")
+        self.assertEqual(len(text_data.split("\n")), Status.objects.count() + 1)
+        for status in Status.objects.iterator():
+            self.assertIn(status.name, text_data)
+
+    def test_export_devicetype_to_yaml(self):
+        """Export device-type to YAML."""
+        mfr = Manufacturer.objects.create(name="Cisco")
+        DeviceType.objects.create(
+            manufacturer=mfr,
+            model="Cisco CSR1000v",
+            u_height=0,
+        )
+        job_result = create_job_result_and_run_job(
+            "nautobot.core.jobs",
+            "ExportObjectList",
+            content_type=ContentType.objects.get_for_model(DeviceType).pk,
+            export_format="yaml",
+        )
+        self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertTrue(job_result.files.exists())
+        self.assertEqual(Path(job_result.files.first().file.name).name, "nautobot_device_types.yaml")
+        yaml_data = job_result.files.first().file.read().decode("utf-8")
+        data = yaml.safe_load(yaml_data)
+        self.assertEqual(data["manufacturer"], "Cisco")

nautobot/core/tests/test_openapi.py

@@ -41,6 +41,9 @@ class OpenAPITest(TestCase):
         query_params = self.schema["paths"]["/dcim/devices/"]["get"]["parameters"]
         at_least_one_test = False
         for query_param_info in query_params:
+            if query_param_info["name"].endswith("_isnull"):
+                # The broad catch below does not apply to isnull, which will return a boolean.
+                continue
             if query_param_info["name"].startswith("created") or query_param_info["name"].startswith("last_updated"):
                 self.assertEqual("array", query_param_info["schema"]["type"])
                 self.assertEqual("string", query_param_info["schema"]["items"]["type"])
@@ -57,6 +60,9 @@ class OpenAPITest(TestCase):
         query_params = self.schema["paths"]["/dcim/devices/"]["get"]["parameters"]
         at_least_one_test = False
         for query_param_info in query_params:
+            if query_param_info["name"].endswith("_isnull"):
+                # The broad catch below does not apply to isnull, which will return a boolean.
+                continue
             if query_param_info["name"].startswith("device_redundancy_group_priority"):
                 self.assertEqual("array", query_param_info["schema"]["type"])
                 self.assertEqual("integer", query_param_info["schema"]["items"]["type"])

nautobot/core/tests/test_views.py

@@ -37,7 +37,7 @@ class HomeViewTestCase(TestCase):
 
         # Search bar in nav
         nav_search_bar_pattern = re.compile(
-            '<nav.*<form action="/search/" method="get" class="navbar-form navbar-right" id="navbar_search" role="search">.*</form>.*</nav>'
+            '<nav.*<form action="/search/" method="get" class="navbar-form" id="navbar_search" role="search">.*</form>.*</nav>'
         )
         nav_search_bar_result = nav_search_bar_pattern.search(
             response.content.decode(response.charset).replace("\n", "")
@@ -53,8 +53,7 @@ class HomeViewTestCase(TestCase):
 
         return nav_search_bar_result, body_search_bar_result
 
-    @override_settings(HIDE_RESTRICTED_UI=True)
-    def test_search_bar_not_visible_if_user_not_authenticated_and_hide_restricted_ui_True(self):
+    def test_search_bar_not_visible_if_user_not_authenticated(self):
         self.client.logout()
 
         nav_search_bar_result, body_search_bar_result = self.make_request()
@@ -62,23 +61,7 @@ class HomeViewTestCase(TestCase):
         self.assertIsNone(nav_search_bar_result)
         self.assertIsNone(body_search_bar_result)
 
-    @override_settings(HIDE_RESTRICTED_UI=False)
-    def test_search_bar_visible_if_user_authenticated_and_hide_restricted_ui_True(self):
-        nav_search_bar_result, body_search_bar_result = self.make_request()
-
-        self.assertIsNotNone(nav_search_bar_result)
-        self.assertIsNotNone(body_search_bar_result)
-
-    @override_settings(HIDE_RESTRICTED_UI=False)
-    def test_search_bar_visible_if_hide_restricted_ui_False(self):
-        # Assert if user is authenticated
-        nav_search_bar_result, body_search_bar_result = self.make_request()
-
-        self.assertIsNotNone(nav_search_bar_result)
-        self.assertIsNotNone(body_search_bar_result)
-
-        # Assert if user is logout
-        self.client.logout()
+    def test_search_bar_visible_if_user_authenticated(self):
         nav_search_bar_result, body_search_bar_result = self.make_request()
 
         self.assertIsNotNone(nav_search_bar_result)
@@ -229,27 +212,8 @@ class NavRestrictedUI(TestCase):
         response = self.client.get(reverse("home"))
         return response.content.decode(response.charset)
 
-    @override_settings(HIDE_RESTRICTED_UI=True)
-    def test_installed_apps_visible_to_staff_with_hide_restricted_ui_true(self):
-        """The "Installed Apps" menu item should be available to is_staff user regardless of HIDE_RESTRICTED_UI."""
-        # Make user admin
-        self.user.is_staff = True
-        self.user.save()
-
-        response_content = self.make_request()
-        self.assertInHTML(
-            f"""
-            <a href="{self.url}"
-                data-item-weight="{self.item_weight}">
-                Installed Plugins
-            </a>
-            """,
-            response_content,
-        )
-
-    @override_settings(HIDE_RESTRICTED_UI=False)
-    def test_installed_apps_visible_to_staff_with_hide_restricted_ui_false(self):
-        """The "Installed Apps" menu item should be available to is_staff user regardless of HIDE_RESTRICTED_UI."""
+    def test_installed_apps_visible_to_staff(self):
+        """The "Installed Apps" menu item should be available to is_staff user."""
         # Make user admin
         self.user.is_staff = True
         self.user.save()
@@ -265,29 +229,11 @@ class NavRestrictedUI(TestCase):
             response_content,
         )
 
-    @override_settings(HIDE_RESTRICTED_UI=True)
-    def test_installed_apps_not_visible_to_non_staff_user_with_hide_restricted_ui_true(self):
-        """The "Installed Apps" menu item should be hidden from a non-staff user when HIDE_RESTRICTED_UI=True."""
-        response_content = self.make_request()
-
-        self.assertNotRegex(response_content, r"Installed\s+Apps")
-
-    @override_settings(HIDE_RESTRICTED_UI=False)
-    def test_installed_apps_disabled_to_non_staff_user_with_hide_restricted_ui_false(self):
-        """The "Installed Apps" menu item should be disabled for a non-staff user when HIDE_RESTRICTED_UI=False."""
+    def test_installed_apps_not_visible_to_non_staff_user_without_permission(self):
+        """The "Installed Apps" menu item should be hidden from a non-staff user without permission."""
         response_content = self.make_request()
 
-        # print(response_content)
-
-        self.assertInHTML(
-            f"""
-            <a href="{self.url}"
-                data-item-weight="{self.item_weight}">
-                Installed Plugins
-            </a>
-            """,
-            response_content,
-        )
+        self.assertNotRegex(response_content, r"Installed\s+Plugins")
 
 
 class LoginUI(TestCase):
@@ -326,9 +272,9 @@ class LoginUI(TestCase):
         sso_login_search_result = self.make_request()
         self.assertIsNotNone(sso_login_search_result)
 
-    @override_settings(HIDE_RESTRICTED_UI=True, BANNER_TOP="Hello, Banner Top", BANNER_BOTTOM="Hello, Banner Bottom")
-    def test_routes_redirect_back_to_login_if_hide_restricted_ui_true(self):
-        """Assert that api docs and graphql redirects to login page if user is unauthenticated and HIDE_RESTRICTED_UI=True."""
+    @override_settings(BANNER_TOP="Hello, Banner Top", BANNER_BOTTOM="Hello, Banner Bottom")
+    def test_routes_redirect_back_to_login_unauthenticated(self):
+        """Assert that api docs and graphql redirects to login page if user is unauthenticated."""
         self.client.logout()
         headers = {"HTTP_ACCEPT": "text/html"}
         urls = [reverse("api_docs"), reverse("graphql")]
@@ -346,26 +292,6 @@ class LoginUI(TestCase):
                 self.assertNotIn("Hello, Banner Top", response_content)
                 self.assertNotIn("Hello, Banner Bottom", response_content)
 
-    @override_settings(HIDE_RESTRICTED_UI=False, BANNER_TOP="Hello, Banner Top", BANNER_BOTTOM="Hello, Banner Bottom")
-    def test_routes_no_redirect_back_to_login_if_hide_restricted_ui_false(self):
-        """Assert that api docs and graphql do not redirects to login page if user is unauthenticated and HIDE_RESTRICTED_UI=False."""
-        self.client.logout()
-        headers = {"HTTP_ACCEPT": "text/html"}
-        urls = [reverse("api_docs"), reverse("graphql")]
-        for url in urls:
-            response = self.client.get(url, **headers)
-            self.assertHttpStatus(response, 200)
-            self.assertEqual(response.request["PATH_INFO"], url)
-            response_content = response.content.decode(response.charset).replace("\n", "")
-            # Assert Footer items(`self.footer_elements`), Banner and Banner Top is not hidden
-            for footer_text in self.footer_elements:
-                self.assertInHTML(footer_text, response_content)
-
-            # Only API Docs implements BANNERS
-            if url == urls[0]:
-                self.assertInHTML("Hello, Banner Top", response_content)
-                self.assertInHTML("Hello, Banner Bottom", response_content)
-
 
 class MetricsViewTestCase(TestCase):
     def query_and_parse_metrics(self):

nautobot/core/urls.py

@@ -1,6 +1,7 @@
 from django.conf import settings
 from django.conf.urls import include
 from django.urls import path
+from django.views.generic import TemplateView
 from django.views.static import serve
 
 from nautobot.core.views import CustomGraphQLView, HomeView, StaticMediaFailureView, SearchView, nautobot_metrics_view
@@ -31,7 +32,7 @@ urlpatterns = [
     path("api/", include("nautobot.core.api.urls")),
     # GraphQL
     path("graphql/", CustomGraphQLView.as_view(graphiql=True), name="graphql"),
-    # Serving static media in Django
+    # Serving static media in Django (TODO: should be DEBUG mode only - "This view is NOT hardened for production use")
     path("media/<path:path>", serve, {"document_root": settings.MEDIA_ROOT}),
     # Admin
     path("admin/", admin_site.urls),
@@ -46,6 +47,10 @@ urlpatterns = [
     path(r"health/", include("health_check.urls")),
     # FileProxy attachments download/get URLs used in admin views only
     path("files/", include("db_file_storage.urls")),
+    # Templated css file
+    path(
+        "template.css", TemplateView.as_view(template_name="template.css", content_type="text/css"), name="template_css"
+    ),
 ]
 
 

nautobot/core/utils/lookup.py

@@ -192,3 +192,31 @@ def get_table_for_model(model):
         (Union[Table, None]): Either the `Table` class or `None`
     """
     return get_related_class_for_model(model, module_name="tables", object_suffix="Table")
+
+
+def get_created_and_last_updated_usernames_for_model(instance):
+    """
+    Args:
+        instance: A model class instance
+
+    Returns:
+        created_by: Username of the user that created the instance
+        last_updated_by: Username of the user that last modified the instance
+    """
+    from nautobot.extras.choices import ObjectChangeActionChoices
+    from nautobot.extras.models import ObjectChange
+
+    object_change_records = get_changes_for_model(instance)
+    created_by = None
+    last_updated_by = None
+    try:
+        created_by_record = object_change_records.get(action=ObjectChangeActionChoices.ACTION_CREATE)
+        created_by = created_by_record.user_name
+    except ObjectChange.DoesNotExist:
+        pass
+
+    last_updated_by_record = object_change_records.first()
+    if last_updated_by_record:
+        last_updated_by = last_updated_by_record.user_name
+
+    return created_by, last_updated_by

nautobot/core/utils/requests.py

@@ -114,13 +114,12 @@ def get_filterable_params_from_filter_params(filter_params, non_filter_params, f
     Returns:
         (QueryDict): Filter param querydict with only queryset filterable params
     """
-    for non_filter_param in non_filter_params:
-        filter_params.pop(non_filter_param, None)
-
     # Some FilterSet field only accept single choice not multiple choices
     # e.g datetime field, bool fields etc.
     final_filter_params = {}
     for field in filter_params.keys():
+        if field in non_filter_params:
+            continue
         if filter_params.get(field):
             # `is_single_choice_field` implements `get_filterset_field`, which throws an exception if a field is not found.
             # If an exception is thrown, instead of throwing an exception, set `_is_single_choice_field` to 'False'

nautobot/core/views/__init__.py

@@ -25,7 +25,6 @@ from prometheus_client.registry import Collector
 from nautobot.core.constants import SEARCH_MAX_RESULTS
 from nautobot.core.forms import SearchForm
 from nautobot.core.releases import get_latest_release
-from nautobot.core.utils.config import get_settings_or_config
 from nautobot.core.utils.lookup import get_route_for_model
 from nautobot.extras.models import GraphQLQuery
 from nautobot.extras.registry import registry
@@ -58,8 +57,8 @@ class HomeView(AccessMixin, TemplateView):
         return template.render(additional_context)
 
     def get(self, request, *args, **kwargs):
-        # Redirect user to login page if not authenticated and HIDE_RESTRICTED_UI is set to True
-        if not request.user.is_authenticated and get_settings_or_config("HIDE_RESTRICTED_UI"):
+        # Redirect user to login page if not authenticated
+        if not request.user.is_authenticated:
             return self.handle_no_permission()
         # Check whether a new release is available. (Only for staff/superusers.)
         new_release = None
@@ -242,7 +241,7 @@ def csrf_failure(request, reason="", template_name="403_csrf_failure.html"):
 
 class CustomGraphQLView(GraphQLView):
     def render_graphiql(self, request, **data):
-        if not request.user.is_authenticated and get_settings_or_config("HIDE_RESTRICTED_UI"):
+        if not request.user.is_authenticated:
             graphql_url = reverse("graphql")
             login_url = reverse(settings.LOGIN_URL)
             return redirect(f"{login_url}?next={graphql_url}")

nautobot/core/views/generic.py

@@ -39,6 +39,7 @@ from nautobot.core.forms import (
 from nautobot.core.forms.forms import DynamicFilterFormSet
 from nautobot.core.templatetags.helpers import bettertitle, validated_viewname
 from nautobot.core.utils.config import get_settings_or_config
+from nautobot.core.utils.lookup import get_created_and_last_updated_usernames_for_model
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.core.utils.requests import (
     convert_querydict_to_factory_formset_acceptable_querydict,
@@ -100,6 +101,8 @@ class ObjectView(ObjectPermissionRequiredMixin, View):
         Generic GET handler for accessing an object.
         """
         instance = get_object_or_404(self.queryset, **kwargs)
+        # Get the ObjectChange records to populate the advanced tab information
+        created_by, last_updated_by = get_created_and_last_updated_usernames_for_model(instance)
 
         # TODO: this feels inelegant - should the tabs lookup be a dedicated endpoint rather than piggybacking
         # on the object-retrieve endpoint?
@@ -127,6 +130,8 @@ class ObjectView(ObjectPermissionRequiredMixin, View):
                     "object": instance,
                     "verbose_name": self.queryset.model._meta.verbose_name,
                     "verbose_name_plural": self.queryset.model._meta.verbose_name_plural,
+                    "created_by": created_by,
+                    "last_updated_by": last_updated_by,
                     **self.get_extra_context(request, instance),
                 },
             )
@@ -152,7 +157,7 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
     template_name = "generic/object_list.html"
     action_buttons = ("add", "import", "export")
     non_filter_params = (
-        "export",  # trigger for CSV/export-template/YAML export
+        "export",  # trigger for CSV/export-template/YAML export # 3.0 TODO: remove, irrelevant after #4746
         "page",  # used by django-tables2.RequestConfig
         "per_page",  # used by get_paginate_count
         "sort",  # table sorting
@@ -166,7 +171,7 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
     def get_required_permission(self):
         return get_permission_for_model(self.queryset.model, "view")
 
-    # TODO: remove this as well?
+    # 3.0 TODO: remove, irrelevant after #4746
     def queryset_to_yaml(self):
         """
         Export the queryset of objects as concatenated YAML documents.
@@ -229,7 +234,7 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
                 filter_form = self.filterset_form(filter_params, label_suffix="")
 
         # Check for export template rendering
-        if request.GET.get("export"):
+        if request.GET.get("export"):  # 3.0 TODO: remove, irrelevant after #4746
             et = get_object_or_404(
                 ExportTemplate,
                 content_type=content_type,
@@ -244,7 +249,7 @@ class ObjectListView(ObjectPermissionRequiredMixin, View):
                 )
 
         # Check for YAML export support
-        elif "export" in request.GET and hasattr(model, "to_yaml"):
+        elif "export" in request.GET and hasattr(model, "to_yaml"):  # 3.0 TODO: remove, irrelevant after #4746
             response = HttpResponse(self.queryset_to_yaml(), content_type="text/yaml")
             filename = f"{settings.BRANDING_PREPENDED_FILENAME}{self.queryset.model._meta.verbose_name_plural}.yaml"
             response["Content-Disposition"] = f'attachment; filename="{filename}"'