nautobot 2.4.13__py3-none-any.whl → 2.4.14__py3-none-any.whl

nautobot/extras/templates/extras/secretsgroup_edit.html

@@ -1,82 +1,2 @@
-{% extends 'generic/object_create.html' %}
-{% load static %}
-{% load form_helpers %}
-
-{% block form %}
-    <div class="panel panel-default">
-        <div class="panel-heading"><strong>Secrets Group</strong></div>
-        <div class="panel-body">
-            {% render_field form.name %}
-            {% render_field form.description %}
-        </div>
-    </div>
-    <div class="panel panel-default">
-        <div class="panel-heading"><strong>Secret Assignment</strong></div>
-        <div class="panel-body">
-            {% if secrets.errors %}
-                <div class="text-danger">
-                    Please correct the error(s) below:
-
-                    {% for secret in secrets.forms %}
-                        {% if secret.errors %}
-                            {% for error in secret.errors.values %}{{ error }}{% endfor %}
-                        {% endif %}
-                    {% endfor %}
-                </div>
-            {% endif %}
-            {{ secrets.non_field_errors }}
-            <table class="table" id="secrets">
-                {{ secrets.management_form }}
-                {% for secret_form in secrets.forms %}
-                    {% if forloop.first %}
-                        <thead>
-                            <tr>
-                                {% for field in secret_form.visible_fields %}
-                                    <th>{{ field.label|capfirst }}</th>
-                                {% endfor %}
-                            </tr>
-                        </thead>
-                    {% endif %}
-                    <tr class="formset_row-{{ secrets.prefix }}">
-                        {% for field in secret_form.visible_fields %}
-                            <td>
-                                {% if forloop.first %}
-                                    {% for hidden in secret_form.hidden_fields %}
-                                        {{ hidden }}
-                                    {% endfor %}
-                                {% endif %}
-                                {{ field }}
-                                {% if field.errors %}
-                                    <ul>
-                                        {% for error in field.errors %}
-                                            {# Embed an HTML comment indicating the error for extraction by tests #}
-                                            <!-- FORM-ERROR {{ field.name }}: {{ error }} -->
-                                            <li class="text-danger">{{ error }}</li>
-                                        {% endfor %}
-                                    </ul>
-                                {% endif %}
-                            </td>
-                        {% endfor %}
-                    </tr>
-                {% endfor %}
-            </table>
-        </div>
-    </div>
-    {% include "inc/extras_features_edit_form_fields.html" %}
-{% endblock form %}
-
-{% block javascript %}
-{{ block.super }}
-<script src="{% static 'jquery/jquery.formset.js' %}"></script>
-<script type="text/javascript">
-    $('.formset_row-{{ secrets.prefix }}').formset({
-        addText: '<span class="mdi mdi-plus-thick" aria-hidden="true"></span> Add another Secret',
-        addCssClass: 'btn btn-primary add-row',
-        deleteText: '<span class="mdi mdi-trash-can-outline" aria-hidden="true"></span>',
-        deleteCssClass: 'btn btn-danger delete-row',
-        prefix: '{{ secrets.prefix }}',
-        formCssClass: 'dynamic-formset-{{ secrets.prefix }}',
-        added: jsify_form
-    });
-</script>
-{% endblock javascript %}
+{% extends 'extras/secretsgroup_update.html' %}
+{% comment %}3.0 TODO: remove this template, which only exists for backward compatibility with 2.4 and earlier{% endcomment %}

nautobot/extras/templates/extras/secretsgroup_retrieve.html

@@ -0,0 +1,29 @@
+{% extends "generic/object_retrieve.html" %}
+{% load helpers %}
+
+{% block content_left_page %}
+    <div class="panel panel-default">
+        <div class="panel-heading">
+            <strong>Secrets Group</strong>
+        </div>
+        <table class="table table-hover panel-body attr-table">
+            <tr>
+                <td>Description</td>
+                <td colspan="3">{{ object.description | placeholder }}</td>
+            </tr>
+            <tr>
+                <td rowspan="{{ secrets_group_associations | length | add:'1'}}">Secrets</td>
+                <th>Access Type</th>
+                <th>Secret Type</th>
+                <th>Secret</th>
+            </tr>
+            {% for secret_association in secrets_group_associations %}
+                <tr>
+                    <td>{{ secret_association.access_type }}</td>
+                    <td>{{ secret_association.secret_type | bettertitle }}</td>
+                    <td>{{ secret_association.secret|hyperlinked_object }}</td>
+                </tr>
+            {% endfor %}
+        </table>
+    </div>
+{% endblock content_left_page %}

nautobot/extras/templates/extras/secretsgroup_update.html

@@ -0,0 +1,82 @@
+{% extends 'generic/object_create.html' %}
+{% load static %}
+{% load form_helpers %}
+
+{% block form %}
+    <div class="panel panel-default">
+        <div class="panel-heading"><strong>Secrets Group</strong></div>
+        <div class="panel-body">
+            {% render_field form.name %}
+            {% render_field form.description %}
+        </div>
+    </div>
+    <div class="panel panel-default">
+        <div class="panel-heading"><strong>Secret Assignment</strong></div>
+        <div class="panel-body">
+            {% if secrets.errors %}
+                <div class="text-danger">
+                    Please correct the error(s) below:
+
+                    {% for secret in secrets.forms %}
+                        {% if secret.errors %}
+                            {% for error in secret.errors.values %}{{ error }}{% endfor %}
+                        {% endif %}
+                    {% endfor %}
+                </div>
+            {% endif %}
+            {{ secrets.non_field_errors }}
+            <table class="table" id="secrets">
+                {{ secrets.management_form }}
+                {% for secret_form in secrets.forms %}
+                    {% if forloop.first %}
+                        <thead>
+                            <tr>
+                                {% for field in secret_form.visible_fields %}
+                                    <th>{{ field.label|capfirst }}</th>
+                                {% endfor %}
+                            </tr>
+                        </thead>
+                    {% endif %}
+                    <tr class="formset_row-{{ secrets.prefix }}">
+                        {% for field in secret_form.visible_fields %}
+                            <td>
+                                {% if forloop.first %}
+                                    {% for hidden in secret_form.hidden_fields %}
+                                        {{ hidden }}
+                                    {% endfor %}
+                                {% endif %}
+                                {{ field }}
+                                {% if field.errors %}
+                                    <ul>
+                                        {% for error in field.errors %}
+                                            {# Embed an HTML comment indicating the error for extraction by tests #}
+                                            <!-- FORM-ERROR {{ field.name }}: {{ error }} -->
+                                            <li class="text-danger">{{ error }}</li>
+                                        {% endfor %}
+                                    </ul>
+                                {% endif %}
+                            </td>
+                        {% endfor %}
+                    </tr>
+                {% endfor %}
+            </table>
+        </div>
+    </div>
+    {% include "inc/extras_features_edit_form_fields.html" %}
+{% endblock form %}
+
+{% block javascript %}
+{{ block.super }}
+<script src="{% static 'jquery/jquery.formset.js' %}"></script>
+<script type="text/javascript">
+    $('.formset_row-{{ secrets.prefix }}').formset({
+        addText: '<span class="mdi mdi-plus-thick" aria-hidden="true"></span> Add another Secret',
+        addCssClass: 'btn btn-primary add-row',
+        deleteText: '<span class="mdi mdi-trash-can-outline" aria-hidden="true"></span>',
+        deleteCssClass: 'btn btn-danger delete-row',
+        prefix: '{{ secrets.prefix }}',
+        formCssClass: 'dynamic-formset-{{ secrets.prefix }}',
+        added: jsify_form
+    });
+</script>
+{% endblock javascript %}

nautobot/extras/tests/test_customfields.py

@@ -4,7 +4,7 @@ import logging
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
-from django.db.models import ProtectedError
+from django.db.models import ProtectedError, QuerySet
 from django.forms import ChoiceField, IntegerField, NumberInput
 from django.urls import reverse
 from rest_framework import status
@@ -400,28 +400,46 @@ class CustomFieldTest(ModelTestCases.BaseModelTestCase, TestCase):
 class CustomFieldManagerTest(TestCase):
     def setUp(self):
         self.content_type = ContentType.objects.get_for_model(Location)
-        custom_field = CustomField(type=CustomFieldTypeChoices.TYPE_TEXT, label="Text Field", default="foo")
+        custom_field = CustomField(
+            type=CustomFieldTypeChoices.TYPE_TEXT,
+            label="Text Field",
+            default="foo",
+            filter_logic=CustomFieldFilterLogicChoices.FILTER_DISABLED,
+        )
         custom_field.save()
         custom_field.content_types.set([self.content_type])
 
     def test_get_for_model(self):
         self.assertEqual(CustomField.objects.get_for_model(Location).count(), 2)
         self.assertEqual(CustomField.objects.get_for_model(VirtualMachine).count(), 0)
+        self.assertEqual(len(CustomField.objects.get_for_model(Location, get_queryset=False)), 2)
+        self.assertEqual(len(CustomField.objects.get_for_model(VirtualMachine, get_queryset=False)), 0)
 
     def test_get_for_model_caching_and_cache_invalidation(self):
         """Test that the cache is used and is properly invalidated when CustomFields are created or deleted."""
         # Assert that the cache is used when calling get_for_model a second time
         CustomField.objects.get_for_model(Location)
         with self.assertNumQueries(0):
-            CustomField.objects.get_for_model(Location)
+            qs = CustomField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            listing = CustomField.objects.get_for_model(Location, get_queryset=False)
+        self.assertIsInstance(qs, QuerySet)
+        self.assertIsInstance(listing, list)
+        self.assertQuerysetEqualAndNotEmpty(qs, listing)
 
         # Assert that different values of exclude_filter_disabled are cached separately
         with self.assertNumQueries(1):
             CustomField.objects.get_for_model(Location, exclude_filter_disabled=True)
         with self.assertNumQueries(0):
-            CustomField.objects.get_for_model(Location, exclude_filter_disabled=True)
+            qs = CustomField.objects.get_for_model(Location, exclude_filter_disabled=True)
+        with self.assertNumQueries(0):
+            listing = CustomField.objects.get_for_model(Location, exclude_filter_disabled=True, get_queryset=False)
         with self.assertNumQueries(0):
             CustomField.objects.get_for_model(Location)
+        self.assertIsInstance(qs, QuerySet)
+        self.assertIsInstance(listing, list)
+        self.assertEqual(1, len(listing))
+        self.assertQuerysetEqualAndNotEmpty(qs, listing)
 
         # Assert that different models are cached separately
         with self.assertNumQueries(1):
@@ -444,21 +462,111 @@ class CustomFieldManagerTest(TestCase):
         with self.assertNumQueries(1):
             CustomField.objects.get_for_model(Location)
         with self.assertNumQueries(0):
-            CustomField.objects.get_for_model(Location)
+            qs = CustomField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            listing = CustomField.objects.get_for_model(Location, get_queryset=False)
+        self.assertIsInstance(qs, QuerySet)
+        self.assertIsInstance(listing, list)
+        self.assertEqual(3, len(listing))
+        self.assertQuerysetEqualAndNotEmpty(qs, listing)
 
         # Assert that the cache is invalidated when removing a CustomField.content_types m2m relationship
         custom_field.content_types.set([])
         with self.assertNumQueries(1):
             CustomField.objects.get_for_model(Location)
         with self.assertNumQueries(0):
-            CustomField.objects.get_for_model(Location)
+            qs = CustomField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            listing = CustomField.objects.get_for_model(Location, get_queryset=False)
+        self.assertIsInstance(qs, QuerySet)
+        self.assertIsInstance(listing, list)
+        self.assertEqual(2, len(listing))
+        self.assertQuerysetEqualAndNotEmpty(qs, listing)
 
         # Assert that the cache is invalidated on object delete
         custom_field.delete()
         with self.assertNumQueries(1):
             CustomField.objects.get_for_model(Location)
         with self.assertNumQueries(0):
-            CustomField.objects.get_for_model(Location)
+            qs = CustomField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            listing = CustomField.objects.get_for_model(Location, get_queryset=False)
+        self.assertIsInstance(qs, QuerySet)
+        self.assertIsInstance(listing, list)
+        self.assertEqual(2, len(listing))
+        self.assertQuerysetEqualAndNotEmpty(qs, listing)
+
+
+class ComputedFieldManagerTestCase(TestCase):
+    def setUp(self):
+        self.content_type = ContentType.objects.get_for_model(Location)
+        ComputedField.objects.create(
+            content_type=ContentType.objects.get_for_model(Location),
+            key="computed_field_one",
+            label="Computed Field One",
+            template="{{ obj.name }} is the name of this location.",
+            fallback_value="An error occurred while rendering this template.",
+            weight=100,
+        )
+
+    def test_get_for_model(self):
+        self.assertEqual(ComputedField.objects.get_for_model(Location).count(), 1)
+        self.assertEqual(ComputedField.objects.get_for_model(VirtualMachine).count(), 0)
+        self.assertEqual(len(ComputedField.objects.get_for_model(Location, get_queryset=False)), 1)
+        self.assertEqual(len(ComputedField.objects.get_for_model(VirtualMachine, get_queryset=False)), 0)
+
+    def test_get_for_model_caching_and_cache_invalidation(self):
+        # Assert that the cache is used when calling get_for_model a second time
+        ComputedField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            qs = ComputedField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            listing = ComputedField.objects.get_for_model(Location, get_queryset=False)
+        self.assertIsInstance(qs, QuerySet)
+        self.assertIsInstance(listing, list)
+        self.assertEqual(1, len(listing))
+        self.assertQuerysetEqualAndNotEmpty(qs, listing)
+
+        # Assert that different models are cached separately
+        with self.assertNumQueries(1):
+            ComputedField.objects.get_for_model(VirtualMachine)
+        with self.assertNumQueries(0):
+            ComputedField.objects.get_for_model(VirtualMachine)
+        with self.assertNumQueries(0):
+            ComputedField.objects.get_for_model(Location)
+
+        # Assert that the cache is invalidated on object save
+        computed_field = ComputedField.objects.create(
+            content_type=ContentType.objects.get_for_model(Location),
+            key="computed_field_two",
+            label="Computed Field Two",
+            template="{{ obj.name }} is still jthe name of this location.",
+            fallback_value="An error occurred while rendering this template.",
+            weight=200,
+        )
+        with self.assertNumQueries(1):
+            ComputedField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            qs = ComputedField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            listing = ComputedField.objects.get_for_model(Location, get_queryset=False)
+        self.assertIsInstance(qs, QuerySet)
+        self.assertIsInstance(listing, list)
+        self.assertEqual(2, len(listing))
+        self.assertQuerysetEqualAndNotEmpty(qs, listing)
+
+        # Assert that the cache is invalided on object delete
+        computed_field.delete()
+        with self.assertNumQueries(1):
+            ComputedField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            qs = ComputedField.objects.get_for_model(Location)
+        with self.assertNumQueries(0):
+            listing = ComputedField.objects.get_for_model(Location, get_queryset=False)
+        self.assertIsInstance(qs, QuerySet)
+        self.assertIsInstance(listing, list)
+        self.assertEqual(1, len(listing))
+        self.assertQuerysetEqualAndNotEmpty(qs, listing)
 
 
 class CustomFieldDataAPITest(APITestCase):

nautobot/extras/tests/test_relationships.py

@@ -482,10 +482,12 @@ class RelationshipTest(RelationshipBaseTest, ModelTestCases.BaseModelTestCase):
                 # Assert that the cache is used when calling method a second time
                 with self.assertNumQueries(0):
                     manager_method(Location)
+                with self.assertNumQueries(0):
+                    manager_method(Location, get_queryset=False)
 
                 # Assert that different models are cached separately
                 with self.assertNumQueries(expected_queries):
-                    manager_method(Rack)
+                    manager_method(Rack, get_queryset=False)
                 with self.assertNumQueries(0):
                     manager_method(Rack)
                 with self.assertNumQueries(0):
@@ -507,6 +509,8 @@ class RelationshipTest(RelationshipBaseTest, ModelTestCases.BaseModelTestCase):
                         manager_method(Location)
                     with self.assertNumQueries(0):
                         manager_method(Location)
+                    with self.assertNumQueries(0):
+                        manager_method(Location, get_queryset=False)
                 finally:
                     # Assert that the cache is invalidated on object delete
                     relationship.delete()
@@ -514,6 +518,8 @@ class RelationshipTest(RelationshipBaseTest, ModelTestCases.BaseModelTestCase):
                     manager_method(Location)
                 with self.assertNumQueries(0):
                     manager_method(Location)
+                with self.assertNumQueries(0):
+                    manager_method(Location, get_queryset=False)
 
     def test_required_related_object_errors(self):
         """

nautobot/extras/tests/test_views.py

@@ -1850,8 +1850,18 @@ class SecretTestCase(
         }
 
 
-class SecretsGroupTestCase(ViewTestCases.OrganizationalObjectViewTestCase):
+class SecretsGroupTestCase(
+    ViewTestCases.OrganizationalObjectViewTestCase,
+    ViewTestCases.BulkEditObjectsViewTestCase,
+):
     model = SecretsGroup
+    custom_test_permissions = [
+        "extras.view_secret",
+        "extras.add_secretsgroup",
+        "extras.view_secretsgroup",
+        "extras.add_secretsgroupassociation",
+        "extras.change_secretsgroupassociation",
+    ]
 
     @classmethod
     def setUpTestData(cls):
@@ -1895,6 +1905,108 @@ class SecretsGroupTestCase(ViewTestCases.OrganizationalObjectViewTestCase):
             "secrets_group_associations-MIN_NUM_FORMS": "0",
             "secrets_group_associations-MAX_NUM_FORMS": "1000",
         }
+        cls.bulk_edit_data = {
+            "description": "This is a very detailed new description",
+        }
+
+    def test_create_group_with_valid_secret_association(self):
+        """Test that a SecretsGroup with a valid Secret association saves correctly via the formset."""
+        self.add_permissions(*self.custom_test_permissions)
+        # Create a secret to associate
+        secret = Secret.objects.create(
+            name="AWS_Secret",
+            provider="text-file",
+            parameters={"path": "/tmp"},  # noqa: S108  # hardcoded-temp-file -- false positive
+        )
+
+        form_data = {
+            "name": "test",
+            "description": "test bulk edits",
+            "secrets_group_associations-TOTAL_FORMS": "1",
+            "secrets_group_associations-INITIAL_FORMS": "0",
+            "secrets_group_associations-MIN_NUM_FORMS": "0",
+            "secrets_group_associations-MAX_NUM_FORMS": "1000",
+            "secrets_group_associations-0-secret": secret.pk,
+            "secrets_group_associations-0-access_type": SecretsGroupAccessTypeChoices.TYPE_HTTP,
+            "secrets_group_associations-0-secret_type": SecretsGroupSecretTypeChoices.TYPE_PASSWORD,
+        }
+
+        # Submit the form to the "add SecretsGroup" view
+        response = self.client.post(reverse("extras:secretsgroup_add"), data=form_data, follow=True)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue(SecretsGroup.objects.filter(name="test").exists())
+
+        # Checks that the association was created correctly
+        group = SecretsGroup.objects.get(name="test")
+        self.assertEqual(group.secrets_group_associations.count(), 1)
+
+        association = group.secrets_group_associations.first()
+        self.assertEqual(association.secret, secret)
+        self.assertEqual(association.access_type, SecretsGroupAccessTypeChoices.TYPE_HTTP)
+        self.assertEqual(association.secret_type, SecretsGroupSecretTypeChoices.TYPE_PASSWORD)
+
+    def test_create_group_with_invalid_secret_association(self):
+        """Test that invalid Secret association formset raises validation error and does not save."""
+        self.add_permissions(*self.custom_test_permissions)
+        url = reverse("extras:secretsgroup_add")
+
+        form_data = {
+            "name": "Invalid Secrets Group",
+            "description": "Missing required fields",
+            "secrets_group_associations-TOTAL_FORMS": "1",
+            "secrets_group_associations-INITIAL_FORMS": "0",
+            "secrets_group_associations-MIN_NUM_FORMS": "0",
+            "secrets_group_associations-MAX_NUM_FORMS": "1000",
+            "secrets_group_associations-0-secret": "",  # invalid
+            "secrets_group_associations-0-access_type": SecretsGroupAccessTypeChoices.TYPE_HTTP,
+            "secrets_group_associations-0-secret_type": "",  # invalid
+        }
+
+        response = self.client.post(url, data=form_data)
+
+        self.assertEqual(response.status_code, 200)
+
+        # Checks that no new SecretsGroup was created
+        self.assertFalse(SecretsGroup.objects.filter(name="Invalid Secrets Group").exists())
+
+        # Checks that formset errors are raised in the context
+        self.assertFormsetError(
+            response.context["secrets"], form_index=0, field="secret", errors=["This field is required."]
+        )
+
+    def test_create_group_with_deleted_secret_fails_cleanly(self):
+        """
+        Creating a SecretsGroup with a deleted Secret should fail with a formset error.
+        """
+        self.add_permissions(*self.custom_test_permissions)
+
+        secret = Secret.objects.create(name="TempSecret", provider="text-file", parameters={"path": "/tmp"})  # noqa: S108  # hardcoded-temp-file -- false positive
+        secret_pk = secret.pk
+        secret.delete()
+
+        form_data = {
+            "name": "Test Group",
+            "description": "This should not be created",
+            "secrets_group_associations-TOTAL_FORMS": "1",
+            "secrets_group_associations-INITIAL_FORMS": "0",
+            "secrets_group_associations-MIN_NUM_FORMS": "0",
+            "secrets_group_associations-MAX_NUM_FORMS": "1000",
+            "secrets_group_associations-0-secret": secret_pk,
+            "secrets_group_associations-0-access_type": SecretsGroupAccessTypeChoices.TYPE_HTTP,
+            "secrets_group_associations-0-secret_type": SecretsGroupSecretTypeChoices.TYPE_PASSWORD,
+        }
+
+        response = self.client.post(reverse("extras:secretsgroup_add"), data=form_data)
+        self.assertEqual(response.status_code, 200)
+
+        self.assertFormsetError(
+            response.context["secrets"],
+            form_index=0,
+            field="secret",
+            errors=["Select a valid choice. That choice is not one of the available choices."],
+        )
+        self.assertFalse(SecretsGroup.objects.filter(name="Test Group").exists())
 
 
 class GraphQLQueriesTestCase(

nautobot/extras/urls.py

@@ -6,11 +6,9 @@ from nautobot.extras.models import (
     CustomField,
     DynamicGroup,
     GitRepository,
-    GraphQLQuery,
     Job,
     Note,
     Relationship,
-    SecretsGroup,
 )
 
 app_name = "extras"
@@ -24,6 +22,7 @@ router.register("contact-associations", views.ContactAssociationUIViewSet)
 router.register("custom-links", views.CustomLinkUIViewSet)
 router.register("export-templates", views.ExportTemplateUIViewSet)
 router.register("external-integrations", views.ExternalIntegrationUIViewSet)
+router.register("graphql-queries", views.GraphQLQueryUIViewSet)
 router.register("job-buttons", views.JobButtonUIViewSet)
 router.register("job-hooks", views.JobHookUIViewSet)
 router.register("job-queues", views.JobQueueUIViewSet)
@@ -34,6 +33,7 @@ router.register("relationships", views.RelationshipUIViewSet)
 router.register("roles", views.RoleUIViewSet)
 router.register("saved-views", views.SavedViewUIViewSet)
 router.register("secrets", views.SecretUIViewSet)
+router.register("secrets-groups", views.SecretsGroupUIViewSet)
 router.register("static-group-associations", views.StaticGroupAssociationUIViewSet)
 router.register("statuses", views.StatusUIViewSet)
 router.register("tags", views.TagUIViewSet)
@@ -181,37 +181,6 @@ urlpatterns = [
         views.GitRepositoryDryRunView.as_view(),
         name="gitrepository_dryrun",
     ),
-    # GraphQL Queries
-    path("graphql-queries/", views.GraphQLQueryListView.as_view(), name="graphqlquery_list"),
-    path("graphql-queries/add/", views.GraphQLQueryEditView.as_view(), name="graphqlquery_add"),
-    path(
-        "graphql-queries/delete/",
-        views.GraphQLQueryBulkDeleteView.as_view(),
-        name="GraphQLQuery_bulk_delete",
-    ),
-    path("graphql-queries/<uuid:pk>/", views.GraphQLQueryView.as_view(), name="graphqlquery"),
-    path(
-        "graphql-queries/<uuid:pk>/edit/",
-        views.GraphQLQueryEditView.as_view(),
-        name="graphqlquery_edit",
-    ),
-    path(
-        "graphql-queries/<uuid:pk>/delete/",
-        views.GraphQLQueryDeleteView.as_view(),
-        name="graphqlquery_delete",
-    ),
-    path(
-        "graphql-queries/<uuid:pk>/changelog/",
-        views.ObjectChangeLogView.as_view(),
-        name="graphqlquery_changelog",
-        kwargs={"model": GraphQLQuery},
-    ),
-    path(
-        "graphql-queries/<uuid:pk>/notes/",
-        views.ObjectNotesView.as_view(),
-        name="graphqlquery_notes",
-        kwargs={"model": GraphQLQuery},
-    ),
     # Image attachments
     path(
         "image-attachments/<uuid:pk>/edit/",
@@ -311,24 +280,6 @@ urlpatterns = [
         views.SecretProviderParametersFormView.as_view(),
         name="secret_provider_parameters_form",
     ),
-    path("secrets-groups/", views.SecretsGroupListView.as_view(), name="secretsgroup_list"),
-    path("secrets-groups/add/", views.SecretsGroupEditView.as_view(), name="secretsgroup_add"),
-    path("secrets-groups/delete/", views.SecretsGroupBulkDeleteView.as_view(), name="secretsgroup_bulk_delete"),
-    path("secrets-groups/<uuid:pk>/", views.SecretsGroupView.as_view(), name="secretsgroup"),
-    path("secrets-groups/<uuid:pk>/edit/", views.SecretsGroupEditView.as_view(), name="secretsgroup_edit"),
-    path("secrets-groups/<uuid:pk>/delete/", views.SecretsGroupDeleteView.as_view(), name="secretsgroup_delete"),
-    path(
-        "secrets-groups/<uuid:pk>/changelog/",
-        views.ObjectChangeLogView.as_view(),
-        name="secretsgroup_changelog",
-        kwargs={"model": SecretsGroup},
-    ),
-    path(
-        "secrets-groups/<uuid:pk>/notes/",
-        views.ObjectNotesView.as_view(),
-        name="secretsgroup_notes",
-        kwargs={"model": SecretsGroup},
-    ),
 ]
 
 urlpatterns += router.urls

nautobot/extras/utils.py

@@ -275,11 +275,14 @@ def extras_features(*features):
     """
 
     def wrapper(model_class):
-        # Initialize the model_features store if not already defined
+        # Initialize the model_features and feature_models stores if not already defined
         if "model_features" not in registry:
             registry["model_features"] = {f: collections.defaultdict(list) for f in EXTRAS_FEATURES}
+        if "feature_models" not in registry:
+            registry["feature_models"] = {f: [] for f in EXTRAS_FEATURES}
         for feature in features:
             if feature in EXTRAS_FEATURES:
+                registry["feature_models"][feature].append(model_class)
                 app_label, model_name = model_class._meta.label_lower.split(".")
                 registry["model_features"][feature][app_label].append(model_name)
             else: