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

nautobot/circuits/navigation.py

@@ -5,7 +5,6 @@ from nautobot.core.apps import (
     NavMenuAddButton,
     NavMenuGroup,
     NavMenuItem,
-    NavMenuImportButton,
     NavMenuTab,
 )
 
@@ -33,12 +32,6 @@ menu_items = (
                                     "circuits.add_circuit",
                                 ],
                             ),
-                            NavMenuImportButton(
-                                link="circuits:circuit_import",
-                                permissions=[
-                                    "circuits.add_circuit",
-                                ],
-                            ),
                         ),
                     ),
                     NavMenuItem(
@@ -55,12 +48,6 @@ menu_items = (
                                     "circuits.add_circuittype",
                                 ],
                             ),
-                            NavMenuImportButton(
-                                link="circuits:circuittype_import",
-                                permissions=[
-                                    "circuits.add_circuittype",
-                                ],
-                            ),
                         ),
                     ),
                 ),
@@ -83,12 +70,6 @@ menu_items = (
                                     "circuits.add_provider",
                                 ],
                             ),
-                            NavMenuImportButton(
-                                link="circuits:provider_import",
-                                permissions=[
-                                    "circuits.add_provider",
-                                ],
-                            ),
                         ),
                     ),
                     NavMenuItem(
@@ -105,12 +86,6 @@ menu_items = (
                                     "circuits.add_providernetwork",
                                 ],
                             ),
-                            NavMenuImportButton(
-                                link="circuits:providernetwork_import",
-                                permissions=[
-                                    "circuits.add_providernetwork",
-                                ],
-                            ),
                         ),
                     ),
                 ),

nautobot/circuits/templates/circuits/circuit_retrieve.html

@@ -5,15 +5,6 @@
                 <li><a href="{% url 'circuits:circuit_list' %}?provider={{ object.provider.pk }}">{{ object.provider }}</a></li>
 {% endblock extra_breadcrumbs %}
 
-{% block masthead %}
-<h1>
-<span class="hover_copy"><span id="copy_title">{{ object }}</span><button type="button" class="btn btn-inline btn-default hover_copy_button" data-clipboard-target="#copy_title">
-    <span class="mdi mdi-content-copy"></span>
-</button>
-</span>
-</h1>
-{% endblock masthead %}
-
 {% block content_left_page %}
         <div class="panel panel-default">
             <div class="panel-heading">

nautobot/circuits/templates/circuits/providernetwork_retrieve.html

@@ -9,8 +9,6 @@
   <li>{{ object }}</li>
 {% endblock %}
 
-{% block title %}{{ object.provider }} {{ object.name }}{% endblock title %}
-
 {% block content_left_page %}
         <div class="panel panel-default">
             <div class="panel-heading">

nautobot/circuits/tests/test_api.py

@@ -3,8 +3,9 @@ from django.urls import reverse
 from nautobot.circuits.choices import CircuitTerminationSideChoices
 from nautobot.circuits.models import Circuit, CircuitTermination, CircuitType, Provider, ProviderNetwork
 from nautobot.core.testing import APITestCase, APIViewTestCases
-from nautobot.dcim.models import Location
-from nautobot.extras.models import Status
+from nautobot.dcim.choices import InterfaceTypeChoices
+from nautobot.dcim.models import Cable, Device, DeviceType, FrontPort, Interface, RearPort, Location
+from nautobot.extras.models import Role, Status
 
 
 class AppTest(APITestCase):
@@ -164,6 +165,7 @@ class CircuitTerminationTest(APIViewTestCases.APIViewTestCase):
             Location.objects.first(),
             Location.objects.last(),
         )
+        cls.locations = locations
 
         provider = Provider.objects.first()
         circuit_type = CircuitType.objects.first()
@@ -174,6 +176,7 @@ class CircuitTerminationTest(APIViewTestCases.APIViewTestCase):
             Circuit.objects.create(cid="Circuit 2", provider=provider, circuit_type=circuit_type, status=status),
             Circuit.objects.create(cid="Circuit 3", provider=provider, circuit_type=circuit_type, status=status),
         )
