nautobot 2.2.1__py3-none-any.whl → 2.2.3__py3-none-any.whl

nautobot/extras/tests/test_jobs.py

@@ -1,6 +1,7 @@
 import datetime
 from io import StringIO
 import json
+import os
 from pathlib import Path
 import re
 import tempfile
@@ -34,7 +35,7 @@ from nautobot.extras.choices import (
     ObjectChangeEventContextChoices,
 )
 from nautobot.extras.context_managers import change_logging, JobHookChangeContext, web_request_context
-from nautobot.extras.jobs import get_job
+from nautobot.extras.jobs import get_job, get_jobs
 
 
 class JobTest(TestCase):
@@ -174,6 +175,111 @@ class JobTest(TestCase):
         self.assertFalse(job_class.supports_dryrun)
         self.assertFalse(job_model.supports_dryrun)
 
+    def test_submodule_in_jobs_root(self):
+        """
+        Test that a subdirectory/submodule in JOBS_ROOT can contain Jobs.
+        """
+        job_class, job_model = get_job_class_and_model("jobs_module.jobs_submodule.jobs", "ChildJob")
+        self.assertIsNotNone(job_class)
+        self.assertIsNotNone(job_model)
+
+    def test_relative_import_among_files_in_jobs_root(self):
+        """
+        Test that a module in JOBS_ROOT can import from other modules in JOBS_ROOT.
+        """
+        job_class, job_model = get_job_class_and_model("relative_import", "TestReallyPass")
+        self.assertIsNotNone(job_class)
+        self.assertIsNotNone(job_model)
+
+    def test_get_jobs_from_jobs_root(self):
+        """
+        Test that get_jobs() correctly loads jobs from JOBS_ROOT as its contents change.
+        """
+        try:
+            with tempfile.TemporaryDirectory() as temp_dir:
+                with override_settings(JOBS_ROOT=temp_dir):
+                    # Create a new Job and make sure it's discovered correctly
+                    with open(os.path.join(temp_dir, "my_jobs.py"), "w") as fd:
+                        fd.write("""\
+from nautobot.apps.jobs import Job, register_jobs
+class MyJob(Job):
+    def run(self):
+        pass
+register_jobs(MyJob)
+""")
+                    jobs_data = get_jobs(reload=True)
+                    self.assertIn("my_jobs.MyJob", jobs_data.keys())
+                    self.assertIsNotNone(get_job("my_jobs.MyJob"))
+                    # Also make sure some representative previous JOBS_ROOT jobs aren't still around:
+                    self.assertNotIn("dry_run.TestDryRun", jobs_data.keys())
+                    self.assertNotIn("pass.TestPass", jobs_data.keys())
+
+                    # Create a second Job in the same module
+                    with open(os.path.join(temp_dir, "my_jobs.py"), "a") as fd:
+                        fd.write("""
+class MyOtherJob(MyJob):
+    pass
+register_jobs(MyOtherJob)
+""")
+                    jobs_data = get_jobs(reload=True)
+                    self.assertIn("my_jobs.MyJob", jobs_data.keys())
+                    self.assertIsNotNone(get_job("my_jobs.MyJob"))
+                    self.assertIn("my_jobs.MyOtherJob", jobs_data.keys())
+                    self.assertIsNotNone(get_job("my_jobs.MyOtherJob"))
+
+                    # Create a third Job in another module
+                    with open(os.path.join(temp_dir, "their_jobs.py"), "w") as fd:
+                        fd.write("""
+from nautobot.apps.jobs import Job, register_jobs
+
+class MyJob(Job):
+    def run(self):
+        pass
+register_jobs(MyJob)
+""")
+                    jobs_data = get_jobs(reload=True)
+                    self.assertIn("my_jobs.MyJob", jobs_data.keys())
+                    self.assertIsNotNone(get_job("my_jobs.MyJob"))
+                    self.assertIn("my_jobs.MyOtherJob", jobs_data.keys())
+                    self.assertIsNotNone(get_job("my_jobs.MyOtherJob"))
+                    self.assertIn("their_jobs.MyJob", jobs_data.keys())
+                    self.assertIsNotNone(get_job("their_jobs.MyJob"))
+                    self.assertNotEqual(get_job("my_jobs.MyJob"), get_job("their_jobs.MyJob"))
+
+                    # Delete a module
+                    os.remove(os.path.join(temp_dir, "their_jobs.py"))
+                    jobs_data = get_jobs(reload=True)
+                    self.assertIn("my_jobs.MyJob", jobs_data.keys())
+                    self.assertIsNotNone(get_job("my_jobs.MyJob"))
+                    self.assertIn("my_jobs.MyOtherJob", jobs_data.keys())
+                    self.assertIsNotNone(get_job("my_jobs.MyOtherJob"))
+                    self.assertNotIn("their_jobs", jobs_data.keys())
+                    self.assertIsNone(get_job("their_jobs.MyJob"))
+
+                    # Create a module with an inauspicious name
+                    with open(os.path.join(temp_dir, "traceback.py"), "w") as fd:
+                        fd.write("""
+from nautobot.apps.jobs import Job, register_jobs
+
+class BadJob(Job):
+    def run(self):
+        raise RuntimeError("You ran a bad job!")
+register_jobs(BadJob)
+""")
+                    jobs_data = get_jobs(reload=True)
+                    self.assertIn("my_jobs.MyJob", jobs_data.keys())
+                    self.assertIsNotNone(get_job("my_jobs.MyJob"))
+                    self.assertIn("my_jobs.MyOtherJob", jobs_data.keys())
+                    self.assertIsNotNone(get_job("my_jobs.MyOtherJob"))
+                    # Since `traceback` conflicts with a system module, it should not get loaded
+                    self.assertNotIn("traceback.BadJob", jobs_data.keys())
+                    self.assertIsNone(get_job("traceback.BadJob"))
+
+                    # TODO: testing with subdirectories/submodules under JOBS_ROOT...
+        finally:
+            # Clean up back to normal behavior
+            get_jobs(reload=True)
+
 
 class JobTransactionTest(TransactionTestCase):
     """
@@ -216,6 +322,19 @@ class JobTransactionTest(TransactionTestCase):
         name = "TestPass"
         job_result = create_job_result_and_run_job(module, name)
         self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_SUCCESS)
+        self.assertEqual(job_result.result, True)
+        logs = job_result.job_log_entries
+        self.assertGreater(logs.count(), 0)
+        try:
+            logs.get(message="before_start() was called as expected")
+            logs.get(message="Success")
+            logs.get(message="on_success() was called as expected")
+            logs.get(message="after_return() was called as expected")
+        except models.JobLogEntry.DoesNotExist:
+            for log in logs.all():
+                print(log.message)
+            print(job_result.traceback)
+            raise
 
     def test_job_result_manager_censor_sensitive_variables(self):
         """
