nautobot 2.2.4__py3-none-any.whl → 2.2.6__py3-none-any.whl

nautobot/extras/api/views.py

@@ -304,13 +304,13 @@ class DynamicGroupViewSet(NotesViewSetMixin, ModelViewSet):
     # @extend_schema(methods=["get"], responses={200: member_response})
     @action(detail=True, methods=["get"])
     def members(self, request, pk, *args, **kwargs):
-        """List member objects of the same type as the `content_type` for this dynamic group."""
+        """List the member objects of this dynamic group."""
         instance = get_object_or_404(self.queryset, pk=pk)
 
         # Retrieve the serializer for the content_type and paginate the results
         member_model_class = instance.content_type.model_class()
         member_serializer_class = get_serializer_for_model(member_model_class)
-        members = self.paginate_queryset(instance.members)
+        members = self.paginate_queryset(instance.members.restrict(request.user, "view"))
         member_serializer = member_serializer_class(members, many=True, context={"request": request})
         return self.get_paginated_response(member_serializer.data)
 

nautobot/extras/context_managers.py

@@ -91,9 +91,12 @@ class ChangeContext:
                 for entry in self.deferred_object_changes[key]:
                     objectchange = entry["instance"].to_objectchange(entry["action"])
                     objectchange.user = entry["user"]
+                    objectchange.user_name = objectchange.user.username
                     objectchange.request_id = self.change_id
                     objectchange.change_context = self.context
                     objectchange.change_context_detail = self.context_detail[:CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL]
+                    if not objectchange.changed_object_id:
+                        objectchange.changed_object_id = entry.get("changed_object_id")
                     create_object_changes.append(objectchange)
                 self.deferred_object_changes.pop(key, None)
             ObjectChange.objects.bulk_create(create_object_changes, batch_size=batch_size)

nautobot/extras/datasources/git.py