+        cls.circuits = circuits
 
         CircuitTermination.objects.create(circuit=circuits[0], location=locations[0], term_side=SIDE_A)
         CircuitTermination.objects.create(circuit=circuits[0], location=locations[1], term_side=SIDE_Z)
@@ -204,3 +207,77 @@ class CircuitTerminationTest(APIViewTestCases.APIViewTestCase):
         }
 
         cls.bulk_update_data = {"port_speed": 123456}
+
+    def test_circuit_termination_connected_endpoint(self):
+        """Assert that API response for CircuitTermination connected cables to CircuitTermination, Interface, FortPort, or RearPort does not raise any errors"""
+        # Fix for https://github.com/nautobot/nautobot/issues/3179
+        self.add_permissions("circuits.view_circuittermination")
+
+        status = Status.objects.get_for_model(Cable).first()
+        device_status = Status.objects.get_for_model(Device).first()
+        interface_status = Status.objects.get_for_model(Interface).first()
+        device_type = DeviceType.objects.exclude(manufacturer__isnull=True).first()
+        device_role = Role.objects.get_for_model(Device).first()
+        device = Device.objects.create(
+            device_type=device_type, role=device_role, name="Device", location=self.locations[0], status=device_status
+        )
+        circuits = self.circuits
+
+        interface = Interface.objects.create(
+            device=device, type=InterfaceTypeChoices.TYPE_1GE_FIXED, name="Interface 001", status=interface_status
+        )
+        rearport1 = RearPort.objects.create(device=device, name="Rear Port 1", positions=1)
+        frontport1 = FrontPort.objects.create(
+            device=device, name="Front Port 1", rear_port=rearport1, rear_port_position=1
+        )
+
+        CircuitTermination.objects.create(
+            circuit=circuits[2], location=self.locations[0], term_side=CircuitTerminationSideChoices.SIDE_A
+        )
+        CircuitTermination.objects.create(
+            circuit=circuits[2], location=self.locations[0], term_side=CircuitTerminationSideChoices.SIDE_Z
+        )
+
+        with self.subTest("Assert CircuitTermination Cable connected to an Interface and Rear Port"):
+            Cable.objects.create(
+                termination_a=circuits[0].circuit_termination_a, termination_b=interface, label="Cable 1", status=status
+            )
+            Cable.objects.create(
+                termination_a=circuits[0].circuit_termination_z, termination_b=rearport1, label="Cable 2", status=status
+            )
+
+            response = self.client.get(
+                circuits[0].circuit_termination_a.get_absolute_url(api=True),
+                **self.header,
+            )
+            self.assertEqual(response.status_code, 200)
+            response = self.client.get(
+                circuits[0].circuit_termination_z.get_absolute_url(api=True),
+                **self.header,
+            )
+            self.assertEqual(response.status_code, 200)
+
+        with self.subTest("Assert CircuitTermination Cable connected to a FrontPort and CircuitTermination"):
+            Cable.objects.create(
+                termination_a=circuits[2].circuit_termination_a,
+                termination_b=circuits[1].circuit_termination_z,
+                label="Cable 3",
+                status=status,
+            )
+            Cable.objects.create(
+                termination_a=circuits[2].circuit_termination_z,
+                termination_b=frontport1,
+                label="Cable 4",
+                status=status,
+            )
+
+            response = self.client.get(
+                circuits[2].circuit_termination_a.get_absolute_url(api=True),
+                **self.header,
+            )
+            self.assertEqual(response.status_code, 200)
+            response = self.client.get(
+                circuits[2].circuit_termination_z.get_absolute_url(api=True),
+                **self.header,
+            )
+            self.assertEqual(response.status_code, 200)

nautobot/circuits/tests/test_filters.py

