nautobot 2.3.4__py3-none-any.whl → 2.3.6__py3-none-any.whl

nautobot/dcim/tests/test_models.py

@@ -65,7 +65,6 @@ from nautobot.dcim.models import (
 from nautobot.extras import context_managers
 from nautobot.extras.choices import CustomFieldTypeChoices
 from nautobot.extras.models import CustomField, Role, SecretsGroup, Status
-from nautobot.ipam.factory import VLANGroupFactory
 from nautobot.ipam.models import IPAddress, IPAddressToInterface, Namespace, Prefix, VLAN, VLANGroup
 from nautobot.tenancy.models import Tenant
 from nautobot.users.models import User
@@ -2351,7 +2350,6 @@ class InterfaceTestCase(ModularDeviceComponentTestCaseMixin, ModelTestCases.Base
             vid=100,
             location=location_2,
             status=vlan_status,
-            vlan_group=VLANGroupFactory.create(location=location_2),
         )
 
         cls.namespace = Namespace.objects.create(name="dcim_test_interface_ip_addresses")

nautobot/dcim/views.py

@@ -3148,7 +3148,7 @@ class DeviceBayPopulateView(generic.ObjectEditView):
                 f"Added {device_bay.installed_device} to {device_bay}.",
             )
 
-            return redirect("dcim:device", pk=device_bay.device.pk)
+            return redirect("dcim:device_devicebays", pk=device_bay.device.pk)
 
         return render(
             request,
@@ -3191,7 +3191,7 @@ class DeviceBayDepopulateView(generic.ObjectEditView):
                 f"Removed {removed_device} from {device_bay}.",
             )
 
-            return redirect("dcim:device", pk=device_bay.device.pk)
+            return redirect("dcim:device_devicebays", pk=device_bay.device.pk)
 
         return render(
             request,
@@ -4139,9 +4139,12 @@ class DeviceFamilyUIViewSet(NautobotUIViewSet):
             context["device_type_table"] = device_type_table
 
             total_devices = 0
+            device_type_count = 0
             for device_type in device_types:
                 total_devices += device_type.device_count
+                device_type_count += 1
             context["total_devices"] = total_devices
+            context["device_type_count"] = device_type_count
 
         return context
 

nautobot/extras/api/views.py

@@ -1,5 +1,6 @@
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
+from django.db.models import ProtectedError
 from django.forms import ValidationError as FormsValidationError
 from django.http import FileResponse, Http404
 from django.shortcuts import get_object_or_404
@@ -729,6 +730,14 @@ class JobViewSet(
 ):
     lookup_value_regex = r"[-0-9a-fA-F]+"
 
+    def perform_destroy(self, obj):
+        if obj.module_name.startswith("nautobot."):
+            raise ProtectedError(
+                f"Unable to delete Job {obj}. System Job cannot be deleted",
+                [],
+            )
+        super().perform_destroy(obj)
+
 
 @extend_schema_view(
     destroy=extend_schema(operation_id="extras_jobs_destroy_by_name"),

nautobot/extras/factory.py

@@ -246,7 +246,8 @@ class MetadataTypeFactory(PrimaryModelFactory):
                         lambda: ContentType.objects.filter(
                             FeatureQuery("metadata").get_query(), pk__in=existing_content_type_pks
                         ),
-                        minimum=1,
+                        minimum=3,
+                        maximum=5,
                     )
                 )
 

nautobot/extras/models/jobs.py

@@ -11,7 +11,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ValidationError
 from django.core.validators import MinValueValidator
 from django.db import models, transaction
-from django.db.models import signals
+from django.db.models import ProtectedError, signals
 from django.utils import timezone
 from django.utils.functional import cached_property
 from django_celery_beat.clockedschedule import clocked
@@ -234,6 +234,14 @@ class Job(PrimaryModel):
     def __str__(self):
         return self.name
 