@@ -136,7 +136,7 @@ def get_repo_from_url_to_path_and_from_branch(repository_record):
 
 def ensure_git_repository(repository_record, logger=None, head=None):  # pylint: disable=redefined-outer-name
     """Ensure that the given Git repo is present, up-to-date, and has the correct branch selected.
-    Note that this function may be called independently of the `GitRepositoryiSync` job,
+    Note that this function may be called independently of the `GitRepositorySync` job,
     such as to ensure that different Nautobot instances and/or worker instances all have a local copy of the same HEAD.
     Args:
       repository_record (GitRepository): Repository to ensure the state of.
@@ -224,126 +224,127 @@ def refresh_git_config_contexts(repository_record, job_result, delete=False):
 def update_git_config_contexts(repository_record, job_result):
     """Refresh any config contexts provided by this Git repository."""
     config_context_path = os.path.join(repository_record.filesystem_path, "config_contexts")
-    if not os.path.isdir(config_context_path):
-        return
-
     managed_config_contexts = set()
     managed_local_config_contexts = defaultdict(set)
 
-    # First, handle the "flat file" case - data files in the root config_context_path,
-    # whose metadata is expressed purely within the contents of the file:
-    for file_name in os.listdir(config_context_path):
-        if not os.path.isfile(os.path.join(config_context_path, file_name)):
-            continue
-        msg = f"Loading config context from `{file_name}`"
-        logger.info(msg)
-        job_result.log(msg, grouping="config contexts")
-        try:
-            with open(os.path.join(config_context_path, file_name), "r") as fd:
-                # The data file can be either JSON or YAML; since YAML is a superset of JSON, we can load it regardless
-                context_data = yaml.safe_load(fd)
-
-            # A file can contain one config context dict or a list thereof
-            if isinstance(context_data, dict):
-                context_name = import_config_context(context_data, repository_record, job_result)
-                managed_config_contexts.add(context_name)
-            elif isinstance(context_data, list):
-                for context_data_entry in context_data:
-                    context_name = import_config_context(context_data_entry, repository_record, job_result)
-                    managed_config_contexts.add(context_name)
-            else:
-                raise RuntimeError("data must be a dict or list of dicts")
-
-        except Exception as exc:
-            msg = f"Error in loading config context data from `{file_name}`: {exc}"
-            logger.error(msg)
-            job_result.log(msg, level_choice=LogLevelChoices.LOG_ERROR, grouping="config contexts")
-
-    # Next, handle the "filter/name" directory structure case - files in <filter_type>/<name>.(json|yaml)
-    for filter_type in (
-        "locations",
-        "device_types",
-        "roles",
-        "platforms",
-        "cluster_groups",
-        "clusters",
-        "tenant_groups",
-        "tenants",
-        "tags",
-        "dynamic_groups",
-        "device_redundancy_groups",
-    ):
-        if os.path.isdir(os.path.join(repository_record.filesystem_path, filter_type)):
-            msg = (
-                f'Found "{filter_type}" directory in the repository root. If this is meant to contain config contexts, '
-                "it should be moved into a `config_contexts/` subdirectory."
-            )
-            logger.warning(msg)
-            job_result.log(msg, level_choice=LogLevelChoices.LOG_WARNING, grouping="config contexts")
-
-        dir_path = os.path.join(config_context_path, filter_type)
-        if not os.path.isdir(dir_path):
-            continue
-
-        for file_name in os.listdir(dir_path):
-            name = os.path.splitext(file_name)[0]
-            msg = f'Loading config context, filter `{filter_type} = [name: "{name}"]`, from `{filter_type}/{file_name}`'
+    if os.path.isdir(config_context_path):
+        # First, handle the "flat file" case - data files in the root config_context_path,
+        # whose metadata is expressed purely within the contents of the file:
+        for file_name in os.listdir(config_context_path):
+            if not os.path.isfile(os.path.join(config_context_path, file_name)):
+                continue
+            msg = f"Loading config context from `{file_name}`"
             logger.info(msg)
             job_result.log(msg, grouping="config contexts")
             try:
-                with open(os.path.join(dir_path, file_name), "r") as fd:
-                    # Data file can be either JSON or YAML; since YAML is a superset of JSON, we can load it regardless
+                with open(os.path.join(config_context_path, file_name), "r") as fd:
+                    # The data file can be either JSON or YAML; since YAML is a superset of JSON, we load it regardless
                     context_data = yaml.safe_load(fd)
 
-                # Unlike the above case, these files always contain just a single config context record
-
-                # Add the implied filter to the context metadata
-                if filter_type == "device_types":
-                    context_data.setdefault("_metadata", {}).setdefault(filter_type, []).append({"model": name})
+                # A file can contain one config context dict or a list thereof
+                if isinstance(context_data, dict):
+                    context_name = import_config_context(context_data, repository_record, job_result)
+                    managed_config_contexts.add(context_name)
+                elif isinstance(context_data, list):
+                    for context_data_entry in context_data:
+                        context_name = import_config_context(context_data_entry, repository_record, job_result)
+                        managed_config_contexts.add(context_name)
                 else:
-                    context_data.setdefault("_metadata", {}).setdefault(filter_type, []).append({"name": name})
+                    raise RuntimeError("data must be a dict or list of dicts")
 
-                context_name = import_config_context(context_data, repository_record, job_result)
-                managed_config_contexts.add(context_name)
             except Exception as exc:
                 msg = f"Error in loading config context data from `{file_name}`: {exc}"
                 logger.error(msg)
                 job_result.log(msg, level_choice=LogLevelChoices.LOG_ERROR, grouping="config contexts")
 
-    # Finally, handle device- and virtual-machine-specific "local" context in (devices|virtual_machines)/<name>.(json|yaml)
-    for local_type in ("devices", "virtual_machines"):
-        if os.path.isdir(os.path.join(repository_record.filesystem_path, local_type)):
-            msg = (
-                f'Found "{local_type}" directory in the repository root. If this is meant to contain config contexts, '
-                "it should be moved into a `config_contexts/` subdirectory."
-            )
-            logger.warning(msg)
-            job_result.log(msg, level_choice=LogLevelChoices.LOG_WARNING, grouping="config contexts")
+        # Next, handle the "filter/name" directory structure case - files in <filter_type>/<name>.(json|yaml)
+        for filter_type in (
+            "locations",
+            "device_types",
+            "roles",
+            "platforms",
+            "cluster_groups",
+            "clusters",
+            "tenant_groups",
+            "tenants",
+            "tags",
+            "dynamic_groups",
+            "device_redundancy_groups",
+        ):
+            if os.path.isdir(os.path.join(repository_record.filesystem_path, filter_type)):
+                msg = (
+                    f'Found "{filter_type}" directory in the repository root. If this is meant to contain config contexts, '
+                    "it should be moved into a `config_contexts/` subdirectory."
+                )
+                logger.warning(msg)
+                job_result.log(msg, level_choice=LogLevelChoices.LOG_WARNING, grouping="config contexts")
 
-        dir_path = os.path.join(config_context_path, local_type)
-        if not os.path.isdir(dir_path):
-            continue
+            dir_path = os.path.join(config_context_path, filter_type)
+            if not os.path.isdir(dir_path):
+                continue
 
-        for file_name in os.listdir(dir_path):
-            device_name = os.path.splitext(file_name)[0]
-            msg = f"Loading local config context for `{device_name}` from `{local_type}/{file_name}`"
-            logger.info(msg)
-            job_result.log(msg, grouping="local config contexts")
-            try:
-                with open(os.path.join(dir_path, file_name), "r") as fd:
-                    context_data = yaml.safe_load(fd)
+            for file_name in os.listdir(dir_path):
+                name = os.path.splitext(file_name)[0]
+                msg = (
+                    f'Loading config context, filter `{filter_type} = [name: "{name}"]`, '
+                    f"from `{filter_type}/{file_name}`"
+                )
+                logger.info(msg)
+                job_result.log(msg, grouping="config contexts")
+                try:
+                    with open(os.path.join(dir_path, file_name), "r") as fd:
+                        # Data file can be either JSON or YAML; since YAML is a superset of JSON, we load it regardless
+                        context_data = yaml.safe_load(fd)
+
+                    # Unlike the above case, these files always contain just a single config context record
+
+                    # Add the implied filter to the context metadata
+                    if filter_type == "device_types":
+                        context_data.setdefault("_metadata", {}).setdefault(filter_type, []).append({"model": name})
+                    else:
+                        context_data.setdefault("_metadata", {}).setdefault(filter_type, []).append({"name": name})
 
-                import_local_config_context(
-                    local_type,
-                    device_name,
-                    context_data,
-                    repository_record,
+                    context_name = import_config_context(context_data, repository_record, job_result)
+                    managed_config_contexts.add(context_name)
+                except Exception as exc:
+                    msg = f"Error in loading config context data from `{file_name}`: {exc}"
+                    logger.error(msg)
+                    job_result.log(msg, level_choice=LogLevelChoices.LOG_ERROR, grouping="config contexts")
+
+        # Finally, handle device- and VM-specific "local" context in (devices|virtual_machines)/<name>.(json|yaml)
+        for local_type in ("devices", "virtual_machines"):
+            if os.path.isdir(os.path.join(repository_record.filesystem_path, local_type)):
+                msg = (
+                    f'Found "{local_type}" directory in the repository root. If this is meant to contain '
+                    "config contexts, it should be moved into a `config_contexts/` subdirectory."
                 )
-                managed_local_config_contexts[local_type].add(device_name)
-            except Exception as exc:
-                msg = f"Error in loading local config context from `{local_type}/{file_name}`: {exc}"
-                logger.error(msg)
-                job_result.log(msg, level_choice=LogLevelChoices.LOG_ERROR, grouping="local config contexts")
+                logger.warning(msg)
+                job_result.log(msg, level_choice=LogLevelChoices.LOG_WARNING, grouping="config contexts")
+
+            dir_path = os.path.join(config_context_path, local_type)
+            if not os.path.isdir(dir_path):
+                continue
+
+            for file_name in os.listdir(dir_path):
+                device_name = os.path.splitext(file_name)[0]
+                msg = f"Loading local config context for `{device_name}` from `{local_type}/{file_name}`"
+                logger.info(msg)
+                job_result.log(msg, grouping="local config contexts")
+                try:
+                    with open(os.path.join(dir_path, file_name), "r") as fd:
+                        context_data = yaml.safe_load(fd)
+
+                    import_local_config_context(
+                        local_type,
+                        device_name,
+                        context_data,
+                        repository_record,
+                    )
+                    managed_local_config_contexts[local_type].add(device_name)
+                except Exception as exc:
+                    msg = f"Error in loading local config context from `{local_type}/{file_name}`: {exc}"
+                    logger.error(msg)
+                    job_result.log(msg, level_choice=LogLevelChoices.LOG_ERROR, grouping="local config contexts")
 
     # Delete any prior contexts that are owned by this repository but were not created/updated above
     delete_git_config_contexts(
@@ -599,39 +600,38 @@ def refresh_git_config_context_schemas(repository_record, job_result, delete=Fal
 def update_git_config_context_schemas(repository_record, job_result):
     """Refresh any config context schemas provided by this Git repository."""
     config_context_schema_path = os.path.join(repository_record.filesystem_path, "config_context_schemas")
-    if not os.path.isdir(config_context_schema_path):
-        return
 
     managed_config_context_schemas = set()
 
-    for file_name in os.listdir(config_context_schema_path):
-        if not os.path.isfile(os.path.join(config_context_schema_path, file_name)):
-            continue
-        msg = (f"Loading config context schema from `{file_name}`",)
-        logger.info(msg)
-        job_result.log(msg, grouping="config context schemas")
-        try:
-            with open(os.path.join(config_context_schema_path, file_name), "r") as fd:
-                # The data file can be either JSON or YAML; since YAML is a superset of JSON, we can load it regardless
-                context_schema_data = yaml.safe_load(fd)
-
-            # A file can contain one config context dict or a list thereof
-            if isinstance(context_schema_data, dict):
-                context_name = import_config_context_schema(context_schema_data, repository_record, job_result)
-                managed_config_context_schemas.add(context_name)
-            elif isinstance(context_schema_data, list):
-                for context_schema in context_schema_data:
-                    if isinstance(context_schema, dict):
-                        context_name = import_config_context_schema(context_schema, repository_record, job_result)
-                        managed_config_context_schemas.add(context_name)
-                    else:
-                        raise RuntimeError("each item in list data must be a dict")
-            else:
-                raise RuntimeError("data must be a dict or a list of dicts")
-        except Exception as exc:
-            msg = f"Error in loading config context schema data from `{file_name}`: {exc}"
-            logger.error(msg)
-            job_result.log(msg, level_choice=LogLevelChoices.LOG_ERROR, grouping="config context schemas")
+    if os.path.isdir(config_context_schema_path):
+        for file_name in os.listdir(config_context_schema_path):
+            if not os.path.isfile(os.path.join(config_context_schema_path, file_name)):
+                continue
+            msg = (f"Loading config context schema from `{file_name}`",)
+            logger.info(msg)
+            job_result.log(msg, grouping="config context schemas")
+            try:
+                with open(os.path.join(config_context_schema_path, file_name), "r") as fd:
+                    # The data file can be either JSON or YAML; since YAML is a superset of JSON, we load it regardless
+                    context_schema_data = yaml.safe_load(fd)
+
+                # A file can contain one config context dict or a list thereof
+                if isinstance(context_schema_data, dict):
+                    context_name = import_config_context_schema(context_schema_data, repository_record, job_result)
+                    managed_config_context_schemas.add(context_name)
+                elif isinstance(context_schema_data, list):
+                    for context_schema in context_schema_data:
+                        if isinstance(context_schema, dict):
+                            context_name = import_config_context_schema(context_schema, repository_record, job_result)
+                            managed_config_context_schemas.add(context_name)
+                        else:
+                            raise RuntimeError("each item in list data must be a dict")
+                else:
+                    raise RuntimeError("data must be a dict or a list of dicts")
+            except Exception as exc:
+                msg = f"Error in loading config context schema data from `{file_name}`: {exc}"
+                logger.error(msg)
+                job_result.log(msg, level_choice=LogLevelChoices.LOG_ERROR, grouping="config context schemas")
 
     # Delete any prior contexts that are owned by this repository but were not created/updated above
     delete_git_config_context_schemas(
@@ -835,12 +835,10 @@ def update_git_export_templates(repository_record, job_result):
             job_result.log(msg, level_choice=LogLevelChoices.LOG_WARNING, grouping="export templates")
 
     export_template_path = os.path.join(repository_record.filesystem_path, "export_templates")
-    if not os.path.isdir(export_template_path):
-        return
+    managed_export_templates = {}
 
     git_repository_content_type = ContentType.objects.get_for_model(GitRepository)
 
-    managed_export_templates = {}
     for model_content_type, file_path in files_from_contenttype_directories(
         export_template_path, job_result, "export templates"
     ):

nautobot/extras/datasources/utils.py

@@ -15,6 +15,9 @@ def files_from_contenttype_directories(base_path, job_result, log_grouping):
     Returns:
         (Tuple[ContentType, file_path]): A tuple of the ContentType and the file path.
     """
