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

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)

nautobot/ipam/models.py

@@ -22,7 +22,7 @@ from nautobot.ipam import choices, constants
 from nautobot.virtualization.models import VMInterface
 
 from .fields import VarbinaryIPField
-from .querysets import IPAddressQuerySet, PrefixQuerySet, RIRQuerySet
+from .querysets import IPAddressQuerySet, PrefixQuerySet, RIRQuerySet, VLANQuerySet
 from .validators import DNSValidator
 
 __all__ = (
@@ -1380,6 +1380,7 @@ class VLAN(PrimaryModel):
     ]
 
     natural_key_field_names = ["pk"]
+    objects = BaseManager.from_queryset(VLANQuerySet)()
 
     class Meta:
         ordering = (

nautobot/ipam/querysets.py

@@ -6,6 +6,7 @@ import netaddr
 
 from nautobot.core.models.querysets import RestrictedQuerySet
 from nautobot.core.utils.data import merge_dicts_without_collision
+from nautobot.ipam.mixins import LocationToLocationsQuerySetMixin
 
 
 class RIRQuerySet(RestrictedQuerySet):
@@ -194,7 +195,7 @@ class BaseNetworkQuerySet(RestrictedQuerySet):
         return ip, last_ip
 
 
-class PrefixQuerySet(BaseNetworkQuerySet):
+class PrefixQuerySet(LocationToLocationsQuerySetMixin, BaseNetworkQuerySet):
     """Queryset for `Prefix` objects."""
 
     def net_equals(self, *prefixes):
@@ -474,3 +475,7 @@ class IPAddressQuerySet(BaseNetworkQuerySet):
             q |= Q(pk__in=pk_values)
 
         return super().filter(q)
+
+
+class VLANQuerySet(LocationToLocationsQuerySetMixin, RestrictedQuerySet):
+    """Queryset for `VLAN` objects."""

nautobot/ipam/tests/test_models.py

@@ -295,6 +295,50 @@ class TestPrefix(ModelTestCases.BaseModelTestCase):
         self.child1 = Prefix.objects.create(prefix="101.102.0.0/26", status=self.status, namespace=self.namespace)
         self.child2 = Prefix.objects.create(prefix="101.102.0.64/26", status=self.status, namespace=self.namespace)
 
+    def test_location_queries(self):
+        locations = Location.objects.all()[:4]
+        for location in locations:
+            location.location_type.content_types.add(ContentType.objects.get_for_model(Prefix))
+        for i in range(10):
+            pfx = Prefix.objects.create(prefix=f"1.1.1.{4*i}/30", status=self.status, namespace=self.namespace)
+            if i > 4:
+                pfx.locations.set(locations)
+
+        with self.subTest("Assert filtering and excluding `location`"):
+            self.assertQuerysetEqualAndNotEmpty(
+                Prefix.objects.filter(location=locations[0]),
+                Prefix.objects.filter(locations__in=[locations[0]]),
+            )
+            self.assertQuerysetEqualAndNotEmpty(
+                Prefix.objects.exclude(location=locations[0]),
+                Prefix.objects.exclude(locations__in=[locations[0]]),
+            )
+            self.assertQuerysetEqualAndNotEmpty(
+                Prefix.objects.filter(location__in=[locations[0]]),
+                Prefix.objects.filter(locations__in=[locations[0]]),
+            )
+            self.assertQuerysetEqualAndNotEmpty(
+                Prefix.objects.exclude(location__in=[locations[0]]),
+                Prefix.objects.exclude(locations__in=[locations[0]]),
+            )
+
+        # We use `assertQuerysetEqualAndNotEmpty` for test validation. Including a nullable field could lead
+        # to flaky tests where querysets might return None, causing tests to fail. Therefore, we select
+        # fields that consistently contain values to ensure reliable filtering.
+        query_params = ["name", "location_type", "status"]
+
+        for field_name in query_params:
+            with self.subTest(f"Assert location__{field_name} query."):
+                value = getattr(locations[0], field_name)
+                self.assertQuerysetEqualAndNotEmpty(
+                    Prefix.objects.filter(**{f"location__{field_name}": value}),
+                    Prefix.objects.filter(**{f"locations__{field_name}": value}),
+                )
+                self.assertQuerysetEqualAndNotEmpty(
+                    Prefix.objects.exclude(**{f"location__{field_name}": value}),
+                    Prefix.objects.exclude(**{f"locations__{field_name}": value}),
+                )
+
     def test_prefix_validation(self):
         location_type = LocationType.objects.get(name="Room")
         location = Location.objects.filter(location_type=location_type).first()
@@ -1201,6 +1245,44 @@ class TestVLAN(ModelTestCases.BaseModelTestCase):
             location.vlans.add(vlan)
         self.assertIn(f"{location} is a Floor and may not have VLANs associated to it.", str(cm.exception))
 
+    def test_location_queries(self):
+        location = VLAN.objects.filter(locations__isnull=False).first().locations.first()
+
+        with self.subTest("Assert filtering and excluding `location`"):
+            self.assertQuerysetEqualAndNotEmpty(
+                VLAN.objects.filter(location=location),
+                VLAN.objects.filter(locations__in=[location]),
+            )
+            self.assertQuerysetEqualAndNotEmpty(
+                VLAN.objects.exclude(location=location),
+                VLAN.objects.exclude(locations__in=[location]),
+            )
+            self.assertQuerysetEqualAndNotEmpty(
+                VLAN.objects.filter(location__in=[location]),
+                VLAN.objects.filter(locations__in=[location]),
+            )
+            self.assertQuerysetEqualAndNotEmpty(
+                VLAN.objects.exclude(location__in=[location]),
+                VLAN.objects.exclude(locations__in=[location]),
+            )
+
+        # We use `assertQuerysetEqualAndNotEmpty` for test validation. Including a nullable field could lead
+        # to flaky tests where querysets might return None, causing tests to fail. Therefore, we select
+        # fields that consistently contain values to ensure reliable filtering.
+        query_params = ["name", "location_type", "status"]
+
+        for field_name in query_params:
+            with self.subTest(f"Assert location__{field_name} query."):
+                value = getattr(location, field_name)
+                self.assertQuerysetEqualAndNotEmpty(
+                    VLAN.objects.filter(**{f"location__{field_name}": value}),
+                    VLAN.objects.filter(**{f"locations__{field_name}": value}),
+                )
+                self.assertQuerysetEqualAndNotEmpty(
+                    VLAN.objects.exclude(**{f"location__{field_name}": value}),
+                    VLAN.objects.exclude(**{f"locations__{field_name}": value}),
+                )
+
 
 class TestVRF(ModelTestCases.BaseModelTestCase):
     model = VRF

nautobot/project-static/docs/assets/extra.css

@@ -137,3 +137,7 @@ img.copyright-logo {
     -webkit-mask-image: var(--md-admonition-icon--version-removed);
     mask-image: var(--md-admonition-icon--version-removed);
 }
+
+.md-typeset .tabbed-set {
+    border: 0.5px solid gray;
+}

nautobot/project-static/docs/code-reference/nautobot/apps/api.html

@@ -11918,7 +11918,7 @@ data any serializer fields that do not correspond to a specific model field</p>
 
 
 <h2 id="nautobot.apps.api.get_view_name" class="doc doc-heading">
-          <code class="highlight language-python"><span class="n">nautobot</span><span class="o">.</span><span class="n">apps</span><span class="o">.</span><span class="n">api</span><span class="o">.</span><span class="n">get_view_name</span><span class="p">(</span><span class="n">view</span><span class="p">,</span> <span class="n">suffix</span><span class="o">=</span><span class="kc">None</span><span class="p">)</span></code>
+          <code class="highlight language-python"><span class="n">nautobot</span><span class="o">.</span><span class="n">apps</span><span class="o">.</span><span class="n">api</span><span class="o">.</span><span class="n">get_view_name</span><span class="p">(</span><span class="n">view</span><span class="p">)</span></code>
 
 <a href="#nautobot.apps.api.get_view_name" class="headerlink" title="Permanent link">&para;</a></h2>