@@ -237,6 +356,18 @@ class JobTransactionTest(TransactionTestCase):
         name = "TestFail"
         job_result = create_job_result_and_run_job(module, name)
         self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_FAILURE)
+        logs = job_result.job_log_entries
+        self.assertGreater(logs.count(), 0)
+        try:
+            logs.get(message="before_start() was called as expected")
+            logs.get(message="I'm a test job that fails!")
+            logs.get(message="on_failure() was called as expected")
+            logs.get(message="after_return() was called as expected")
+        except models.JobLogEntry.DoesNotExist:
+            for log in logs.all():
+                print(log.message)
+            print(job_result.traceback)
+            raise
 
     def test_job_fail_with_sanitization(self):
         """
@@ -876,6 +1007,7 @@ class JobHookReceiverTransactionTest(TransactionTestCase):
         test_location = Location.objects.get(name="test_jhr")
         oc = get_changes_for_model(test_location).first()
         self.assertEqual(oc.change_context, ObjectChangeEventContextChoices.CONTEXT_JOB_HOOK)
+        self.assertIsNotNone(job_result.user)
         self.assertEqual(oc.user_id, job_result.user.pk)
 
     def test_missing_receive_job_hook_method(self):
@@ -933,6 +1065,8 @@ class JobHookTransactionTest(TransactionTestCase):  # TODO: BaseModelTestCase mi
         module = "job_hook_receiver"
         name = "TestJobHookReceiverLog"
         self.job_class, self.job_model = get_job_class_and_model(module, name)
+        self.assertIsNotNone(self.job_class)
+        self.assertIsNotNone(self.job_model)
         job_hook = models.JobHook(
             name="JobHookTest",
             type_create=True,

nautobot/extras/tests/test_models.py

@@ -65,6 +65,7 @@ from nautobot.extras.models import (
     Webhook,
 )
 from nautobot.extras.models.statuses import StatusModel
+from nautobot.extras.registry import registry
 from nautobot.extras.secrets.exceptions import SecretParametersError, SecretProviderError, SecretValueNotFoundError
 from nautobot.ipam.models import IPAddress
 from nautobot.tenancy.models import Tenant
@@ -1079,25 +1080,31 @@ class JobModelTest(ModelTestCases.BaseModelTestCase):
     def test_defaults(self):
         """Verify that defaults for discovered JobModel instances are as expected."""
         for job_model in JobModel.objects.all():
-            self.assertTrue(job_model.installed)
-            # System jobs should be enabled by default, all others are disabled by default
-            if job_model.module_name.startswith("nautobot."):
-                self.assertTrue(job_model.enabled)
-            else:
-                self.assertFalse(job_model.enabled)
-            for field_name in JOB_OVERRIDABLE_FIELDS:
-                if field_name == "name" and "duplicate_name" in job_model.job_class.__module__:
-                    pass  # name field for test_duplicate_name jobs tested in test_duplicate_job_name below
-                else:
-                    self.assertFalse(
-                        getattr(job_model, f"{field_name}_override"),
-                        (field_name, getattr(job_model, field_name), getattr(job_model.job_class, field_name)),
-                    )
-                    self.assertEqual(
-                        getattr(job_model, field_name),
-                        getattr(job_model.job_class, field_name),
-                        field_name,
-                    )
+            with self.subTest(class_path=job_model.class_path):
+                try:
+                    self.assertTrue(job_model.installed)
+                    # System jobs should be enabled by default, all others are disabled by default
+                    if job_model.module_name.startswith("nautobot."):
+                        self.assertTrue(job_model.enabled)
+                    else:
+                        self.assertFalse(job_model.enabled)
+                    for field_name in JOB_OVERRIDABLE_FIELDS:
+                        if field_name == "name" and "duplicate_name" in job_model.job_class.__module__:
+                            pass  # name field for test_duplicate_name jobs tested in test_duplicate_job_name below
+                        else:
+                            self.assertFalse(
+                                getattr(job_model, f"{field_name}_override"),
+                                (field_name, getattr(job_model, field_name), getattr(job_model.job_class, field_name)),
+                            )
+                            self.assertEqual(
+                                getattr(job_model, field_name),
+                                getattr(job_model.job_class, field_name),
+                                field_name,
+                            )
+                except AssertionError:
+                    print(list(JobModel.objects.all()))
+                    print(registry["jobs"])
+                    raise
 
     def test_duplicate_job_name(self):
         self.assertTrue(JobModel.objects.filter(name="TestDuplicateNameNoMeta").exists())

nautobot/extras/tests/test_plugins.py

@@ -9,7 +9,6 @@ from django.urls import NoReverseMatch, reverse
 import netaddr
 
 from nautobot.circuits.models import Circuit, CircuitType, Provider
-from nautobot.core.celery import app
 from nautobot.core.testing import APIViewTestCases, disable_warnings, extract_page_body, TestCase, ViewTestCases
 from nautobot.dcim.models import Device, DeviceType, Location, LocationType, Manufacturer
 from nautobot.dcim.tests.test_views import create_test_device
@@ -114,9 +113,8 @@ class AppTest(TestCase):
         """
         from example_app.jobs import ExampleJob
 