+    if not os.path.isdir(base_path):
+        return
+
     for app_label in os.listdir(base_path):
         app_label_path = os.path.join(base_path, app_label)
         if not os.path.isdir(app_label_path):

nautobot/extras/filters/__init__.py

@@ -504,7 +504,7 @@ class ContactFilterSet(ContactTeamFilterSet):
         fields = "__all__"
 
 
-class ContactAssociationFilterSet(NautobotFilterSet):
+class ContactAssociationFilterSet(NautobotFilterSet, StatusModelFilterSetMixin, RoleModelFilterSetMixin):
     q = SearchFilter(
         filter_predicates={
             "contact__name": "icontains",
@@ -512,6 +512,19 @@ class ContactAssociationFilterSet(NautobotFilterSet):
         },
     )
 
+    contact = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=Contact.objects.all(),
+        to_field_name="name",
+        label="Contact (name or ID)",
+    )
+    team = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=Team.objects.all(),
+        to_field_name="name",
+        label="Team (name or ID)",
+    )
+
+    associated_object_type = ContentTypeFilter()
+
     class Meta:
         model = ContactAssociation
         fields = "__all__"
@@ -610,6 +623,7 @@ class ExportTemplateFilterSet(BaseFilterSet):
         },
     )
     owner_content_type = ContentTypeFilter()