+    def delete(self):
+        if self.module_name.startswith("nautobot."):
+            raise ProtectedError(
+                f"Unable to delete Job {self}. System Job cannot be deleted",
+                [],
+            )
+        super().delete()
+
     @property
     def job_class(self):
         """

nautobot/extras/models/models.py

@@ -575,6 +575,8 @@ class FileAttachment(BaseModel):
     filename = models.CharField(max_length=CHARFIELD_MAX_LENGTH)
     mimetype = models.CharField(max_length=CHARFIELD_MAX_LENGTH)
 
+    is_metadata_associable_model = False
+
     natural_key_field_names = ["pk"]
 
     def __str__(self):

nautobot/extras/querysets.py

@@ -1,6 +1,6 @@
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
-from django.db.models import F, Model, OuterRef, Q, Subquery
+from django.db.models import F, Model, OuterRef, ProtectedError, Q, Subquery
 from django.db.models.functions import JSONObject
 
 from nautobot.core.models.query_functions import EmptyGroupByJSONBAgg
@@ -224,6 +224,15 @@ class JobQuerySet(RestrictedQuerySet):
     Extend the standard queryset with a get_for_class_path method.
     """
 
+    def delete(self):
+        for job in self:
+            if job.module_name.startswith("nautobot."):
+                raise ProtectedError(
+                    f"Unable to delete Job {job}. System Job cannot be deleted",
+                    [],
+                )
+        return super().delete()
+
     def get_for_class_path(self, class_path):
         try:
             module_name, job_class_name = class_path.rsplit(".", 1)

nautobot/extras/tables.py

@@ -1031,6 +1031,9 @@ class ObjectMetadataTable(BaseTable):
 class NoteTable(BaseTable):
     actions = ButtonsColumn(Note)
     created = tables.LinkColumn()
+    note = tables.Column(
+        attrs={"td": {"class": "rendered-markdown"}},
+    )
 
     class Meta(BaseTable.Meta):
         model = Note

nautobot/extras/tests/test_api.py

@@ -1388,6 +1388,42 @@ class JobTest(
         job_model = Job.objects.get_for_class_path(class_path)
         return reverse("extras-api:job-run", kwargs={"pk": job_model.pk})
 
+    def get_deletable_object(self):
+        """
+        Get an instance that can be deleted.
+        Exclude system jobs
+        """
+        # filter out the system jobs:
+        queryset = self._get_queryset().exclude(module_name__startswith="nautobot.")
+        instance = get_deletable_objects(self.model, queryset).first()
+        if instance is None:
+            self.fail("Couldn't find a single deletable object!")
+        return instance
+
+    def get_deletable_object_pks(self):
+        """
+        Get a list of PKs corresponding to jobs that can be safely bulk-deleted.
+        Exclude system jobs
+        """
+        queryset = self._get_queryset().exclude(module_name__startswith="nautobot.")
+        instances = get_deletable_objects(self.model, queryset).values_list("pk", flat=True)[:3]
+        if len(instances) < 3:
+            self.fail(f"Couldn't find 3 deletable objects, only found {len(instances)}!")
+        return instances
+
+    def test_delete_system_jobs_fail(self):
+        self.add_permissions("extras.delete_job")
+        instance = self._get_queryset().filter(module_name__startswith="nautobot.").first()
+        job_name = instance.name
+        url = self._get_detail_url(instance)
+        self.client.delete(url, **self.header)
+        # assert Job still exists
+        self.assertTrue(self._get_queryset().filter(name=job_name).exists())
+        self.user.is_superuser = True
+        self.client.delete(url, **self.header)
+        # assert Job still exists
+        self.assertTrue(self._get_queryset().filter(name=job_name).exists())
+
     def test_get_job_variables(self):
         """Test the job/<pk>/variables API endpoint."""
         self.add_permissions("extras.view_job")
@@ -4044,14 +4080,14 @@ class TagTest(APIViewTestCases.APIViewTestCase):
     def test_create_tags_with_invalid_content_types(self):
         self.add_permissions("extras.add_tag")
 
-        # VLANGroup is an OrganizationalModel, not a PrimaryModel, and therefore does not support tags
-        data = {**self.create_data[0], "content_types": [VLANGroup._meta.label_lower]}
+        # Manufacturer is an OrganizationalModel, not a PrimaryModel, and therefore does not support tags
+        data = {**self.create_data[0], "content_types": [Manufacturer._meta.label_lower]}
         response = self.client.post(self._get_list_url(), data, format="json", **self.header)
 
         tag = Tag.objects.filter(name=data["name"])
         self.assertHttpStatus(response, 400)
         self.assertFalse(tag.exists())
-        self.assertIn(f"Invalid content type: {VLANGroup._meta.label_lower}", response.data["content_types"])
+        self.assertIn(f"Invalid content type: {Manufacturer._meta.label_lower}", response.data["content_types"])
 
     def test_create_tags_without_content_types(self):
         self.add_permissions("extras.add_tag")

nautobot/extras/tests/test_forms.py

@@ -388,6 +388,7 @@ class RelationshipModelFormTestCase(TestCase):
         cls.vlangroup_form_base_data = {
             "location": cls.location.pk,
             "name": "New VLAN Group",
+            "range": "1-4094",
         }
 
     def test_create_relationship_associations_valid_1(self):
@@ -665,6 +666,7 @@ class RelationshipModelFormTestCase(TestCase):
             data={
                 "name": self.vlangroup_1.name,
                 "location": self.location,
+                "range": "1-4094",
                 f"cr_{self.relationship_2.key}__source": self.device_2.pk,
             },
         )