-        self.assertIn(ExampleJob, registry.get("plugin_jobs", []))
+        self.assertIn(ExampleJob.class_path, registry.get("jobs", {}))
         self.assertEqual(ExampleJob, get_job("example_app.jobs.ExampleJob"))
-        self.assertIn("example_app.jobs.ExampleJob", app.tasks)
 
     def test_git_datasource_contents_registration(self):
         """

nautobot/extras/tests/test_views.py

@@ -1765,10 +1765,8 @@ class JobTestCase(
     model = Job
 
     def _get_queryset(self):
-        """Don't include hidden Jobs, non-installed Jobs, JobHookReceivers or JobButtonReceivers as they won't appear in the UI by default."""
-        return self.model.objects.filter(
-            installed=True, hidden=False, is_job_hook_receiver=False, is_job_button_receiver=False
-        )
+        """Don't include hidden Jobs or non-installed Jobs, as they won't appear in the UI by default."""
+        return self.model.objects.filter(installed=True, hidden=False)
 
     @classmethod
     def setUpTestData(cls):

nautobot/extras/utils.py

@@ -19,7 +19,9 @@ from nautobot.core.choices import ColorChoices
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
 from nautobot.core.models.managers import TagsManager
 from nautobot.core.models.utils import find_models_with_matching_fields
+from nautobot.extras.choices import ObjectChangeActionChoices
 from nautobot.extras.constants import (
+    CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL,
     EXTRAS_FEATURES,
     JOB_MAX_NAME_LENGTH,
     JOB_OVERRIDABLE_FIELDS,
@@ -610,3 +612,38 @@ def migrate_role_data(
             model_to_migrate._meta.label,
             to_role_field_name,
         )
+
+
+def bulk_delete_with_bulk_change_logging(qs, batch_size=1000):
+    """
+    Deletes objects in the provided queryset and creates ObjectChange instances in bulk to improve performance.
+    For use with bulk delete views. This operation is wrapped in an atomic transaction.
+    """
+    from nautobot.extras.models import ObjectChange
+    from nautobot.extras.signals import change_context_state
+
+    change_context = change_context_state.get()
+    if change_context is None:
+        raise ValueError("Change logging must be enabled before using bulk_delete_with_bulk_change_logging")
+
+    with transaction.atomic():
+        try:
+            queued_object_changes = []
+            change_context.defer_object_changes = True
+            for obj in qs.iterator():
+                if not hasattr(obj, "to_objectchange"):
+                    break
+                if len(queued_object_changes) >= batch_size:
+                    ObjectChange.objects.bulk_create(queued_object_changes)
+                    queued_object_changes = []
+                oc = obj.to_objectchange(ObjectChangeActionChoices.ACTION_DELETE)
+                oc.user = change_context.user
+                oc.request_id = change_context.change_id
+                oc.change_context = change_context.context
+                oc.change_context_detail = change_context.context_detail[:CHANGELOG_MAX_CHANGE_CONTEXT_DETAIL]
+                queued_object_changes.append(oc)
+            ObjectChange.objects.bulk_create(queued_object_changes)
+            return qs.delete()
+        finally:
+            change_context.defer_object_changes = False
+            change_context.reset_deferred_object_changes()

nautobot/extras/views.py

@@ -404,10 +404,8 @@ class ContactAssociationUIViewSet(
     non_filter_params = ("export", "page", "per_page", "sort")
 
 
-class ObjectNewContactView(generic.ObjectEditView):
-    queryset = Contact.objects.all()
-    model_form = forms.ObjectNewContactForm
-    template_name = "extras/object_new_contact.html"
+class ObjectContactTeamMixin:
+    """Mixin that contains a custom post() method to create a new contact/team and assign it to an existing object"""
 
     def post(self, request, *args, **kwargs):
         obj = self.alter_obj(self.get_object(kwargs), request, args, kwargs)
@@ -428,13 +426,22 @@ class ObjectNewContactView(generic.ObjectEditView):
                 if hasattr(form, "save_note") and callable(form.save_note):
                     form.save_note(instance=obj, user=request.user)
 
-                association = ContactAssociation(
-                    contact=obj,
-                    associated_object_type=ContentType.objects.get(id=request.POST.get("associated_object_type")),
-                    associated_object_id=request.POST.get("associated_object_id"),
-                    status=Status.objects.get(id=request.POST.get("status")),
-                    role=Role.objects.get(id=request.POST.get("role")) if request.POST.get("role") else None,
-                )
+                if isinstance(obj, Contact):
+                    association = ContactAssociation(
+                        contact=obj,
+                        associated_object_type=ContentType.objects.get(id=request.POST.get("associated_object_type")),
+                        associated_object_id=request.POST.get("associated_object_id"),
+                        status=Status.objects.get(id=request.POST.get("status")),
+                        role=Role.objects.get(id=request.POST.get("role")) if request.POST.get("role") else None,
+                    )
+                else:
+                    association = ContactAssociation(
+                        team=obj,
+                        associated_object_type=ContentType.objects.get(id=request.POST.get("associated_object_type")),
+                        associated_object_id=request.POST.get("associated_object_id"),
+                        status=Status.objects.get(id=request.POST.get("status")),
+                        role=Role.objects.get(id=request.POST.get("role")) if request.POST.get("role") else None,
+                    )
                 association.validated_save()
                 self.successful_post(request, obj, object_created, logger)
 
@@ -474,75 +481,17 @@ class ObjectNewContactView(generic.ObjectEditView):
         )
 
 
-class ObjectNewTeamView(generic.ObjectEditView):
+class ObjectNewContactView(ObjectContactTeamMixin, generic.ObjectEditView):
+    queryset = Contact.objects.all()
+    model_form = forms.ObjectNewContactForm
+    template_name = "extras/object_new_contact.html"
+
+
+class ObjectNewTeamView(ObjectContactTeamMixin, generic.ObjectEditView):
     queryset = Team.objects.all()
     model_form = forms.ObjectNewTeamForm
     template_name = "extras/object_new_team.html"
 
-    def post(self, request, *args, **kwargs):
-        obj = self.alter_obj(self.get_object(kwargs), request, args, kwargs)
-        form = self.model_form(data=request.POST, files=request.FILES, instance=obj)
-        restrict_form_fields(form, request.user)
-
-        if form.is_valid():
-            logger.debug("Form validation was successful")
-
-            try:
-                with transaction.atomic():
-                    object_created = not form.instance.present_in_database
-                    obj = form.save()
-
-                    # Check that the new object conforms with any assigned object-level permissions
-                    self.queryset.get(pk=obj.pk)
-
-                if hasattr(form, "save_note") and callable(form.save_note):
-                    form.save_note(instance=obj, user=request.user)
-
-                association = ContactAssociation(
-                    team=obj,
-                    associated_object_type=ContentType.objects.get(id=request.POST.get("associated_object_type")),
-                    associated_object_id=request.POST.get("associated_object_id"),
-                    status=Status.objects.get(id=request.POST.get("status")),
-                    role=Role.objects.get(id=request.POST.get("role")) if request.POST.get("role") else None,
-                )
-                association.validated_save()
-                self.successful_post(request, obj, object_created, logger)
-
-                if "_addanother" in request.POST:
-                    # If the object has clone_fields, pre-populate a new instance of the form
-                    if hasattr(obj, "clone_fields"):
-                        url = f"{request.path}?{prepare_cloned_fields(obj)}"
-                        return redirect(url)
-
-                    return redirect(request.get_full_path())
-
-                return_url = form.cleaned_data.get("return_url")
-                if url_has_allowed_host_and_scheme(url=return_url, allowed_hosts=request.get_host()):
-                    return redirect(iri_to_uri(return_url))
-                else:
-                    return redirect(self.get_return_url(request, obj))
-
-            except ObjectDoesNotExist:
-                msg = "Object save failed due to object-level permissions violation"
-                logger.debug(msg)
-                form.add_error(None, msg)
-
-        else:
-            logger.debug("Form validation failed")
-
-        return render(
-            request,
-            self.template_name,
-            {
-                "obj": obj,
-                "obj_type": self.queryset.model._meta.verbose_name,
-                "form": form,
-                "return_url": self.get_return_url(request, obj),
-                "editing": obj.present_in_database,
-                **self.get_extra_context(request, obj),
-            },
-        )
-
 
 class ObjectAssignContactOrTeamView(generic.ObjectEditView):
     queryset = ContactAssociation.objects.all()
@@ -1250,7 +1199,10 @@ class JobListView(generic.ObjectListView):
     filterset = filters.JobFilterSet
     filterset_form = forms.JobFilterForm
     action_buttons = ()
-    non_filter_params = ("display",)
+    non_filter_params = (
+        *generic.ObjectListView.non_filter_params,
+        "display",
+    )
     template_name = "extras/job_list.html"
 
     def alter_queryset(self, request):
@@ -1305,11 +1257,9 @@ class JobRunView(ObjectPermissionRequiredMixin, View):
         job_model = self._get_job_model_or_404(class_path, pk)
 
         try:
-            try:
-                job_class = job_model.job_class
-            except TypeError as exc:
-                # job_class may be None
-                raise RuntimeError("Job code for this job is not currently installed or loadable") from exc
+            job_class = get_job(job_model.class_path, reload=True)
+            if job_class is None:
+                raise RuntimeError("Job code for this job is not currently installed or loadable")
             initial = normalize_querydict(request.GET, form_class=job_class.as_form_class())
             if "kwargs_from_job_result" in initial:
                 job_result_pk = initial.pop("kwargs_from_job_result")
@@ -1357,7 +1307,8 @@ class JobRunView(ObjectPermissionRequiredMixin, View):
     def post(self, request, class_path=None, pk=None):
         job_model = self._get_job_model_or_404(class_path, pk)
 
-        job_form = job_model.job_class.as_form(request.POST, request.FILES) if job_model.job_class is not None else None
+        job_class = get_job(job_model.class_path, reload=True)
+        job_form = job_class.as_form(request.POST, request.FILES) if job_class is not None else None
         schedule_form = forms.JobScheduleForm(request.POST)
         task_queue = request.POST.get("_task_queue")
 
@@ -1370,7 +1321,7 @@ class JobRunView(ObjectPermissionRequiredMixin, View):
         # Allow execution only if a worker process is running and the job is runnable.
         if not get_worker_count(queue=task_queue):
             messages.error(request, "Unable to run or schedule job: Celery worker process not running.")
-        elif not job_model.installed or job_model.job_class is None:
+        elif not job_model.installed or job_class is None:
             messages.error(request, "Unable to run or schedule job: Job is not presently installed.")
         elif not job_model.enabled:
             messages.error(request, "Unable to run or schedule job: Job is not enabled to be run.")
@@ -1422,11 +1373,11 @@ class JobRunView(ObjectPermissionRequiredMixin, View):
                 celery_kwargs = {"nautobot_job_profile": profile, "queue": task_queue}
                 scheduled_job = ScheduledJob(
                     name=schedule_name,
-                    task=job_model.job_class.registered_name,
+                    task=job_model.class_path,
                     job_model=job_model,
                     start_time=schedule_datetime,
                     description=f"Nautobot job {schedule_name} scheduled by {request.user} for {schedule_datetime}",
-                    kwargs=job_model.job_class.serialize_data(job_form.cleaned_data),
+                    kwargs=job_class.serialize_data(job_form.cleaned_data),
                     celery_kwargs=celery_kwargs,
                     interval=schedule_type,
                     one_off=schedule_type == JobExecutionType.TYPE_FUTURE,
@@ -1446,13 +1397,13 @@ class JobRunView(ObjectPermissionRequiredMixin, View):
 
             else:
                 # Enqueue job for immediate execution
-                job_kwargs = job_model.job_class.prepare_job_kwargs(job_form.cleaned_data)
+                job_kwargs = job_class.prepare_job_kwargs(job_form.cleaned_data)
                 job_result = JobResult.enqueue_job(
                     job_model,
                     request.user,
                     profile=profile,
                     task_queue=task_queue,
-                    **job_model.job_class.serialize_data(job_kwargs),
+                    **job_class.serialize_data(job_kwargs),
                 )
 
                 if return_url:
@@ -1471,10 +1422,10 @@ class JobRunView(ObjectPermissionRequiredMixin, View):
             return redirect(return_url)
 
         template_name = "extras/job.html"
-        if job_model.job_class is not None and hasattr(job_model.job_class, "template_name"):
+        if job_class is not None and hasattr(job_class, "template_name"):
             try:
-                get_template(job_model.job_class.template_name)
-                template_name = job_model.job_class.template_name
+                get_template(job_class.template_name)
+                template_name = job_class.template_name
             except TemplateDoesNotExist as err:
                 messages.error(request, f'Unable to render requested custom job template "{template_name}": {err}')
 
@@ -1555,7 +1506,7 @@ class JobApprovalRequestView(generic.ObjectView):
         """
         job_model = instance.job_model
         if job_model is not None:
-            job_class = job_model.job_class
+            job_class = get_job(job_model.class_path, reload=True)
         else:
             # 2.0 TODO: remove this fallback?
             job_class = get_job(instance.job_class)
@@ -1591,6 +1542,7 @@ class JobApprovalRequestView(generic.ObjectView):
         dry_run = "_dry_run" in post_data
 
         job_model = scheduled_job.job_model
+        job_class = get_job(job_model.class_path, reload=True)
 
         if dry_run:
             # To dry-run a job, a user needs the same permissions that would be needed to run the job directly
@@ -1604,13 +1556,13 @@ class JobApprovalRequestView(generic.ObjectView):
                 messages.error(request, "This job does not support dryrun")
             else:
                 # Immediately enqueue the job and send the user to the normal JobResult view
-                job_kwargs = job_model.job_class.prepare_job_kwargs(scheduled_job.kwargs or {})
+                job_kwargs = job_class.prepare_job_kwargs(scheduled_job.kwargs or {})
                 job_kwargs["dryrun"] = True
                 job_result = JobResult.enqueue_job(
                     job_model,
                     request.user,
                     celery_kwargs=scheduled_job.celery_kwargs,
-                    **job_model.job_class.serialize_data(job_kwargs),
+                    **job_class.serialize_data(job_kwargs),
                 )
 
                 return redirect("extras:jobresult", pk=job_result.pk)