+    content_type = ContentTypeFilter()
 
     class Meta:
         model = ExportTemplate
@@ -888,6 +902,7 @@ class JobButtonFilterSet(BaseFilterSet):
         fields = (
             "content_types",
             "name",
+            "enabled",
             "text",
             "job",
             "weight",

nautobot/extras/forms/forms.py

@@ -27,6 +27,7 @@ from nautobot.core.forms import (
     DynamicModelMultipleChoiceField,
     JSONArrayFormField,
     JSONField,
+    LaxURLField,
     MultipleContentTypeField,
     SlugField,
     StaticSelect2,
@@ -104,6 +105,7 @@ __all__ = (
     "ConfigContextSchemaBulkEditForm",
     "ConfigContextSchemaFilterForm",
     "CustomFieldForm",
+    "CustomFieldFilterForm",
     "CustomFieldModelCSVForm",
     "CustomFieldBulkCreateForm",  # 2.0 TODO remove this deprecated class
     "CustomFieldChoiceFormSet",
@@ -114,6 +116,7 @@ __all__ = (
     "DynamicGroupMembershipFormSet",
     "ExportTemplateForm",
     "ExportTemplateFilterForm",
+    "ExternalIntegrationFilterForm",
     "ExternalIntegrationForm",
     "ExternalIntegrationBulkEditForm",
     "GitRepositoryForm",
@@ -144,6 +147,7 @@ __all__ = (
     "RelationshipFilterForm",
     "RelationshipAssociationFilterForm",
     "RoleBulkEditForm",
+    "RoleFilterForm",
     "RoleForm",
     "ScheduledJobFilterForm",
     "SecretForm",
@@ -421,6 +425,17 @@ class CustomFieldForm(BootstrapMixin, forms.ModelForm):
             self.fields["key"].widget.attrs["readonly"] = True
 
 
+class CustomFieldFilterForm(NautobotFilterForm):
+    model = CustomField
+    q = forms.CharField(required=False, label="Search")
+    content_types = MultipleContentTypeField(
+        queryset=ContentType.objects.filter(FeatureQuery("custom_fields").get_query()),
+        choices_as_strings=True,
+        required=False,
+        label="Content Type(s)",
+    )
+
+
 class CustomFieldModelCSVForm(CSVModelForm, CustomFieldModelFormMixin):
     """
     Base class for CSV/JSON/YAML import of models that support custom fields.
@@ -638,6 +653,14 @@ class ExternalIntegrationBulkEditForm(NautobotBulkEditForm):
         nullable_fields = ["extra_config", "secrets_group", "headers"]
 
 
+class ExternalIntegrationFilterForm(NautobotFilterForm):
+    model = ExternalIntegration
+    q = forms.CharField(required=False, label="Search")
+    secrets_group = DynamicModelMultipleChoiceField(
+        queryset=SecretsGroup.objects.all(), to_field_name="name", required=False
+    )
+
+
 #
 # Git repositories and other data sources
 #
@@ -665,7 +688,7 @@ class PasswordInputWithPlaceholder(forms.PasswordInput):
 class GitRepositoryForm(NautobotModelForm):
     slug = SlugField(help_text="Filesystem-friendly unique shorthand")
 
-    remote_url = forms.URLField(
+    remote_url = LaxURLField(
         required=True,
         label="Remote URL",
         help_text="Only http:// and https:// URLs are presently supported",
@@ -716,7 +739,7 @@ class GitRepositoryBulkEditForm(NautobotBulkEditForm):
         queryset=GitRepository.objects.all(),
         widget=forms.MultipleHiddenInput(),
     )
-    remote_url = forms.CharField(
+    remote_url = LaxURLField(
         label="Remote URL",
         required=False,
     )
@@ -990,6 +1013,10 @@ class JobHookForm(BootstrapMixin, forms.ModelForm):
     content_types = MultipleContentTypeField(
         queryset=ChangeLoggedModelsQuery().as_queryset(), required=True, label="Content Type(s)"
     )
+    job = DynamicModelChoiceField(
+        queryset=Job.objects.filter(is_job_hook_receiver=True),
+        query_params={"is_job_hook_receiver": True},
+    )
 
     class Meta:
         model = JobHook
@@ -1157,14 +1184,19 @@ class JobButtonForm(BootstrapMixin, forms.ModelForm):
             api_url="/api/extras/content-types/",
         ),
     )
+    job = DynamicModelChoiceField(
+        queryset=Job.objects.filter(is_job_button_receiver=True),
+        query_params={"is_job_button_receiver": True},
+    )
 
     class Meta:
         model = JobButton
         fields = (
             "content_types",
             "name",
-            "text",
             "job",
+            "enabled",
+            "text",
             "weight",
             "group_name",
             "button_class",
@@ -1184,6 +1216,9 @@ class JobButtonBulkEditForm(BootstrapMixin, BulkEditForm):
         ),
         required=False,
     )
+    enabled = forms.NullBooleanField(
+        required=False, widget=BulkEditNullBooleanSelect, help_text="Whether this job button appears in the UI"
+    )
     weight = forms.IntegerField(required=False)
     group_name = forms.CharField(required=False)
 
@@ -1429,6 +1464,17 @@ class RoleBulkEditForm(NautobotBulkEditForm):
         nullable_fields = ["weight"]
 
 
+class RoleFilterForm(NautobotFilterForm):
+    model = Role
+    q = forms.CharField(required=False, label="Search")
+    content_types = MultipleContentTypeField(
+        queryset=RoleModelsQuery().as_queryset(),
+        required=False,
+        choices_as_strings=True,
+        label="Content Type(s)",
+    )
+
+
 #
 # Secrets
 #

nautobot/extras/forms/mixins.py

@@ -45,7 +45,6 @@ __all__ = (
     # 2.0 TODO: remove the below deprecated aliases
     "AddRemoveTagsForm",
     "CustomFieldBulkEditForm",
-    "CustomFieldFilterForm",
     "CustomFieldModelForm",
     "RelationshipModelForm",
     "RoleModelBulkEditFormMixin",
@@ -767,11 +766,6 @@ class CustomFieldBulkEditForm(CustomFieldModelBulkEditFormMixin):
     pass
 
 
-@class_deprecated_in_favor_of(CustomFieldModelFilterFormMixin)
-class CustomFieldFilterForm(CustomFieldModelFilterFormMixin):
-    pass
-
-
 @class_deprecated_in_favor_of(CustomFieldModelFormMixin)
 class CustomFieldModelForm(CustomFieldModelFormMixin):
     pass

nautobot/extras/jobs.py

@@ -1168,6 +1168,14 @@ def enqueue_job_hooks(object_change):
     job_hooks = JobHook.objects.filter(content_types=content_type, enabled=True, **{action_flag: True})
 
     # Enqueue the jobs related to the job_hooks
+    get_jobs(reload=True)
     for job_hook in job_hooks:
         job_model = job_hook.job
-        JobResult.enqueue_job(job_model, object_change.user, object_change=object_change.pk)
+        if not job_model.installed or not job_model.enabled:
+            logger.warning(
+                "JobHook %s is enabled, but the underlying Job %s is not installed and enabled", job_hook, job_model
+            )
+        elif get_job(job_model.class_path) is None:
+            logger.error("JobHook %s is enabled, but the underlying Job implementation is missing", job_hook)
+        else:
+            JobResult.enqueue_job(job_model, object_change.user, object_change=object_change.pk)

nautobot/extras/migrations/0107_laxurlfield.py

@@ -0,0 +1,28 @@
+# Generated by Django 3.2.25 on 2024-06-17 13:24
+
+from django.db import migrations
+
+import nautobot.core.models.fields
+import nautobot.core.models.validators
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0106_populate_default_statuses_and_roles_for_contact_associations"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="externalintegration",
+            name="remote_url",
+            field=nautobot.core.models.fields.LaxURLField(max_length=500),
+        ),
+        migrations.AlterField(
+            model_name="gitrepository",
+            name="remote_url",
+            field=nautobot.core.models.fields.LaxURLField(
+                max_length=255,
+                validators=[nautobot.core.models.validators.EnhancedURLValidator(schemes=["http", "https"])],
+            ),
+        ),
+    ]

nautobot/extras/migrations/0108_jobbutton_enabled.py

@@ -0,0 +1,17 @@
+# Generated by Django 3.2.25 on 2024-06-17 19:06
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0107_laxurlfield"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="jobbutton",
+            name="enabled",
+            field=models.BooleanField(default=True),
+        ),
+    ]