nautobot/extras/tests/test_views.py

@@ -18,7 +18,7 @@ from nautobot.core.choices import ColorChoices
 from nautobot.core.models.fields import slugify_dashes_to_underscores
 from nautobot.core.templatetags.helpers import bettertitle
 from nautobot.core.testing import extract_form_failures, extract_page_body, ModelViewTestCase, TestCase, ViewTestCases
-from nautobot.core.testing.utils import disable_warnings, post_data
+from nautobot.core.testing.utils import disable_warnings, get_deletable_objects, post_data
 from nautobot.core.utils.permissions import get_permission_for_model
 from nautobot.dcim.models import (
     ConsolePort,
@@ -1840,6 +1840,9 @@ class ApprovalQueueTestCase(
             return reverse("extras:scheduledjob_approval_request_view", kwargs={"pk": instance.pk})
         raise ValueError("This override is only valid for list and view test cases")
 
+    def get_list_url(self):
+        return reverse("extras:scheduledjob_approval_queue_list")
+
     def setUp(self):
         super().setUp()
         self.job_model = Job.objects.get_for_class_path("dry_run.TestDryRun")
@@ -2363,6 +2366,78 @@ class JobTestCase(
             "clear_task_queues_override": False,
         }
 
+    def get_deletable_object(self):
+        """
+        Get an instance that can be deleted.
+        Exclude system jobs
+        """
+        # filter out the system jobs:
+        queryset = self._get_queryset().exclude(module_name__startswith="nautobot.")
+        return get_deletable_objects(self.model, queryset).first()
+
+    def get_deletable_object_pks(self):
+        """
+        Get a list of PKs corresponding to jobs that can be safely bulk-deleted.
+        Excluding system jobs
+        """
+        queryset = self._get_queryset().exclude(module_name__startswith="nautobot.")
+        return get_deletable_objects(self.model, queryset).values_list("pk", flat=True)[:3]
+
+    def test_delete_system_jobs_fail(self):
+        instance = self._get_queryset().filter(module_name__startswith="nautobot.").first()
+        job_name = instance.name
+        request = {
+            "path": self._get_url("delete", instance),
+            "data": post_data({"confirm": True}),
+        }
+
+        # Try delete with delete job permission
+        self.add_permissions("extras.delete_job")
+        response = self.client.post(**request, follow=True)
+        self.assertHttpStatus(response, 403)
+        response_body = extract_page_body(response.content.decode(response.charset))
+        self.assertIn(f"Unable to delete Job {instance}. System Job cannot be deleted", response_body)
+        # assert Job still exists
+        self.assertTrue(self._get_queryset().filter(name=job_name).exists())
+
+        # Try delete as a superuser
+        self.user.is_superuser = True
+        response = self.client.post(**request, follow=True)
+        self.assertHttpStatus(response, 403)
+        response_body = extract_page_body(response.content.decode(response.charset))
+        self.assertIn(f"Unable to delete Job {instance}. System Job cannot be deleted", response_body)
+        # assert Job still exists
+        self.assertTrue(self._get_queryset().filter(name=job_name).exists())
+
+    def test_bulk_delete_system_jobs_fail(self):
+        system_job_queryset = self.model.objects.filter(module_name__startswith="nautobot.")
+        pk_list = system_job_queryset.values_list("pk", flat=True)[:3]
+        initial_count = self._get_queryset().count()
+        data = {
+            "pk": pk_list,
+            "confirm": True,
+            "_confirm": True,  # Form button
+        }
+        # Try bulk delete with delete job permission
+        self.add_permissions("extras.delete_job")
+        response = self.client.post(self._get_url("bulk_delete"), data, follow=True)
+        self.assertHttpStatus(response, 403)
+        self.assertEqual(self._get_queryset().count(), initial_count)
+        response_body = extract_page_body(response.content.decode(response.charset))
+        self.assertIn(
+            f"Unable to delete Job {system_job_queryset.first()}. System Job cannot be deleted", response_body
+        )
+
+        # Try bulk delete as a superuser
+        self.user.is_superuser = True
+        response = self.client.post(self._get_url("bulk_delete"), data, follow=True)
+        self.assertHttpStatus(response, 403)
+        self.assertEqual(self._get_queryset().count(), initial_count)
+        response_body = extract_page_body(response.content.decode(response.charset))
+        self.assertIn(
+            f"Unable to delete Job {system_job_queryset.first()}. System Job cannot be deleted", response_body
+        )
+
     def validate_job_data_after_bulk_edit(self, pk_list, old_data):
         # Name is bulk-editable
         overridable_fields = [field for field in JOB_OVERRIDABLE_FIELDS if field != "name"]
@@ -3520,11 +3595,11 @@ class TagTestCase(ViewTestCases.OrganizationalObjectViewTestCase):
 
     def test_create_tags_with_invalid_content_types(self):
         self.add_permissions("extras.add_tag")
-        vlangroup_content_type = ContentType.objects.get_for_model(VLANGroup)
+        manufacturer_content_type = ContentType.objects.get_for_model(Manufacturer)
 
         form_data = {
             **self.form_data,
-            "content_types": [vlangroup_content_type.id],
+            "content_types": [manufacturer_content_type.id],
         }
 
         request = {

nautobot/extras/views.py

@@ -4,7 +4,6 @@ from urllib.parse import parse_qs
 from celery import chain
 from django.conf import settings
 from django.contrib import messages
-from django.contrib.auth.models import AnonymousUser
 from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import ObjectDoesNotExist, ValidationError
 from django.db import IntegrityError, transaction
@@ -23,6 +22,7 @@ from django.views.generic import View
 from django_tables2 import RequestConfig
 from jsonschema.validators import Draft7Validator
 from rest_framework.decorators import action
+from rest_framework.permissions import IsAuthenticated
 
 try:
     from zoneinfo import ZoneInfo
@@ -1650,6 +1650,9 @@ class SavedViewUIViewSet(
     serializer_class = serializers.SavedViewSerializer
     table_class = tables.SavedViewTable
     action_buttons = ("export",)
+    permission_classes = [
+        IsAuthenticated,
+    ]
 
     def alter_queryset(self, request):
         """
@@ -1676,15 +1679,15 @@ class SavedViewUIViewSet(
 
     def check_permissions(self, request):
         """
-        Override this method to not check any permissions.
+        Override this method to not check any nautobot-specific object permissions and to only check if the user is authenticated.
         Since users with <app_label>.view_<model_name> permissions should be able to view saved views related to this model.
         And those permissions will be enforced in the related view.
         """
-
-    def dispatch(self, request, *args, **kwargs):
-        if isinstance(request.user, AnonymousUser):
-            return self.handle_no_permission()
-        return super().dispatch(request, *args, **kwargs)
+        for permission in self.get_permissions():
+            if not permission.has_permission(request, self):
+                self.permission_denied(
+                    request, message=getattr(permission, "message", None), code=getattr(permission, "code", None)
+                )
 
     def extra_message_context(self, obj):
         """

nautobot/ipam/api/serializers.py

@@ -118,7 +118,7 @@ class RIRSerializer(NautobotModelSerializer):
 #
 
 
-class VLANGroupSerializer(NautobotModelSerializer):
+class VLANGroupSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
     vlan_count = serializers.IntegerField(read_only=True)
 
     class Meta:
@@ -481,6 +481,35 @@ class IPAllocationSerializer(NautobotModelSerializer, TaggedModelSerializerMixin
         return super().validate(data)
 
 
+class VLANAllocationSerializer(NautobotModelSerializer, TaggedModelSerializerMixin):
+    """
+    Input serializer for POST to /api/ipam/vlan-groups/<id>/available-vlans/, i.e. allocating VLAN from VLANGroup.
+    """
+
+    vid = serializers.IntegerField(required=False, min_value=constants.VLAN_VID_MIN, max_value=constants.VLAN_VID_MAX)
+
+    def validate(self, data):
+        """Skip `ValidatedModel` validation.
+        This allows to skip `vid` attribute of `VLAN` model, while validate name and status.
+        """
+        return data
+
+    class Meta(VLANSerializer.Meta):
+        model = VLAN
+        fields = (
+            # permit "vid" and "vlan_group" for `VLAN` consistency.
+            # validate them under `VLANGroupViewSet`
+            "vid",
+            "vlan_group",
+            "name",
+            "status",
+            "role",
+            "tenant",
+            "description",
+            "custom_fields",
+        )
+
+
 #
 # IP address to interface
 #

nautobot/ipam/api/views.py

@@ -6,12 +6,15 @@ from rest_framework import status
 from rest_framework.decorators import action
 from rest_framework.exceptions import APIException
 from rest_framework.response import Response
+from rest_framework.serializers import IntegerField, ListSerializer
 
+from nautobot.core.api.authentication import TokenPermissions
 from nautobot.core.models.querysets import count_related
 from nautobot.core.utils.config import get_settings_or_config
 from nautobot.dcim.models import Location
 from nautobot.extras.api.views import NautobotModelViewSet
 from nautobot.ipam import filters
+from nautobot.ipam.api import serializers
 from nautobot.ipam.models import (
     IPAddress,
     IPAddressToInterface,
@@ -29,8 +32,6 @@ from nautobot.ipam.models import (
     VRFPrefixAssignment,
 )
 
-from . import serializers
-
 #
 # Namespace
 #
@@ -387,10 +388,171 @@ class IPAddressToInterfaceViewSet(NautobotModelViewSet):
 
 
 class VLANGroupViewSet(NautobotModelViewSet):
-    queryset = VLANGroup.objects.select_related("location").annotate(vlan_count=count_related(VLAN, "vlan_group"))
+    queryset = (
+        VLANGroup.objects.select_related("location")
+        .prefetch_related("tags")
+        .annotate(vlan_count=count_related(VLAN, "vlan_group"))
+    )
     serializer_class = serializers.VLANGroupSerializer
     filterset_class = filters.VLANGroupFilterSet
 
+    def restrict_queryset(self, request, *args, **kwargs):
+        """
+        Apply "view" permissions on the POST /available-vlans/ endpoint, otherwise as ModelViewSetMixin.
+        """
+        if request.user.is_authenticated and self.action == "available_vlans":
+            self.queryset = self.queryset.restrict(request.user, "view")
+        else:
+            super().restrict_queryset(request, *args, **kwargs)
+
+    class AvailableVLANPermissions(TokenPermissions):
+        """As nautobot.core.api.authentication.TokenPermissions, but enforcing add_vlan permission."""
+
+        perms_map = {
+            "GET": ["ipam.view_vlangroup"],
+            "POST": ["ipam.view_vlangroup", "ipam.add_vlan"],
+        }
+
+    @extend_schema(methods=["get"], responses={200: ListSerializer(child=IntegerField())})
+    @extend_schema(
+        methods=["post"],
+        responses={201: serializers.VLANSerializer(many=True)},
+        request=serializers.VLANAllocationSerializer(many=True),
+    )
+    @action(
+        detail=True,
+        name="Available VLAN IDs",
+        url_path="available-vlans",
+        methods=["get", "post"],
+        permission_classes=[AvailableVLANPermissions],
+        filterset_class=None,
+    )
+    def available_vlans(self, request, pk=None):
+        """
+        A convenience method for listing available VLAN IDs within a VLANGroup.
+        By default, the number of VIDs returned will be equivalent to PAGINATE_COUNT.
+        An arbitrary limit (up to MAX_PAGE_SIZE, if set) may be passed, however results will not be paginated.
+        """
+        vlan_group = get_object_or_404(self.queryset, pk=pk)
+
+        if request.method == "POST":
+            with cache.lock(
+                "nautobot.ipam.api.views.available_vlans", blocking_timeout=5, timeout=settings.REDIS_LOCK_TIMEOUT
+            ):
+                # Normalize to a list of objects
+                serializer = serializers.VLANAllocationSerializer(
+                    data=request.data if isinstance(request.data, list) else [request.data],
+                    many=True,
+                    context={
+                        "request": request,
+                        "vlan_group": vlan_group,
+                    },
+                )
+                serializer.is_valid(raise_exception=True)
+                requested_vlans = serializer.validated_data
+
+                # Determine if the requested number of VLANs is available
+                available_vids = vlan_group.available_vids
+                if len(available_vids) < len(requested_vlans):
+                    return Response(
+                        {
+                            "detail": (
+                                f"An insufficient number of VLANs are available within the VLANGroup {vlan_group} "
+                                f"({len(requested_vlans)} requested, {len(available_vids)} available)"
+                            )
+                        },
+                        status=status.HTTP_204_NO_CONTENT,
+                    )
+
+                # Prioritise and check for explicitly requested VIDs. Remove them from available_vids
+                for requested_vlan in requested_vlans:
+                    # Check requested `vid` for availability.
+                    # This will also catch if same `vid` was requested multiple times in a request.
+                    if "vid" in requested_vlan and requested_vlan["vid"] not in available_vids:
+                        return Response(
+                            {"detail": f"VLAN {requested_vlan['vid']} is not available within the VLANGroup."},
+                            status=status.HTTP_204_NO_CONTENT,
+                        )
+                    elif "vid" in requested_vlan and requested_vlan["vid"] in available_vids:
+                        available_vids.remove(requested_vlan["vid"])
+
+                # Assign VLAN IDs from the list of VLANGroup's available VLAN IDs.
+                # Available_vids now does not contain explicitly requested vids.
+                _available_vids = iter(available_vids)
+
+                for requested_vlan in requested_vlans:
+                    if "vid" not in requested_vlan:
+                        requested_vlan["vid"] = next(_available_vids)
+
+                    # Check requested `vlan_group`
+                    if "vlan_group" in requested_vlan and requested_vlan["vlan_group"] != vlan_group:
+                        return Response(
+                            {
+                                "detail": f"Invalid VLAN Group requested: {requested_vlan['vlan_group']}. "
+                                f"Only VLAN Group {vlan_group} is permitted."
+                            },
+                            status=status.HTTP_204_NO_CONTENT,
+                        )
+                    else:
+                        requested_vlan["vlan_group"] = vlan_group.pk
+
+                    # Rewrite custom field data
+                    requested_vlan["custom_fields"] = requested_vlan.pop("_custom_field_data", {})
+
+                # Initialize the serializer with a list or a single object depending on what was requested
+                context = {"request": request, "depth": 0}
+
+                if isinstance(request.data, list):
+                    serializer = serializers.VLANSerializer(data=requested_vlans, many=True, context=context)
+                else:
+                    serializer = serializers.VLANSerializer(data=requested_vlans[0], context=context)
+
+                # Create the new VLANs
+                serializer.is_valid(raise_exception=True)
+                serializer.save()
+
+                data = serializer.data
+
+                return Response(
+                    data={
+                        "count": len(data),
+                        "next": None,
+                        "previous": None,
+                        "results": data,
+                    },
+                    status=status.HTTP_201_CREATED,
+                )
+
+        else:
+            try:
+                limit = int(request.query_params.get("limit", get_settings_or_config("PAGINATE_COUNT")))
+            except ValueError:
+                limit = get_settings_or_config("PAGINATE_COUNT")
+
+            if get_settings_or_config("MAX_PAGE_SIZE"):
+                limit = min(limit, get_settings_or_config("MAX_PAGE_SIZE"))
+
+            if isinstance(limit, int) and limit >= 0:
+                vids = vlan_group.available_vids[0:limit]
+            else:
+                vids = vlan_group.available_vids
+
+            serializer = ListSerializer(
+                child=IntegerField(),
+                data=vids,
+            )
+            serializer.is_valid(raise_exception=True)
+            data = serializer.validated_data
+
+            return Response(
+                {
+                    "count": len(data),
+                    "next": None,
+                    "previous": None,
+                    "results": data,
+                }
+            )
+
 
 #
 # VLANs

nautobot/ipam/filters.py

@@ -539,7 +539,7 @@ class IPAddressToInterfaceFilterSet(NautobotFilterSet):
 class VLANGroupFilterSet(NautobotFilterSet, LocatableModelFilterSetMixin, NameSearchFilterSet):
     class Meta:
         model = VLANGroup
-        fields = ["id", "name", "description"]
+        fields = ["id", "name", "description", "tags"]
 
 
 class VLANFilterSet(

nautobot/ipam/forms.py

@@ -727,7 +727,9 @@ class VLANGroupForm(LocatableModelFormMixin, NautobotModelForm):
         fields = [
             "location",
             "name",
+            "range",
             "description",
+            "tags",
         ]
 
 
@@ -873,6 +875,12 @@ class ServiceForm(NautobotModelForm):
         base_field=forms.IntegerField(min_value=SERVICE_PORT_MIN, max_value=SERVICE_PORT_MAX),
         help_text="Comma-separated list of one or more port numbers. A range may be specified using a hyphen.",
     )
+    ip_addresses = DynamicModelMultipleChoiceField(
+        queryset=IPAddress.objects.all(),
+        required=False,
+        label="IP addresses",
+        query_params={"device_id": "$device", "virtual_machine_id": "$virtual_machine"},
+    )
 
     class Meta:
         model = Service
@@ -892,7 +900,6 @@ class ServiceForm(NautobotModelForm):
         }
         widgets = {
             "protocol": StaticSelect2(),
-            "ip_addresses": StaticSelect2Multiple(),
         }
 
     def __init__(self, *args, **kwargs):