@@ -1697,7 +1649,7 @@ class ScheduledJobView(generic.ObjectView):
             for name, var in job_class._get_vars().items():
                 field = var.as_field()
                 if field.label:
-                    labels[name] = var
+                    labels[name] = field.label
                 else:
                     labels[name] = pretty_name(name)
         return {"labels": labels, "job_class_found": (job_class is not None)}

nautobot/ipam/api/views.py

@@ -160,7 +160,13 @@ class PrefixViewSet(NautobotModelViewSet):
 
     @extend_schema(methods=["get"], responses={200: serializers.AvailablePrefixSerializer(many=True)})
     @extend_schema(methods=["post"], responses={201: serializers.PrefixSerializer(many=False)})
-    @action(detail=True, url_path="available-prefixes", methods=["get", "post"], filterset_class=None)
+    @action(
+        detail=True,
+        name="Available Prefixes",
+        url_path="available-prefixes",
+        methods=["get", "post"],
+        filterset_class=None,
+    )
     def available_prefixes(self, request, pk=None):
         """
         A convenience method for returning available child prefixes within a parent.
@@ -237,6 +243,7 @@ class PrefixViewSet(NautobotModelViewSet):
     )
     @action(
         detail=True,
+        name="Available IPs",
         url_path="available-ips",
         methods=["get", "post"],
         queryset=IPAddress.objects.all(),

nautobot/ipam/graphql/types.py

@@ -26,6 +26,7 @@ class PrefixType(OptimizedNautobotObjectType):
     prefix = graphene.String()
     ip_version = graphene.Int()
     dynamic_groups = graphene.List("nautobot.extras.graphql.types.DynamicGroupType")
+    location = graphene.Field("nautobot.dcim.graphql.types.LocationType")
 
     class Meta:
         model = models.Prefix
@@ -33,3 +34,13 @@ class PrefixType(OptimizedNautobotObjectType):
 
     def resolve_dynamic_groups(self, args):
         return DynamicGroup.objects.get_for_object(self, use_cache=True)
+
+
+class VLANType(OptimizedNautobotObjectType):
+    """Graphql Type Object for VLAN model."""
+
+    location = graphene.Field("nautobot.dcim.graphql.types.LocationType")
+
+    class Meta:
+        model = models.VLAN
+        filterset_class = filters.VLANFilterSet

nautobot/ipam/mixins.py

@@ -0,0 +1,32 @@
+class LocationToLocationsQuerySetMixin:
+    """
+    A mixin for Django QuerySets to support backward compatibility by converting
+    queries from a previously used 'location' field to the new
+    'locations'. This mixin intercepts `filter` and `exclude` calls
+    to transform references from 'location' to 'locations'.
+    """
+
+    def _convert_location_to_locations(self, kwargs):
+        """Transforms query parameters that reference 'location' field into the corresponding 'locations' field."""
+        updated_kwargs = {}
+        for field, value in kwargs.items():
+            if field == "location":
+                # If there is no lookup expression, it means 'location' is queried directly,
+                # thus use 'locations__in' to accommodate the ManyToMany relationship
+                updated_kwargs["locations__in"] = [value]
+            elif field.startswith("location__"):
+                # If there is a lookup expression following 'location', prepend it with 'locations'
+                _, lookup_expr = field.split("location", maxsplit=1)
+                locations_field = f"locations{lookup_expr}".strip()
+                updated_kwargs[locations_field] = value
+            else:
+                updated_kwargs[field] = value
+        return updated_kwargs
+
+    def filter(self, *args, **kwargs):
+        kwargs = self._convert_location_to_locations(kwargs)
+        return super().filter(*args, **kwargs)
+
+    def exclude(self, *args, **kwargs):
+        kwargs = self._convert_location_to_locations(kwargs)
+        return super().exclude(*args, **kwargs)