class TenantFilterExtension(PluginFilterExtension):
"""Test instance showing both filterset_fields and filterform_fields in action."""
model = "tenancy.tenant"
filterset_fields = {
"example_plugin_description":
MultiValueCharFilter(field_name="description", label="Description"),
"example_plugin_sdescrip":
MultiValueCharFilter(field_name="description",
label="Description",
method=suffix_search),
"example_plugin_dtype":
MultiValueCharFilter(field_name="sites__devices__device_type__slug",
label="Device Type"),
}
filterform_fields = {
"example_plugin_description":
forms.CharField(required=False, label="Description"),
"example_plugin_dtype":
forms.CharField(required=False, label="Device Type"),
"slug__ic":
forms.CharField(required=False, label="Slug Contains"),
"example_plugin_sdescrip":
forms.CharField(required=False, label="Suffix Description"),
}
class InterfaceConnectionFilterSet(ConnectionFilterSet, BaseFilterSet):
site = django_filters.CharFilter(
method="filter_site",
label="Site (slug)",
)
device_id = MultiValueCharFilter(method="filter_device",
label="Device (ID)")
device = MultiValueCharFilter(method="filter_device",
field_name="device__name",
label="Device (name)")
class Meta:
model = Interface
fields = []
class CableFilterSet(StatusModelFilterSetMixin, BaseFilterSet):
q = django_filters.CharFilter(
method="search",
label="Search",
)
type = django_filters.MultipleChoiceFilter(choices=CableTypeChoices)
color = django_filters.MultipleChoiceFilter(choices=ColorChoices)
device_id = MultiValueNumberFilter(method="filter_device")
device = MultiValueCharFilter(method="filter_device", field_name="device__name")
rack_id = MultiValueNumberFilter(method="filter_device", field_name="device__rack_id")
rack = MultiValueNumberFilter(method="filter_device", field_name="device__rack__name")
site_id = MultiValueNumberFilter(method="filter_device", field_name="device__site_id")
site = MultiValueNumberFilter(method="filter_device", field_name="device__site__slug")
tenant_id = MultiValueNumberFilter(method="filter_device", field_name="device__tenant_id")
tenant = MultiValueNumberFilter(method="filter_device", field_name="device__tenant__slug")
tag = TagFilter()
class Meta:
model = Cable
fields = ["id", "label", "length", "length_unit"]
def search(self, queryset, name, value):
if not value.strip():
return queryset
return queryset.filter(label__icontains=value)
def filter_device(self, queryset, name, value):
queryset = queryset.filter(
Q(**{"_termination_a_{}__in".format(name): value}) | Q(**{"_termination_b_{}__in".format(name): value})
)
return queryset
class PowerConnectionFilterSet(ConnectionFilterSet, BaseFilterSet):
site = django_filters.CharFilter(
method="filter_site",
label="Site (slug)",
)
device_id = MultiValueNumberFilter(method="filter_device")
device = MultiValueCharFilter(method="filter_device", field_name="device__name")
class Meta:
model = PowerPort
fields = ["name"]
class CableFilterSet(NautobotFilterSet, StatusModelFilterSetMixin):
q = SearchFilter(filter_predicates={"label": "icontains"})
type = django_filters.MultipleChoiceFilter(choices=CableTypeChoices)
color = django_filters.MultipleChoiceFilter(choices=ColorChoices)
device_id = MultiValueUUIDFilter(method="filter_device", label="Device (ID)")
device = MultiValueCharFilter(method="filter_device", field_name="device__name", label="Device (name)")
rack_id = MultiValueUUIDFilter(method="filter_device", field_name="device__rack_id", label="Rack (ID)")
rack = MultiValueCharFilter(method="filter_device", field_name="device__rack__name", label="Rack (name)")
site_id = MultiValueUUIDFilter(method="filter_device", field_name="device__site_id", label="Site (ID)")
site = MultiValueCharFilter(method="filter_device", field_name="device__site__slug", label="Site (name)")
tenant_id = MultiValueUUIDFilter(method="filter_device", field_name="device__tenant_id", label="Tenant (ID)")
tenant = MultiValueCharFilter(method="filter_device", field_name="device__tenant__slug", label="Tenant (name)")
tag = TagFilter()
class Meta:
model = Cable
fields = ["id", "label", "length", "length_unit"]
def filter_device(self, queryset, name, value):
queryset = queryset.filter(
Q(**{"_termination_a_{}__in".format(name): value}) | Q(**{"_termination_b_{}__in".format(name): value})
)
return queryset
class TestFilterSet(BaseFilterSet):
charfield = django_filters.CharFilter()
macaddressfield = MACAddressFilter()
modelchoicefield = django_filters.ModelChoiceFilter(
field_name=
"integerfield", # We're pretending this is a ForeignKey field
queryset=Site.objects.all(),
)
modelmultiplechoicefield = django_filters.ModelMultipleChoiceFilter(
field_name=
"integerfield", # We're pretending this is a ForeignKey field
queryset=Site.objects.all(),
)
multiplechoicefield = django_filters.MultipleChoiceFilter(
field_name="choicefield")
multivaluecharfield = MultiValueCharFilter(field_name="charfield")
tagfield = TagFilter()
treeforeignkeyfield = TreeNodeMultipleChoiceFilter(
queryset=TestModel.objects.all())
class Meta:
model = TestModel
fields = (
"charfield",
"choicefield",
"datefield",
"datetimefield",
"integerfield",
"macaddressfield",
"modelchoicefield",
"modelmultiplechoicefield",
"multiplechoicefield",
"tagfield",
"textfield",
"timefield",
"treeforeignkeyfield",
)
class InterfaceFilterSet(
BaseFilterSet,
DeviceComponentFilterSet,
CableTerminationFilterSet,
PathEndpointFilterSet,
):
# Override device and device_id filters from DeviceComponentFilterSet to match against any peer virtual chassis
# members
device = MultiValueCharFilter(
method="filter_device",
field_name="name",
label="Device (name)",
)
device_id = MultiValueUUIDFilter(
method="filter_device_id",
field_name="pk",
label="Device (ID)",
)
kind = django_filters.CharFilter(
method="filter_kind",
label="Kind of interface",
)
lag_id = django_filters.ModelMultipleChoiceFilter(
field_name="lag",
queryset=Interface.objects.all(),
label="LAG interface (ID)",
)
mac_address = MultiValueMACAddressFilter()
tag = TagFilter()
vlan_id = django_filters.CharFilter(method="filter_vlan_id", label="Assigned VLAN")
vlan = django_filters.NumberFilter(method="filter_vlan", label="Assigned VID")
type = django_filters.MultipleChoiceFilter(choices=InterfaceTypeChoices, null_value=None)
class Meta:
model = Interface
fields = [
"id",
"name",
"type",
"enabled",
"mtu",
"mgmt_only",
"mode",
"description",
]
def filter_device(self, queryset, name, value):
try:
devices = Device.objects.filter(**{"{}__in".format(name): value})
vc_interface_ids = []
for device in devices:
vc_interface_ids.extend(device.vc_interfaces.values_list("id", flat=True))
return queryset.filter(pk__in=vc_interface_ids)
except Device.DoesNotExist:
return queryset.none()
def filter_device_id(self, queryset, name, id_list):
# Include interfaces belonging to peer virtual chassis members
vc_interface_ids = []
try:
devices = Device.objects.filter(pk__in=id_list)
for device in devices:
vc_interface_ids += device.vc_interfaces.values_list("id", flat=True)
return queryset.filter(pk__in=vc_interface_ids)
except Device.DoesNotExist:
return queryset.none()
def filter_vlan_id(self, queryset, name, value):
value = value.strip()
if not value:
return queryset
return queryset.filter(Q(untagged_vlan_id=value) | Q(tagged_vlans=value))
def filter_vlan(self, queryset, name, value):
value = str(value).strip()
if not value:
return queryset
return queryset.filter(Q(untagged_vlan_id__vid=value) | Q(tagged_vlans__vid=value))
def filter_kind(self, queryset, name, value):
value = value.strip().lower()
return {
"physical": queryset.exclude(type__in=NONCONNECTABLE_IFACE_TYPES),
"virtual": queryset.filter(type__in=VIRTUAL_IFACE_TYPES),
"wireless": queryset.filter(type__in=WIRELESS_IFACE_TYPES),
}.get(value, queryset.none())
class IPAddressFilterSet(
BaseFilterSet,
TenancyFilterSet,
StatusModelFilterSetMixin,
CustomFieldModelFilterSet,
CreatedUpdatedFilterSet,
):
q = django_filters.CharFilter(
method="search",
label="Search",
)
family = django_filters.NumberFilter(field_name="address",
lookup_expr="family")
parent = django_filters.CharFilter(
method="search_by_parent",
label="Parent prefix",
)
address = MultiValueCharFilter(
method="filter_address",
label="Address",
)
mask_length = django_filters.NumberFilter(
method="filter_mask_length",
label="Mask length",
)
vrf_id = django_filters.ModelMultipleChoiceFilter(
queryset=VRF.objects.all(),
label="VRF",
)
vrf = django_filters.ModelMultipleChoiceFilter(
field_name="vrf__rd",
queryset=VRF.objects.all(),
to_field_name="rd",
label="VRF (RD)",
)
present_in_vrf_id = django_filters.ModelChoiceFilter(
queryset=VRF.objects.all(),
method="filter_present_in_vrf",
label="VRF")
present_in_vrf = django_filters.ModelChoiceFilter(
queryset=VRF.objects.all(),
method="filter_present_in_vrf",
to_field_name="rd",
label="VRF (RD)",
)
device = MultiValueCharFilter(
method="filter_device",
field_name="name",
label="Device (name)",
)
device_id = MultiValueNumberFilter(
method="filter_device",
field_name="pk",
label="Device (ID)",
)
virtual_machine = MultiValueCharFilter(
method="filter_virtual_machine",
field_name="name",
label="Virtual machine (name)",
)
virtual_machine_id = MultiValueNumberFilter(
method="filter_virtual_machine",
field_name="pk",
label="Virtual machine (ID)",
)
interface = django_filters.ModelMultipleChoiceFilter(
field_name="interface__name",
queryset=Interface.objects.all(),
to_field_name="name",
label="Interface (name)",
)
interface_id = django_filters.ModelMultipleChoiceFilter(
field_name="interface",
queryset=Interface.objects.all(),
label="Interface (ID)",
)
vminterface = django_filters.ModelMultipleChoiceFilter(
field_name="vminterface__name",
queryset=VMInterface.objects.all(),
to_field_name="name",
label="VM interface (name)",
)
vminterface_id = django_filters.ModelMultipleChoiceFilter(
field_name="vminterface",
queryset=VMInterface.objects.all(),
label="VM interface (ID)",
)
assigned_to_interface = django_filters.BooleanFilter(
method="_assigned_to_interface",
label="Is assigned to an interface",
)
role = django_filters.MultipleChoiceFilter(choices=IPAddressRoleChoices)
tag = TagFilter()
class Meta:
model = IPAddress
fields = ["id", "dns_name"]
def search(self, queryset, name, value):
if not value.strip():
return queryset
qs_filter = Q(dns_name__icontains=value) | Q(
description__icontains=value) | Q(address__istartswith=value)
return queryset.filter(qs_filter)
def search_by_parent(self, queryset, name, value):
value = value.strip()
if not value:
return queryset
try:
query = str(netaddr.IPNetwork(value.strip()).cidr)
return queryset.filter(address__net_host_contained=query)
except (AddrFormatError, ValueError):
return queryset.none()
def filter_address(self, queryset, name, value):
try:
return queryset.filter(address__net_in=value)
except ValidationError:
return queryset.none()
def filter_mask_length(self, queryset, name, value):
if not value:
return queryset
return queryset.filter(address__net_mask_length=value)
def filter_present_in_vrf(self, queryset, name, vrf):
if vrf is None:
return queryset.none
return queryset.filter(
Q(vrf=vrf) | Q(vrf__export_targets__in=vrf.import_targets.all()))
def filter_device(self, queryset, name, value):
devices = Device.objects.filter(**{"{}__in".format(name): value})
if not devices.exists():
return queryset.none()
interface_ids = []
for device in devices:
interface_ids.extend(
device.vc_interfaces.values_list("id", flat=True))
return queryset.filter(interface__in=interface_ids)
def filter_virtual_machine(self, queryset, name, value):
virtual_machines = VirtualMachine.objects.filter(
**{"{}__in".format(name): value})
if not virtual_machines.exists():
return queryset.none()
interface_ids = []
for vm in virtual_machines:
interface_ids.extend(vm.interfaces.values_list("id", flat=True))
return queryset.filter(vminterface__in=interface_ids)
def _assigned_to_interface(self, queryset, name, value):
return queryset.exclude(assigned_object_id__isnull=value)
