nautobot 2.3.16__py3-none-any.whl → 2.4.0b1__py3-none-any.whl

nautobot/dcim/choices.py

@@ -1567,3 +1567,31 @@ class ModuleStatusChoices(ChoiceSet):
         (STATUS_INVENTORY, "Inventory"),
         (STATUS_DECOMMISSIONING, "Decommissioning"),
     )
+
+
+#
+# Virtual Device Context
+#
+
+
+class VirtualDeviceContextStatusChoices(ChoiceSet):
+    STATUS_OFFLINE = "offline"
+    STATUS_ACTIVE = "active"
+    STATUS_PLANNED = "planned"
+
+    CHOICES = (
+        (STATUS_OFFLINE, "Offline"),
+        (STATUS_ACTIVE, "Active"),
+        (STATUS_PLANNED, "Planned"),
+    )
+
+
+#
+# Controllers
+#
+
+
+class ControllerCapabilitiesChoices(ChoiceSet):
+    WIRELESS = "wireless"
+
+    CHOICES = ((WIRELESS, "Wireless"),)

nautobot/dcim/factory.py

@@ -19,6 +19,7 @@ from nautobot.core.factory import (
 )
 from nautobot.dcim.choices import (
     ConsolePortTypeChoices,
+    ControllerCapabilitiesChoices,
     DeviceRedundancyGroupFailoverStrategyChoices,
     InterfaceTypeChoices,
     PortTypeChoices,
@@ -40,6 +41,7 @@ from nautobot.dcim.models import (
     DeviceRedundancyGroup,
     DeviceType,
     FrontPortTemplate,
+    Interface,
     InterfaceTemplate,
     Location,
     LocationType,
@@ -58,6 +60,7 @@ from nautobot.dcim.models import (
     RearPortTemplate,
     SoftwareImageFile,
     SoftwareVersion,
+    VirtualDeviceContext,
 )
 from nautobot.extras.models import ExternalIntegration, Role, Status
 from nautobot.extras.utils import FeatureQuery
@@ -719,6 +722,7 @@ class SoftwareVersionFactory(PrimaryModelFactory):
 class ControllerFactory(PrimaryModelFactory):
     class Meta:
         model = Controller
+        exclude = ("has_capabilities",)
 
     class Params:
         has_device = NautobotBoolIterator()
@@ -727,6 +731,12 @@ class ControllerFactory(PrimaryModelFactory):
     description = factory.Faker("sentence")
     status = random_instance(lambda: Status.objects.get_for_model(Controller), allow_null=False)
     role = random_instance(lambda: Role.objects.get_for_model(Controller))
+    has_capabilities = NautobotBoolIterator()
+    capabilities = factory.Maybe(
+        "has_capabilities",
+        factory.Faker("random_elements", elements=ControllerCapabilitiesChoices.values(), unique=True),
+        [],
+    )
     platform = random_instance(Platform)
     location = random_instance(lambda: Location.objects.get_for_model(Controller), allow_null=False)
     tenant = random_instance(Tenant)
@@ -738,6 +748,7 @@ class ControllerFactory(PrimaryModelFactory):
 class ControllerManagedDeviceGroupFactory(PrimaryModelFactory):
     class Meta:
         model = ControllerManagedDeviceGroup
+        exclude = ("has_capabilities",)
 
     class Params:
         has_parent = NautobotBoolIterator()
@@ -747,6 +758,12 @@ class ControllerManagedDeviceGroupFactory(PrimaryModelFactory):
     controller = factory.LazyAttribute(
         lambda o: o.parent.controller if o.parent else factory.random.randgen.choice(Controller.objects.all())
     )
+    has_capabilities = NautobotBoolIterator()
+    capabilities = factory.Maybe(
+        "has_capabilities",
+        factory.Faker("random_elements", elements=ControllerCapabilitiesChoices.values(), unique=True),
+        [],
+    )
     weight = factory.Faker("pyint", min_value=1, max_value=1000)
 
 
@@ -945,3 +962,44 @@ class ModuleBayTemplateFactory(ModularDeviceComponentTemplateFactory):
         factory.LazyAttribute(lambda o: o.device_type.module_bay_templates.count() + 1),
         factory.LazyAttribute(lambda o: o.module_type.module_bay_templates.count() + 1),
     )
+
+
+class VirtualDeviceContextFactory(PrimaryModelFactory):
+    class Meta:
+        model = VirtualDeviceContext
+        exclude = ("has_role", "has_tenant", "has_description")
+
+    status = random_instance(
+        lambda: Status.objects.get_for_model(VirtualDeviceContext),
+        allow_null=False,
+    )
+    has_role = NautobotBoolIterator()
+    role = factory.Maybe(
+        "has_role",
+        random_instance(
+            lambda: Role.objects.get_for_model(VirtualDeviceContext),
+            allow_null=False,
+        ),
+        None,
+    )
+    identifier = factory.Sequence(
+        lambda n: n + 101
+    )  # Start at 101 to avoid conflicts VirtualDeviceContexts API test cases.
+    name = factory.Sequence(lambda n: f"VirtualDeviceContext {n}")
+    device = random_instance(Device, allow_null=False)
+    has_tenant = NautobotBoolIterator()
+    tenant = factory.Maybe(
+        "has_tenant",
+        random_instance(Tenant, allow_null=False),
+        None,
+    )
+    has_description = NautobotBoolIterator()
+    description = factory.Maybe("has_description", factory.Faker("sentence"), "")
+
+    @factory.post_generation
+    def interfaces(self, create, extracted, **kwargs):
+        if create:
+            if extracted:
+                self.interfaces.set(extracted)
+            else:
+                self.interfaces.set(get_random_instances(Interface.objects.filter(device=self.device)))

nautobot/dcim/filters/__init__.py

@@ -21,6 +21,7 @@ from nautobot.core.utils.deprecation import class_deprecated_in_favor_of
 from nautobot.dcim.choices import (
     CableTypeChoices,
     ConsolePortTypeChoices,
+    ControllerCapabilitiesChoices,
     InterfaceTypeChoices,
     PowerOutletTypeChoices,
     PowerPortTypeChoices,
@@ -65,6 +66,7 @@ from nautobot.dcim.models import (
     InterfaceRedundancyGroup,
     InterfaceRedundancyGroupAssociation,
     InterfaceTemplate,
+    InterfaceVDCAssignment,
     InventoryItem,
     Location,
     LocationType,
@@ -88,6 +90,7 @@ from nautobot.dcim.models import (
     SoftwareImageFile,
     SoftwareVersion,
     VirtualChassis,
+    VirtualDeviceContext,
 )
 from nautobot.extras.filters import (
     LocalContextModelFilterSetMixin,
@@ -101,6 +104,7 @@ from nautobot.ipam.models import IPAddress, VLAN, VLANGroup
 from nautobot.tenancy.filters import TenancyModelFilterSetMixin
 from nautobot.tenancy.models import Tenant
 from nautobot.virtualization.models import Cluster, VirtualMachine
+from nautobot.wireless.models import RadioProfile, WirelessNetwork
 
 __all__ = (
     "CableFilterSet",
@@ -903,19 +907,26 @@ class DeviceFilterSet(
         to_field_name="version",
         label="Software version (version or ID)",
     )
-    ip_addresses = MultiValueCharFilter(
-        method="filter_ip_addresses",
-        label="IP addresses (address or ID)",
-        distinct=True,
+    radio_profiles = NaturalKeyOrPKMultipleChoiceFilter(
+        field_name="controller_managed_device_group__radio_profiles",
+        queryset=RadioProfile.objects.all(),
+        to_field_name="name",
+        label="Radio Profiles (name or ID)",
+    )
+    has_radio_profiles = RelatedMembershipBooleanFilter(
+        field_name="controller_managed_device_group__radio_profiles",
+        label="Has radio profiles",
+    )
+    wireless_networks = NaturalKeyOrPKMultipleChoiceFilter(
+        field_name="controller_managed_device_group__wireless_networks",
+        queryset=WirelessNetwork.objects.all(),
+        to_field_name="name",
+        label="Wireless Networks (name or ID)",
+    )
+    has_wireless_networks = RelatedMembershipBooleanFilter(
+        field_name="controller_managed_device_group__wireless_networks",
+        label="Has wireless networks",
     )
-    has_ip_addresses = RelatedMembershipBooleanFilter(field_name="interfaces__ip_addresses", label="Has IP addresses")
-
-    def filter_ip_addresses(self, queryset, name, value):
-        pk_values = set(item for item in value if is_uuid(item))
-        addresses = set(item for item in value if item not in pk_values)
-
-        ip_queryset = IPAddress.objects.filter_address_or_pk_in(addresses, pk_values)
-        return queryset.filter(interfaces__ip_addresses__in=ip_queryset).distinct()
 
     class Meta:
         model = Device
@@ -1143,19 +1154,15 @@ class InterfaceFilterSet(
         queryset=InterfaceRedundancyGroup.objects.all(),
         to_field_name="name",
     )
-    ip_addresses = MultiValueCharFilter(
-        method="filter_ip_addresses",
-        label="IP addresses (address or ID)",
-        distinct=True,
+    virtual_device_contexts = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=VirtualDeviceContext.objects.all(),
+        to_field_name="name",
+        label="Virtual Device Context (name or ID)",
+    )
+    has_virtual_device_contexts = RelatedMembershipBooleanFilter(
+        field_name="virtual_device_contexts",
+        label="Has Virtual Device Context",
     )
-    has_ip_addresses = RelatedMembershipBooleanFilter(field_name="ip_addresses", label="Has IP addresses")
-
-    def filter_ip_addresses(self, queryset, name, value):
-        pk_values = set(item for item in value if is_uuid(item))
-        addresses = set(item for item in value if item not in pk_values)
-
-        ip_queryset = IPAddress.objects.filter_address_or_pk_in(addresses, pk_values)
-        return queryset.filter(ip_addresses__in=ip_queryset).distinct()
 
     class Meta:
         model = Interface
@@ -1170,6 +1177,8 @@ class InterfaceFilterSet(
             "description",
             "label",
             "tags",
+            "virtual_device_contexts",
+            "interface_redundancy_groups",
         ]
 
     def generate_query_filter_device(self, value):
@@ -1847,6 +1856,12 @@ class ControllerFilterSet(
         to_field_name="name",
         label="External integration (name or ID)",
     )
+    capabilities = django_filters.MultipleChoiceFilter(
+        choices=ControllerCapabilitiesChoices,
+        null_value=None,
+        lookup_expr="icontains",
+        label="Capabilities",
+    )
     controller_device = NaturalKeyOrPKMultipleChoiceFilter(
         queryset=Device.objects.all(),
         to_field_name="name",
@@ -1857,6 +1872,12 @@ class ControllerFilterSet(
         to_field_name="name",
         label="Controller device redundancy group (name or ID)",
     )
+    wireless_networks = NaturalKeyOrPKMultipleChoiceFilter(
+        field_name="controller_managed_device_groups__wireless_networks",
+        queryset=WirelessNetwork.objects.all(),
+        to_field_name="name",
+        label="Wireless Networks (name or ID)",
+    )
 
     class Meta:
         model = Controller
@@ -1871,6 +1892,12 @@ class ControllerManagedDeviceGroupFilterSet(NautobotFilterSet):
             "name": "icontains",
         }
     )
+    capabilities = django_filters.MultipleChoiceFilter(
+        choices=ControllerCapabilitiesChoices,
+        null_value=None,
+        lookup_expr="icontains",
+        label="Capabilities",
+    )
     controller = NaturalKeyOrPKMultipleChoiceFilter(
         queryset=Controller.objects.all(),
         to_field_name="name",
@@ -1887,6 +1914,22 @@ class ControllerManagedDeviceGroupFilterSet(NautobotFilterSet):
         label="Controlled device groups and descendants thereof (name or ID)",
         method="_subtree",
     )
+    radio_profiles = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=RadioProfile.objects.all(),
+        label="Radio Profiles (name or ID)",
+    )
+    has_radio_profiles = RelatedMembershipBooleanFilter(
+        field_name="radio_profiles",
+        label="Has radio profiles",
+    )
+    wireless_networks = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=WirelessNetwork.objects.all(),
+        label="Wireless Networks (name or ID)",
+    )
+    has_wireless_networks = RelatedMembershipBooleanFilter(
+        field_name="wireless_networks",
+        label="Has wireless networks",
+    )
 
     class Meta:
         model = ControllerManagedDeviceGroup
@@ -2129,3 +2172,133 @@ class ModuleBayFilterSet(NautobotFilterSet):
     class Meta:
         model = ModuleBay
         fields = "__all__"
+
+
+class VirtualDeviceContextFilterSet(
+    NautobotFilterSet, TenancyModelFilterSetMixin, RoleModelFilterSetMixin, StatusModelFilterSetMixin
+):
+    q = SearchFilter(
+        filter_predicates={
+            "device__name": {
+                "lookup_expr": "icontains",
+                "preprocessor": str.strip,
+            },
+            "tenant__name": {
+                "lookup_expr": "icontains",
+                "preprocessor": str.strip,
+            },
+            "name": {
+                "lookup_expr": "icontains",
+                "preprocessor": str.strip,
+            },
+        }
+    )
+    primary_ip4 = MultiValueCharFilter(
+        method="filter_primary_ip4",
+        label="Primary IPv4 Address (address or ID)",
+    )
+    primary_ip6 = MultiValueCharFilter(
+        method="filter_primary_ip6",
+        label="Primary IPv6 Address (address or ID)",
+    )
+    has_primary_ip = django_filters.BooleanFilter(
+        method="_has_primary_ip",
+        label="Has a primary IP",
+    )
+    device = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=Device.objects.all(),
+        to_field_name="name",
+        label="Device (name or ID)",
+    )
+    interfaces = NaturalKeyOrPKMultipleChoiceFilter(
+        prefers_id=True,
+        queryset=Interface.objects.all(),
+        to_field_name="name",
+        label="Interface (name or ID)",
+    )
+    has_interfaces = RelatedMembershipBooleanFilter(
+        field_name="interfaces",
+        label="Has Interfaces",
+    )
+
+    class Meta:
+        model = VirtualDeviceContext
+        fields = [
+            "identifier",
+            "name",
+            "device",
+            "tenant",
+            "interfaces",
+            "has_interfaces",
+            "has_primary_ip",
+            "primary_ip4",
+            "primary_ip6",
+            "role",
+            "status",
+            "tags",
+            "description",
+        ]
+
+    # TODO(timizuo): Make a mixin for ip filterset fields to reduce code duplication
+    # VirtualMachineFilterSet,
+    def generate_query__has_primary_ip(self, value):
+        query = Q(primary_ip4__isnull=False) | Q(primary_ip6__isnull=False)
+        return ~query if not value else query
+
+    def _has_primary_ip(self, queryset, name, value):
+        params = self.generate_query__has_primary_ip(value)
+        return queryset.filter(params)
+
+    def get_ip_queryset(self, value):
+        pk_values = {item for item in value if is_uuid(item)}
+        addresses = {item for item in value if item not in pk_values}
+
+        return IPAddress.objects.filter_address_or_pk_in(addresses, pk_values)
+
+    def filter_primary_ip4(self, queryset, name, value):
+        ip_queryset = self.get_ip_queryset(value)
+        return queryset.filter(primary_ip4__in=ip_queryset)
+
+    def filter_primary_ip6(self, queryset, name, value):
+        ip_queryset = self.get_ip_queryset(value)
+        return queryset.filter(primary_ip6__in=ip_queryset)
+
+
+class InterfaceVDCAssignmentFilterSet(NautobotFilterSet):
+    q = SearchFilter(
+        filter_predicates={
+            "interface__name": {
+                "lookup_expr": "icontains",
+                "preprocessor": str.strip,
+            },
+            "virtual_device_context__name": {
+                "lookup_expr": "icontains",
+                "preprocessor": str.strip,
+            },
+        }
+    )
+    device = NaturalKeyOrPKMultipleChoiceFilter(
+        field_name="interface__device",
+        queryset=Device.objects.all(),
+        to_field_name="name",
+        label="Device (name or ID)",
+    )
+    virtual_device_context = NaturalKeyOrPKMultipleChoiceFilter(
+        queryset=VirtualDeviceContext.objects.all(),
+        to_field_name="name",
+        label="Virtual Device Context (name or ID)",
+    )
+    interface = NaturalKeyOrPKMultipleChoiceFilter(
+        prefers_id=True,
+        queryset=Interface.objects.all(),
+        to_field_name="name",
+        label="Interface (name or ID)",
+    )
+
+    class Meta:
+        model = InterfaceVDCAssignment
+        fields = [
+            "device",
+            "interface",
+            "virtual_device_context",
+        ]