@@ -91,6 +91,7 @@ class CircuitTestCase(FilterTestCases.FilterTestCase, FilterTestCases.TenancyFil
         ["provider_network", "circuit_terminations__provider_network__name"],
         ["circuit_type", "circuit_type__id"],
         ["circuit_type", "circuit_type__name"],
+        ["status", "status__id"],
         ["status", "status__name"],
         ["circuit_termination_a"],
         ["circuit_termination_z"],

nautobot/core/api/serializers.py

@@ -134,7 +134,15 @@ class BaseModelSerializer(OptInFieldsMixin, serializers.HyperlinkedModelSerializ
     natural_keys_values = None
     natural_slug = serializers.SerializerMethodField()
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, force_csv=False, **kwargs):
+        """
+        Instantiate a BaseModelSerializer.
+
+        The force_csv kwarg allows you to force _is_csv_request() to evaluate True without passing a Request object,
+        which is necessary to be able to export appropriately structured CSV from a Job that doesn't have a Request.
+        """
+        self._force_csv = force_csv
+
         super().__init__(*args, **kwargs)
         # If it is not a Nested Serializer, we should set the depth argument to whatever is in the request's context
         if not self.is_nested:
@@ -270,6 +278,8 @@ class BaseModelSerializer(OptInFieldsMixin, serializers.HyperlinkedModelSerializ
 
     def _is_csv_request(self):
         """Return True if this a CSV export request"""
+        if self._force_csv:
+            return True
         request = self.context.get("request")
         return hasattr(request, "accepted_media_type") and "text/csv" in request.accepted_media_type
 
@@ -361,10 +371,10 @@ class BaseModelSerializer(OptInFieldsMixin, serializers.HyperlinkedModelSerializ
         self.extend_field_names(fields, "id", at_start=True)
 
         # Move these fields to the end
-        if hasattr(self.Meta.model, "created"):
-            self.extend_field_names(fields, "created")
-        if hasattr(self.Meta.model, "last_updated"):
-            self.extend_field_names(fields, "last_updated")
+        fields_to_include = ["created", "last_updated"]
+        for field in fields_to_include:
+            if hasattr(self.Meta.model, field):
+                self.extend_field_names(fields, field)
 
         def filter_field(field):
             # Eliminate all field names that start with "_" as those fields are not user-facing

nautobot/core/api/views.py

@@ -494,7 +494,7 @@ class NautobotSpectacularSwaggerView(APIVersioningGetSchemaURLMixin, Spectacular
     @extend_schema(exclude=True)
     def get(self, request, *args, **kwargs):
         """Fix up the rendering of the Swagger UI to work with Nautobot's UI."""
-        if not request.user.is_authenticated and get_settings_or_config("HIDE_RESTRICTED_UI"):
+        if not request.user.is_authenticated:
             doc_url = reverse("api_docs")
             login_url = reverse(settings.LOGIN_URL)
             return redirect(f"{login_url}?next={doc_url}")
@@ -721,18 +721,16 @@ class GetMenuAPIView(NautobotAPIVersionMixin, APIView):
 
     permission_classes = [IsAuthenticated]
 
-    def format_and_remove_hidden_menu(self, request, data, hide_restricted_ui):
+    def format_and_remove_hidden_menu(self, request, data):
         """
         Formats the menu data and removes hidden menu items based on user permissions.
 
         Args:
             request (HttpRequest): The request object.
-            data (Union[dict, str]): The menu data to format and filter. Can be either a dictionary or a string.
-            hide_restricted_ui (bool): Flag indicating whether to hide restricted menu items.
+            data (dict): The menu data to format and filter.
 
         Returns:
-            (Union[dict, str]): The formatted menu data without hidden items. Returns a dict if `data` is a
-                `dict`, otherwise returns a string.
+            (dict): The formatted menu data without hidden items.
 
         Example:
             Input:
@@ -747,15 +745,18 @@ class GetMenuAPIView(NautobotAPIVersionMixin, APIView):
             Output:
             {"Devices": "data value"}
         """
-        if isinstance(data, dict):
-            return_value = {}
-            for name, value in data.items():
-                if not hide_restricted_ui or any(
-                    request.user.has_perm(permission) for permission in value["permissions"]
-                ):
-                    return_value[name] = self.format_and_remove_hidden_menu(request, value["data"], hide_restricted_ui)
-            return return_value
-        return data
+        return_value = {}
+        for name, value in data.items():
+            if "permissions" in value:
+                permissions = value["permissions"]
+                user_has_permission = any(request.user.has_perm(permission) for permission in permissions)
+                if user_has_permission:
+                    return_value[name] = value["data"]
+            else:
+                return_data = self.format_and_remove_hidden_menu(request, value["data"])
+                if return_data:
+                    return_value[name] = return_data
+        return return_value
 
     @extend_schema(exclude=True)
     def get(self, request):
@@ -796,8 +797,7 @@ class GetMenuAPIView(NautobotAPIVersionMixin, APIView):
         }
         """
         base_menu = registry["new_ui_nav_menu"]
-        HIDE_RESTRICTED_UI = get_settings_or_config("HIDE_RESTRICTED_UI")
-        formatted_data = self.format_and_remove_hidden_menu(request, base_menu, HIDE_RESTRICTED_UI)
+        formatted_data = self.format_and_remove_hidden_menu(request, base_menu)
         return Response(formatted_data)
 
 
@@ -838,13 +838,12 @@ class GetObjectCountsView(NautobotAPIVersionMixin, APIView):
                 {"model": "extras.role"},
             ],
         }
-        HIDE_RESTRICTED_UI = get_settings_or_config("HIDE_RESTRICTED_UI")
 
         for entry in itertools.chain(*object_counts.values()):
             app_label, model_name = entry["model"].split(".")
             model = apps.get_model(app_label, model_name)
             permission = get_permission_for_model(model, "view")
-            if HIDE_RESTRICTED_UI and not request.user.has_perm(permission):
+            if not request.user.has_perm(permission):
                 continue
             data = {"name": model._meta.verbose_name_plural}
             try:

nautobot/core/choices.py

@@ -203,7 +203,7 @@ class ButtonActionColorChoices(ChoiceSet):
     Map standard button actions to Bootstrap color classes.
     """
 
-    ADD = "success"
+    ADD = "info"
     CANCEL = "default"
     CLONE = "success"
     CONFIGURE = "default"

nautobot/core/filters.py

@@ -630,15 +630,23 @@ class BaseFilterSet(django_filters.FilterSet):
         if field is None:
             return magic_filters
 
+        # If the field allows null values, add an `isnull`` check
+        if getattr(field, "null", None):
+            # Use this method vs extend as the `lookup_map` variable is generally one of
+            # the constants which we do not want to update
+            lookup_map = dict(lookup_map, **{"isnull": "isnull"})
+
         # Create new filters for each lookup expression in the map
         for lookup_name, lookup_expr in lookup_map.items():
             new_filter_name = f"{filter_name}__{lookup_name}"
 
             try:
-                if filter_name in cls.declared_filters:
-                    # The filter field has been explicity defined on the filterset class so we must manually
+                if filter_name in cls.declared_filters and lookup_expr not in {"isnull"}:
+                    # The filter field has been explicitly defined on the filterset class so we must manually
                     # create the new filter with the same type because there is no guarantee the defined type
-                    # is the same as the default type for the field
+                    # is the same as the default type for the field. This does not apply if the filter
+                    # should retain the original lookup_expr type, such as `isnull` using a boolean field on a
+                    # char or date object.
                     resolve_field(field, lookup_expr)  # Will raise FieldLookupError if the lookup is invalid
                     new_filter = type(filter_field)(
                         field_name=field_name,
@@ -649,7 +657,7 @@ class BaseFilterSet(django_filters.FilterSet):
                         **filter_field.extra,
                     )
                 else:
-                    # The filter field is listed in Meta.fields so we can safely rely on default behaviour
+                    # The filter field is listed in Meta.fields so we can safely rely on default behavior
                     # Will raise FieldLookupError if the lookup is invalid
                     new_filter = cls.filter_for_field(field, field_name, lookup_expr)
             except django_filters.exceptions.FieldLookupError:

nautobot/core/jobs/__init__.py

@@ -1,7 +1,16 @@
+from django.conf import settings
+from django.contrib.contenttypes.models import ContentType
+from django.core.exceptions import PermissionDenied
+from django.http import QueryDict
+
+from nautobot.core.api.renderers import NautobotCSVRenderer
+from nautobot.core.api.utils import get_serializer_for_model
 from nautobot.core.celery import app, register_jobs
+from nautobot.core.utils.lookup import get_filterset_for_model
+from nautobot.core.utils.requests import get_filterable_params_from_filter_params
 from nautobot.extras.datasources import ensure_git_repository, git_repository_dry_run, refresh_datasource_content
-from nautobot.extras.jobs import Job, ObjectVar
-from nautobot.extras.models import GitRepository
+from nautobot.extras.jobs import ChoiceVar, Job, ObjectVar, RunJobTaskFailed, StringVar
+from nautobot.extras.models import ExportTemplate, GitRepository
 
 name = "System Jobs"
 
@@ -59,5 +68,118 @@ class GitRepositoryDryRun(Job):
             self.logger.info(f"Repository dry run completed in {job_result.duration}")
 
 
-jobs = [GitRepositorySync, GitRepositoryDryRun]
+class ExportObjectList(Job):
+    """System Job to export a list of objects via CSV or ExportTemplate."""
+
+    content_type = ObjectVar(
+        model=ContentType,
+        description="Type of objects to export",
+        label="Content Type",
+    )
+    query_string = StringVar(
+        description='Filterset parameters to apply, in URL query parameter format e.g. "name=test&status=Active"',
+        label="Filterset Parameters",
+        default="",
+        required=False,
+    )
+    export_format = ChoiceVar(
+        choices=(("csv", "CSV"), ("yaml", "YAML")),
+        description="Format to export to if not using an Export Template<br>"
+        "(note, in core only <code>dcim | device type</code> supports YAML export at present)",
+        default="csv",
+        required=False,
+    )
+    export_template = ObjectVar(
+        model=ExportTemplate,
+        query_params={"content_type": "$content_type"},
+        display_field="name",
+        description="Export Template to use (if unspecified, will export to CSV/YAML as specified above)",
+        label="Export Template",
+        default=None,
+        required=False,
+    )
+
+    class Meta:
+        name = "Export Object List"
+        has_sensitive_variables = False
+        # Exporting large querysets may take substantial processing time
+        soft_time_limit = 1800
+        time_limit = 2000
+
+    def run(self, *, content_type, query_string="", export_format="csv", export_template=None):
+        if not self.user.has_perm(f"{content_type.app_label}.view_{content_type.model}"):
+            self.logger.error('User "%s" does not have permission to view %s objects', self.user, content_type.model)
+            raise PermissionDenied("User does not have view permissions on the requested content-type")
+
+        model = content_type.model_class()
+
+        # Start with all objects of the requested type
+        queryset = model.objects.all()
+        # Enforce user permissions
+        queryset = queryset.restrict(self.user, "view")
+
+        # Filter the queryset based on the provided query_string
+        filterset_class = get_filterset_for_model(model)
+        self.logger.debug("Found filterset class: `%s`", filterset_class.__name__)
+        # TODO: ideally the ObjectListView should strip its non_filter_params (which may vary by view!)
+        #       such that they never are even seen here.
+        query_params = QueryDict(query_string)
+        self.logger.debug("Parsed query_params: `%s`", query_params.dict())
+        default_non_filter_params = ("export", "page", "per_page", "sort")
+        filter_params = get_filterable_params_from_filter_params(
+            query_params, default_non_filter_params, filterset_class()
+        )
+        self.logger.debug("Filterset params: `%s`", filter_params)
+        filterset = filterset_class(filter_params, queryset)
+        if not filterset.is_valid():
+            self.logger.error("Invalid filters were specified: %s", filterset.errors)
+            raise RunJobTaskFailed("Invalid query_string value for this content_type")
+        queryset = filterset.qs
+        object_count = queryset.count()
+
+        filename = f"{settings.BRANDING_PREPENDED_FILENAME}{model._meta.verbose_name_plural.lower().replace(' ', '_')}"
+
+        if export_template is not None:
+            # Export templates
+            if export_template.content_type != content_type:
+                self.logger.error("ExportTemplate %s doesn't apply to %s", export_template, content_type)
+                raise RunJobTaskFailed("ExportTemplate ContentType mismatch")
+            self.logger.info(
+                "Exporting %d objects via ExportTemplate. This may take some time.",
+                object_count,
+                extra={"object": export_template},
+            )
+            try:
+                # export_template.render() consumes the whole queryset, so we don't have any way to do a progress bar.
+                output = export_template.render(queryset)
+            except Exception as err:
+                self.logger.error("Error when rendering ExportTemplate: %s", err)
+                raise
+            if export_template.file_extension:
+                filename += f".{export_template.file_extension}"
+            self.create_file(filename, output)
+
+        elif export_format == "yaml":
+            # Device-type (etc.) YAML export
+            if not hasattr(model, "to_yaml"):
+                self.logger.error("Model %s doesn't support YAML export", content_type.model)
+                raise ValueError("YAML export not supported for this content-type")
+            self.logger.info("Exporting %d objects to YAML. This may take some time.", object_count)
+            yaml_data = [obj.to_yaml() for obj in queryset]
+            self.create_file(filename + ".yaml", "---\n".join(yaml_data))
+
+        else:
+            # Generic CSV export
+            serializer_class = get_serializer_for_model(model)
+            self.logger.debug("Found serializer class: `%s`", serializer_class.__name__)
+            renderer = NautobotCSVRenderer()
+            self.logger.info("Exporting %d objects to CSV. This may take some time.", object_count)
+            # The force_csv=True attribute is a hack, but much easier than trying to construct a valid HttpRequest
+            # object from scratch that passes all implicit and explicit assumptions in Django and DRF.
+            serializer = serializer_class(queryset, many=True, context={"request": None}, force_csv=True)
+            csv_data = renderer.render(serializer.data)
+            self.create_file(filename + ".csv", csv_data)
+
+
+jobs = [ExportObjectList, GitRepositorySync, GitRepositoryDryRun]
 register_jobs(*jobs)

nautobot/core/management/commands/generate_test_data.py

@@ -63,7 +63,7 @@ class Command(BaseCommand):
                 ManufacturerFactory,
                 PlatformFactory,
             )
-            from nautobot.extras.factory import RoleFactory, StatusFactory, TagFactory
+            from nautobot.extras.factory import ExternalIntegrationFactory, RoleFactory, StatusFactory, TagFactory
             from nautobot.extras.management import populate_status_choices
             from nautobot.dcim.factory import (
                 LocationTypeFactory,
@@ -172,6 +172,11 @@ class Command(BaseCommand):
             has_description=True,
             using=db_name,
         )
+        self.stdout.write("Creating ExternalIntegrations...")
+        ExternalIntegrationFactory.create_batch(20, using=db_name)
+        # make sure we have some tenants that have null relationships to make filter tests happy
+        self.stdout.write("Creating Tenants without Circuits, Locations, IPAddresses, or Prefixes...")
+        TenantFactory.create_batch(10, using=db_name)
         # TODO: nautobot.tenancy.tests.test_filters currently calls the following additional factories:
         # UserFactory.create_batch(10)
         # RackFactory.create_batch(10)

nautobot/core/middleware.py

@@ -17,7 +17,8 @@ from nautobot.core.settings_funcs import (
     ldap_auth_enabled,
 )
 from nautobot.core.views import server_error
-from nautobot.extras.context_managers import change_logging, WebChangeContext
+from nautobot.extras.choices import ObjectChangeEventContextChoices
+from nautobot.extras.context_managers import web_request_context
 
 
 class RemoteUserMiddleware(RemoteUserMiddleware_):
@@ -92,11 +93,18 @@ class ObjectChangeMiddleware:
         except Resolver404:
             change_context_detail = ""
 
-        # Pass request rather than user here because at this point in the request handling logic, request.user may not have been set yet
-        change_context = WebChangeContext(request=request, context_detail=change_context_detail)
+        # Bypass change logging for health check requests to prevent database connection exhaustion
+        if change_context_detail == "health_check:health_check_home":
+            response = self.get_response(request)
+            return response
 
         # Process the request with change logging enabled
-        with change_logging(change_context):
+        with web_request_context(
+            request.user,
+            context_detail=change_context_detail,
+            context=ObjectChangeEventContextChoices.CONTEXT_WEB,
+            request=request,
+        ):
             response = self.get_response(request)
 
         return response

nautobot/core/models/fields.py

@@ -1,7 +1,6 @@
 import json
 import re
 
-from django.contrib.contenttypes.models import ContentType
 from django.core import exceptions
 from django.core.validators import RegexValidator, MaxLengthValidator
 from django.db import models
@@ -187,7 +186,18 @@ class ForeignKeyLimitedByContentTypes(ForeignKeyWithAutoRelatedName):
     """
 
     def get_limit_choices_to(self):
-        return {"content_types": ContentType.objects.get_for_model(self.model)}
+        """
+        Limit this field to only objects which are assigned to this model's content-type.
+
+        Note that this is implemented via specifying `content_types__app_label=` and `content_types__model=`
+        rather than via the more obvious `content_types=ContentType.objects.get_for_model(self.model)`
+        because the latter approach would involve a database query, and in some cases
+        (most notably FilterSet definition) this function is called **before** database migrations can be run.
+        """
+        return {
+            "content_types__app_label": self.model._meta.app_label,
+            "content_types__model": self.model._meta.model_name,
+        }
 
     def formfield(self, **kwargs):
         """Return a prepped formfield for use in model forms."""

nautobot/core/settings.py

@@ -87,6 +87,9 @@ HTTP_PROXIES = None
 # Send anonymized installation metrics when post_upgrade or send_installation_metrics management commands are run
 INSTALLATION_METRICS_ENABLED = is_truthy(os.getenv("NAUTOBOT_INSTALLATION_METRICS_ENABLED", "True"))
 
+# The storage backend to use for Job input files and Job output files
+JOB_FILE_IO_STORAGE = os.getenv("NAUTOBOT_JOB_FILE_IO_STORAGE", "db_file_storage.storage.DatabaseFileStorage")
+
 # The file path to a directory where locally installed Jobs can be discovered
 JOBS_ROOT = os.getenv("NAUTOBOT_JOBS_ROOT", os.path.join(NAUTOBOT_ROOT, "jobs").rstrip("/"))
 
@@ -611,12 +614,6 @@ CONSTANCE_CONFIG = {
         help_text="Whether to show the Feedback button in the new UI sidebar.",
         field_type=bool,
     ),
-    "HIDE_RESTRICTED_UI": ConstanceConfigItem(
-        default=False,
-        help_text="If set to True, users with limited permissions will not be shown menu items and home-page elements that "
-        "they do not have permission to access.",
-        field_type=bool,
-    ),
     "LOCATION_NAME_AS_NATURAL_KEY": ConstanceConfigItem(
         default=False,
         help_text="Location names are not guaranteed globally-unique by Nautobot but in practice they often are. "
@@ -645,7 +642,7 @@ CONSTANCE_CONFIG = {
     ),
     "NETWORK_DRIVERS": ConstanceConfigItem(
         default={},
-        help_text=mark_safe(
+        help_text=mark_safe(  # noqa: S308
             "Extend or override default Platform.network_driver translations provided by "
             '<a href="https://netutils.readthedocs.io/en/latest/user/lib_use_cases_lib_mapper/">netutils</a>. '
             "Enter a dictionary in JSON format, for example:\n"
@@ -700,7 +697,7 @@ CONSTANCE_CONFIG_FIELDSETS = {
     "Performance": ["DYNAMIC_GROUPS_MEMBER_CACHE_TIMEOUT"],
     "Rack Elevation Rendering": ["RACK_ELEVATION_DEFAULT_UNIT_HEIGHT", "RACK_ELEVATION_DEFAULT_UNIT_WIDTH"],
     "Release Checking": ["RELEASE_CHECK_URL", "RELEASE_CHECK_TIMEOUT"],
-    "User Interface": ["HIDE_RESTRICTED_UI", "FEEDBACK_BUTTON_ENABLED", "SUPPORT_MESSAGE"],
+    "User Interface": ["FEEDBACK_BUTTON_ENABLED", "SUPPORT_MESSAGE"],
 }
 
 #
@@ -839,6 +836,10 @@ BRANDING_FILEPATHS = {
     "icon_mask": os.getenv(
         "NAUTOBOT_BRANDING_FILEPATHS_ICON_MASK", None
     ),  # mono-chrome icon used for the mask-icon header
+    "header_bullet": os.getenv(
+        "NAUTOBOT_BRANDING_FILEPATHS_HEADER_BULLET", None
+    ),  # bullet image used for various view headers
+    "nav_bullet": os.getenv("NAUTOBOT_BRANDING_FILEPATHS_NAV_BULLET", None),  # bullet image used for nav menu headers
 }
 
 # Title to use in place of "Nautobot"