class InterfaceFilter(django_filters.FilterSet):
"""
Not using DeviceComponentFilterSet for Interfaces because we need to check for VirtualChassis membership.
"""
device = django_filters.CharFilter(
method='filter_device',
field_name='name',
label='Device',
)
device_id = django_filters.NumberFilter(
method='filter_device',
field_name='pk',
label='Device (ID)',
)
cabled = django_filters.BooleanFilter(field_name='cable',
lookup_expr='isnull',
exclude=True)
type = django_filters.CharFilter(
method='filter_type',
label='Interface type',
)
lag_id = django_filters.ModelMultipleChoiceFilter(
field_name='lag',
queryset=Interface.objects.all(),
label='LAG interface (ID)',
)
mac_address = django_filters.CharFilter(
method='_mac_address',
label='MAC address',
)
tag = TagFilter()
vlan_id = django_filters.CharFilter(method='filter_vlan_id',
label='Assigned VLAN')
vlan = django_filters.CharFilter(method='filter_vlan',
label='Assigned VID')
form_factor = django_filters.MultipleChoiceFilter(choices=IFACE_FF_CHOICES,
null_value=None)
class Meta:
model = Interface
fields = [
'name', 'connection_status', 'form_factor', 'enabled', 'mtu',
'mgmt_only'
]
def filter_device(self, queryset, name, value):
try:
device = Device.objects.get(**{name: value})
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 = value.strip()
if not value:
return queryset
return queryset.filter(
Q(untagged_vlan_id__vid=value) | Q(tagged_vlans__vid=value))
def filter_type(self, queryset, name, value):
value = value.strip().lower()
return {
'physical':
queryset.exclude(form_factor__in=NONCONNECTABLE_IFACE_TYPES),
'virtual':
queryset.filter(form_factor__in=VIRTUAL_IFACE_TYPES),
'wireless':
queryset.filter(form_factor__in=WIRELESS_IFACE_TYPES),
'lag':
queryset.filter(form_factor=IFACE_FF_LAG),
}.get(value, queryset.none())
def _mac_address(self, queryset, name, value):
value = value.strip()
if not value:
return queryset
try:
mac = EUI(value.strip())
return queryset.filter(mac_address=mac)
except AddrFormatError:
return queryset.none()
class IPAddressFilter(TenancyFilterSet, CustomFieldFilterSet):
id__in = NumericInFilter(
field_name='id',
lookup_expr='in'
)
q = django_filters.CharFilter(
method='search',
label='Search',
)
parent = django_filters.CharFilter(
method='search_by_parent',
label='Parent prefix',
)
address = django_filters.CharFilter(
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)',
)
device = django_filters.CharFilter(
method='filter_device',
field_name='name',
label='Device',
)
device_id = django_filters.NumberFilter(
method='filter_device',
field_name='pk',
label='Device (ID)',
)
virtual_machine_id = django_filters.ModelMultipleChoiceFilter(
field_name='interface__virtual_machine',
queryset=VirtualMachine.objects.all(),
label='Virtual machine (ID)',
)
virtual_machine = django_filters.ModelMultipleChoiceFilter(
field_name='interface__virtual_machine__name',
queryset=VirtualMachine.objects.all(),
to_field_name='name',
label='Virtual machine (name)',
)
interface = django_filters.ModelMultipleChoiceFilter(
field_name='interface__name',
queryset=Interface.objects.all(),
to_field_name='name',
label='Interface (ID)',
)
interface_id = django_filters.ModelMultipleChoiceFilter(
queryset=Interface.objects.all(),
label='Interface (ID)',
)
status = django_filters.MultipleChoiceFilter(
choices=IPADDRESS_STATUS_CHOICES,
null_value=None
)
role = django_filters.MultipleChoiceFilter(
choices=IPADDRESS_ROLE_CHOICES
)
tag = TagFilter()
class Meta:
model = IPAddress
fields = ['family', '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):
if not value.strip():
return queryset
try:
# Match address and subnet mask
if '/' in value:
return queryset.filter(address=value)
return queryset.filter(address__net_host=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_device(self, queryset, name, value):
try:
device = Device.objects.prefetch_related('device_type').get(**{name: value})
vc_interface_ids = [i['id'] for i in device.vc_interfaces.values('id')]
return queryset.filter(interface_id__in=vc_interface_ids)
except Device.DoesNotExist:
return queryset.none()
class DeviceFilter(CustomFieldFilterSet, django_filters.FilterSet):
id__in = NumericInFilter(name='id', lookup_expr='in')
q = django_filters.CharFilter(
method='search',
label='Search',
)
manufacturer_id = django_filters.ModelMultipleChoiceFilter(
name='device_type__manufacturer',
queryset=Manufacturer.objects.all(),
label='Manufacturer (ID)',
)
manufacturer = django_filters.ModelMultipleChoiceFilter(
name='device_type__manufacturer__slug',
queryset=Manufacturer.objects.all(),
to_field_name='slug',
label='Manufacturer (slug)',
)
device_type_id = django_filters.ModelMultipleChoiceFilter(
queryset=DeviceType.objects.all(),
label='Device type (ID)',
)
role_id = django_filters.ModelMultipleChoiceFilter(
name='device_role_id',
queryset=DeviceRole.objects.all(),
label='Role (ID)',
)
role = django_filters.ModelMultipleChoiceFilter(
name='device_role__slug',
queryset=DeviceRole.objects.all(),
to_field_name='slug',
label='Role (slug)',
)
tenant_id = NullableModelMultipleChoiceFilter(
queryset=Tenant.objects.all(),
label='Tenant (ID)',
)
tenant = NullableModelMultipleChoiceFilter(
name='tenant',
queryset=Tenant.objects.all(),
to_field_name='slug',
label='Tenant (slug)',
)
platform_id = NullableModelMultipleChoiceFilter(
queryset=Platform.objects.all(),
label='Platform (ID)',
)
platform = NullableModelMultipleChoiceFilter(
name='platform',
queryset=Platform.objects.all(),
to_field_name='slug',
label='Platform (slug)',
)
name = NullableCharFieldFilter()
asset_tag = NullableCharFieldFilter()
site_id = django_filters.ModelMultipleChoiceFilter(
queryset=Site.objects.all(),
label='Site (ID)',
)
site = django_filters.ModelMultipleChoiceFilter(
name='site__slug',
queryset=Site.objects.all(),
to_field_name='slug',
label='Site name (slug)',
)
rack_group_id = django_filters.ModelMultipleChoiceFilter(
name='rack__group',
queryset=RackGroup.objects.all(),
label='Rack group (ID)',
)
rack_id = NullableModelMultipleChoiceFilter(
name='rack',
queryset=Rack.objects.all(),
label='Rack (ID)',
)
model = django_filters.ModelMultipleChoiceFilter(
name='device_type__slug',
queryset=DeviceType.objects.all(),
to_field_name='slug',
label='Device model (slug)',
)
status = django_filters.MultipleChoiceFilter(
choices=STATUS_CHOICES
)
is_full_depth = django_filters.BooleanFilter(
name='device_type__is_full_depth',
label='Is full depth',
)
is_console_server = django_filters.BooleanFilter(
name='device_type__is_console_server',
label='Is a console server',
)
is_pdu = django_filters.BooleanFilter(
name='device_type__is_pdu',
label='Is a PDU',
)
is_network_device = django_filters.BooleanFilter(
name='device_type__is_network_device',
label='Is a network device',
)
mac_address = django_filters.CharFilter(
method='_mac_address',
label='MAC address',
)
has_primary_ip = django_filters.BooleanFilter(
method='_has_primary_ip',
label='Has a primary IP',
)
class Meta:
model = Device
fields = ['serial']
def search(self, queryset, name, value):
if not value.strip():
return queryset
return queryset.filter(
Q(name__icontains=value) |
Q(serial__icontains=value.strip()) |
Q(inventory_items__serial__icontains=value.strip()) |
Q(asset_tag=value.strip()) |
Q(comments__icontains=value)
).distinct()
def _mac_address(self, queryset, name, value):
value = value.strip()
if not value:
return queryset
try:
mac = EUI(value.strip())
return queryset.filter(interfaces__mac_address=mac).distinct()
except AddrFormatError:
return queryset.none()
def _has_primary_ip(self, queryset, name, value):
if value:
return queryset.filter(
Q(primary_ip4__isnull=False) |
Q(primary_ip6__isnull=False)
)
else:
return queryset.exclude(
Q(primary_ip4__isnull=False) |
Q(primary_ip6__isnull=False)
)
class WorkshopStaffFilter(AMYFilterSet):
"""Form for this filter is never showed up, instead a custom form
(.forms.WorkshopStaffForm) is used. So there's no need to specify widgets
here.
"""
country = django_filters.MultipleChoiceFilter(
choices=list(Countries()),
method="filter_country",
)
continent = ContinentFilter(label="Continent")
lessons = django_filters.ModelMultipleChoiceFilter(
label='Lessons',
queryset=Lesson.objects.all(),
conjoined=True, # `AND`
)
badges = django_filters.ModelMultipleChoiceFilter(
label='Badges',
queryset=Badge.objects.instructor_badges(),
conjoined=False, # `OR`
)
is_trainer = django_filters.BooleanFilter(
widget=widgets.CheckboxInput,
method='filter_trainer',
)
languages = django_filters.ModelMultipleChoiceFilter(
label='Languages',
queryset=Language.objects.all(),
conjoined=True, # `AND`
)
gender = django_filters.ChoiceFilter(
label='Gender',
choices=Person.GENDER_CHOICES,
)
was_helper = django_filters.BooleanFilter(
widget=widgets.CheckboxInput,
method='filter_helper',
)
was_organizer = django_filters.BooleanFilter(
widget=widgets.CheckboxInput,
method='filter_organizer',
)
is_in_progress_trainee = django_filters.BooleanFilter(
widget=widgets.CheckboxInput,
method='filter_in_progress_trainee',
)
def filter_country(self, qs, n, v):
if v:
return qs.filter(
Q(airport__country__in=v) | Q(country__in=v)
)
return qs
def filter_trainer(self, qs, n, v):
if v:
return qs.filter(is_trainer__gte=1)
return qs
def filter_helper(self, qs, n, v):
if v:
return qs.filter(num_helper__gte=1)
return qs
def filter_organizer(self, qs, n, v):
if v:
return qs.filter(num_organizer__gte=1)
return qs
def filter_in_progress_trainee(self, qs, n, v):
if v:
return qs.filter(is_trainee__gte=1)
return qs
class InterfaceFilterSet(
BaseFilterSet,
DeviceComponentFilterSet,
CableTerminationFilterSet,
PathEndpointFilterSet,
):
q = django_filters.CharFilter(
method="search",
label="Search",
)
# 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 VLANFilter(CustomFieldFilterSet, django_filters.FilterSet):
id__in = NumericInFilter(name='id', lookup_expr='in')
q = django_filters.CharFilter(
method='search',
label='Search',
)
site_id = django_filters.ModelMultipleChoiceFilter(
queryset=Site.objects.all(),
label='Site (ID)',
)
site = django_filters.ModelMultipleChoiceFilter(
name='site__slug',
queryset=Site.objects.all(),
to_field_name='slug',
label='Site (slug)',
)
group_id = django_filters.ModelMultipleChoiceFilter(
queryset=VLANGroup.objects.all(),
label='Group (ID)',
)
group = django_filters.ModelMultipleChoiceFilter(
name='group__slug',
queryset=VLANGroup.objects.all(),
to_field_name='slug',
label='Group',
)
tenant_id = django_filters.ModelMultipleChoiceFilter(
queryset=Tenant.objects.all(),
label='Tenant (ID)',
)
tenant = django_filters.ModelMultipleChoiceFilter(
name='tenant__slug',
queryset=Tenant.objects.all(),
to_field_name='slug',
label='Tenant (slug)',
)
role_id = django_filters.ModelMultipleChoiceFilter(
queryset=Role.objects.all(),
label='Role (ID)',
)
role = django_filters.ModelMultipleChoiceFilter(
name='role__slug',
queryset=Role.objects.all(),
to_field_name='slug',
label='Role (slug)',
)
status = django_filters.MultipleChoiceFilter(
choices=VLAN_STATUS_CHOICES,
null_value=None
)
class Meta:
model = VLAN
fields = ['vid', 'name']
def search(self, queryset, name, value):
if not value.strip():
return queryset
qs_filter = Q(name__icontains=value) | Q(description__icontains=value)
try:
qs_filter |= Q(vid=int(value.strip()))
except ValueError:
pass
return queryset.filter(qs_filter)
class VirtualMachineFilter(CustomFieldFilterSet):
id__in = NumericInFilter(name='id', lookup_expr='in')
q = django_filters.CharFilter(
method='search',
label='Search',
)
status = django_filters.MultipleChoiceFilter(
choices=VM_STATUS_CHOICES,
null_value=None
)
cluster_group_id = django_filters.ModelMultipleChoiceFilter(
name='cluster__group',
queryset=ClusterGroup.objects.all(),
label='Cluster group (ID)',
)
cluster_group = django_filters.ModelMultipleChoiceFilter(
name='cluster__group__slug',
queryset=ClusterGroup.objects.all(),
to_field_name='slug',
label='Cluster group (slug)',
)
cluster_type_id = django_filters.ModelMultipleChoiceFilter(
name='cluster__type',
queryset=ClusterType.objects.all(),
label='Cluster type (ID)',
)
cluster_type = django_filters.ModelMultipleChoiceFilter(
name='cluster__type__slug',
queryset=ClusterType.objects.all(),
to_field_name='slug',
label='Cluster type (slug)',
)
cluster_id = django_filters.ModelMultipleChoiceFilter(
queryset=Cluster.objects.all(),
label='Cluster (ID)',
)
region_id = django_filters.NumberFilter(
method='filter_region',
name='pk',
label='Region (ID)',
)
region = django_filters.CharFilter(
method='filter_region',
name='slug',
label='Region (slug)',
)
site_id = django_filters.ModelMultipleChoiceFilter(
name='cluster__site',
queryset=Site.objects.all(),
label='Site (ID)',
)
site = django_filters.ModelMultipleChoiceFilter(
name='cluster__site__slug',
queryset=Site.objects.all(),
to_field_name='slug',
label='Site (slug)',
)
role_id = django_filters.ModelMultipleChoiceFilter(
queryset=DeviceRole.objects.all(),
label='Role (ID)',
)
role = django_filters.ModelMultipleChoiceFilter(
name='role__slug',
queryset=DeviceRole.objects.all(),
to_field_name='slug',
label='Role (slug)',
)
tenant_id = django_filters.ModelMultipleChoiceFilter(
queryset=Tenant.objects.all(),
label='Tenant (ID)',
)
tenant = django_filters.ModelMultipleChoiceFilter(
name='tenant__slug',
queryset=Tenant.objects.all(),
to_field_name='slug',
label='Tenant (slug)',
)
platform_id = django_filters.ModelMultipleChoiceFilter(
queryset=Platform.objects.all(),
label='Platform (ID)',
)
platform = django_filters.ModelMultipleChoiceFilter(
name='platform__slug',
queryset=Platform.objects.all(),
to_field_name='slug',
label='Platform (slug)',
)
tag = django_filters.CharFilter(
name='tags__slug',
)
class Meta:
model = VirtualMachine
fields = ['name', 'cluster']
def search(self, queryset, name, value):
if not value.strip():
return queryset
return queryset.filter(
Q(name__icontains=value) |
Q(comments__icontains=value)
)
def filter_region(self, queryset, name, value):
try:
region = Region.objects.get(**{name: value})
except ObjectDoesNotExist:
return queryset.none()
return queryset.filter(
Q(cluster__site__region=region) |
Q(cluster__site__region__in=region.get_descendants())
)
class CircuitFilterSet(PrimaryModelFilterSet, TenancyFilterSet):
q = django_filters.CharFilter(
method='search',
label='Search',
)
provider_id = django_filters.ModelMultipleChoiceFilter(
queryset=Provider.objects.all(),
label='Provider (ID)',
)
provider = django_filters.ModelMultipleChoiceFilter(
field_name='provider__slug',
queryset=Provider.objects.all(),
to_field_name='slug',
label='Provider (slug)',
)
provider_network_id = django_filters.ModelMultipleChoiceFilter(
field_name='terminations__provider_network',
queryset=ProviderNetwork.objects.all(),
label='ProviderNetwork (ID)',
)
type_id = django_filters.ModelMultipleChoiceFilter(
queryset=CircuitType.objects.all(),
label='Circuit type (ID)',
)
type = django_filters.ModelMultipleChoiceFilter(
field_name='type__slug',
queryset=CircuitType.objects.all(),
to_field_name='slug',
label='Circuit type (slug)',
)
status = django_filters.MultipleChoiceFilter(choices=CircuitStatusChoices,
null_value=None)
region_id = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name='terminations__site__region',
lookup_expr='in',
label='Region (ID)',
)
region = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name='terminations__site__region',
lookup_expr='in',
to_field_name='slug',
label='Region (slug)',
)
site_group_id = TreeNodeMultipleChoiceFilter(
queryset=SiteGroup.objects.all(),
field_name='terminations__site__group',
lookup_expr='in',
label='Site group (ID)',
)
site_group = TreeNodeMultipleChoiceFilter(
queryset=SiteGroup.objects.all(),
field_name='terminations__site__group',
lookup_expr='in',
to_field_name='slug',
label='Site group (slug)',
)
site_id = django_filters.ModelMultipleChoiceFilter(
field_name='terminations__site',
queryset=Site.objects.all(),
label='Site (ID)',
)
site = django_filters.ModelMultipleChoiceFilter(
field_name='terminations__site__slug',
queryset=Site.objects.all(),
to_field_name='slug',
label='Site (slug)',
)
tag = TagFilter()
class Meta:
model = Circuit
fields = ['id', 'cid', 'install_date', 'commit_rate']
def search(self, queryset, name, value):
if not value.strip():
return queryset
return queryset.filter(
Q(cid__icontains=value)
| Q(terminations__xconnect_id__icontains=value)
| Q(terminations__pp_info__icontains=value)
| Q(terminations__description__icontains=value)
| Q(description__icontains=value)
| Q(comments__icontains=value)).distinct()
class IPAddressFilterSet(BaseFilterSet, TenancyFilterSet, CustomFieldFilterSet,
CreatedUpdatedFilterSet):
id__in = NumericInFilter(field_name='id', lookup_expr='in')
q = django_filters.CharFilter(
method='search',
label='Search',
)
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)',
)
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_id = django_filters.ModelMultipleChoiceFilter(
field_name='interface__virtual_machine',
queryset=VirtualMachine.objects.all(),
label='Virtual machine (ID)',
)
virtual_machine = django_filters.ModelMultipleChoiceFilter(
field_name='interface__virtual_machine__name',
queryset=VirtualMachine.objects.all(),
to_field_name='name',
label='Virtual machine (name)',
)
interface = django_filters.ModelMultipleChoiceFilter(
field_name='interface__name',
queryset=Interface.objects.all(),
to_field_name='name',
label='Interface (ID)',
)
interface_id = django_filters.ModelMultipleChoiceFilter(
queryset=Interface.objects.all(),
label='Interface (ID)',
)
assigned_to_interface = django_filters.BooleanFilter(
method='_assigned_to_interface',
label='Is assigned to an interface',
)
status = django_filters.MultipleChoiceFilter(
choices=IPAddressStatusChoices, null_value=None)
role = django_filters.MultipleChoiceFilter(choices=IPAddressRoleChoices)
tag = TagFilter()
class Meta:
model = IPAddress
fields = ['family', '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_device(self, queryset, name, value):
try:
devices = Device.objects.prefetch_related('device_type').filter(
**{'{}__in'.format(name): value})
vc_interface_ids = []
for device in devices:
vc_interface_ids.extend(
[i['id'] for i in device.vc_interfaces.values('id')])
return queryset.filter(interface_id__in=vc_interface_ids)
except Device.DoesNotExist:
return queryset.none()
def _assigned_to_interface(self, queryset, name, value):
return queryset.exclude(interface__isnull=value)
class InterfaceFilterSet(BaseFilterSet, DeviceComponentFilterSet,
CableTerminationFilterSet, PathEndpointFilterSet):
q = django_filters.CharFilter(
method='search',
label='Search',
)
# 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',
)
device_id = MultiValueNumberFilter(
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.CharFilter(method='filter_vlan',
label='Assigned VID')
type = django_filters.MultipleChoiceFilter(choices=InterfaceTypeChoices,
null_value=None)
class Meta:
model = Interface
fields = [
'id', 'name', 'label', '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 = 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 ResourceContainerFilter(django_filters.FilterSet):
name = django_filters.CharFilter(method='lookup_using_name_index')
content = django_filters.CharFilter(name='primary__indexable_content',
lookup_expr='icontains')
part_of = django_filters.ModelChoiceFilter(name='part_of', queryset=Collection.objects.all())
# FIXME: The following statement results in a very expensive Postgres query.
# entity_type = django_filters.ModelChoiceFilter(
# name='primary__entity_type',
# queryset=Type.objects.annotate(num_instances=Count('resource'))\
# .filter(num_instances__gt=0)
# )
# As a temporary workaround, use a static list for choices.
entity_type = django_filters.ModelChoiceFilter(
name='primary__entity_type',
queryset=Type.objects.all(),
)
# FIXME: The following statement results in a very expensive Postgres query.
# As a temporary workaround, use a static list for choices.
# content_type = django_filters.MultipleChoiceFilter(choices=[(val, val) for val in ContentRelation.objects.values_list('content_type', flat=True).distinct('content_type')], method='filter_content_type')
content_type_choices = [
'application/java-archive',
'application/javascript',
'application/json',
'application/msword',
'application/octet-stream',
'application/pdf',
'application/rtf',
'application/vnd.apple.pages',
'application/vnd.ms-excel',
'application/vnd.oasis.opendocument.text',
'application/vnd.openxmlformats-officedocument.presentationml.presentation',
'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
'application/x-bibtex-text-file',
'application/xhtml+xml',
'application/x-java-archive',
'application/xml',
'application/x-msdownload',
'application/x-msdownload; format=pe32',
'application/x-sh',
'application/x-sqlite3',
'application/x-tika-msoffice',
'application/zip',
'image/gif',
'image/png',
'image/tiff',
'image/vnd.microsoft.icon',
'message/news',
'multipart/appledouble',
'text/css',
'text/csv',
'text/html',
'text/html; charset=utf-8',
'text/plain',
'text/tab-separated-values',
'text/x-matlab',
'text/xml',
'text/x-python',
'video/quicktime',
]
content_type = django_filters.MultipleChoiceFilter(
choices=zip(content_type_choices, content_type_choices), method='filter_content_type')
tag = django_filters.CharFilter(method='filter_tag')
def filter_tag(self, queryset, value):
if not value:
return queryset
return queryset.filter(primary__tags__tag__id=value)
def filter_content_type(self, queryset, name, value):
if not value:
return queryset
return queryset.filter(Q(content_relations__content_type__in=value)).distinct('id')
def lookup_name_in_parts(self, queryset, name, value):
q = Q()
for part in value.split():
q &= Q(primary__name__icontains=part)
return queryset.filter(q)
def lookup_using_name_index(self, queryset, name, value):
return queryset.filter(primary__name_index__plain_tsquery=value)
o = django_filters.OrderingFilter(
# tuple-mapping retains order
fields=(
('primary__name', 'name'),
('primary__entity_type', 'type'),
),
field_labels={
'name': 'Name',
'type': 'Type',
}
)
class Meta:
model = Resource
fields = ['name', 'entity_type', 'content', 'created_by', 'part_of']
strict = 'STRICTNESS.IGNORE'
class IPAddressFilterSet(
BaseFilterSet,
TenancyFilterSet,
StatusModelFilterSetMixin,
CustomFieldModelFilterSet,
CreatedUpdatedFilterSet,
):
q = django_filters.CharFilter(
method="search",
label="Search",
)
family = django_filters.NumberFilter(
method="filter_ip_family",
label="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 = MultiValueCharFilter(
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 = MultiValueCharFilter(
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):
return queryset.string_search(value)
def search_by_parent(self, queryset, name, value):
value = value.strip()
if not value:
return queryset
try:
query = netaddr.IPNetwork(value.strip()).cidr
return queryset.net_host_contained(query)
except (AddrFormatError, ValueError):
return queryset.none()
def filter_address(self, queryset, name, value):
try:
return queryset.net_in(value)
except ValidationError:
return queryset.none()
def filter_mask_length(self, queryset, name, value):
if not value:
return queryset
return queryset.filter(prefix_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_ip_family(self, queryset, name, value):
return queryset.ip_family(value)
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)
class Reg02MaininfoFilter(filters.FilterSet):
regdate = filters.DateFromToRangeFilter(widget=filters.widgets.RangeWidget(
attrs={'class': 'datepicker'}))
farmername = filters.CharFilter(label='Farmername Auto Search',
lookup_expr='icontains')
farmermobile = filters.CharFilter(lookup_expr='icontains')
hhhname = filters.CharFilter(lookup_expr='icontains')
hhhmobile = filters.CharFilter(lookup_expr='icontains')
#nmale0to5 = filters.NumberFilter(
# widget=widgets.NumberInput(
# attrs={'min':0,'max':5}
# )
#)
animcatowned = filters.MultipleChoiceFilter(
label='Animal categories owned at farm',
choices=constants.ANIMAL_CATEGORIES,
method='filter_animal_categories',
help_text='Hold CTRL button to select multiple entries')
hhproblems = filters.MultipleChoiceFilter(
label='House Hold Problem',
choices=constants.HOUSE_HOLD_PROBLEMS,
method='filter_household_problems',
help_text='Hold CTRL button to select multiple entriess')
hhproblemsoth = filters.CharFilter(
label='Other House Hold Problem',
lookup_expr='icontains',
)
#animcatowned_exact = filters.MultipleChoiceFilter(
# label='Animal categories exactly owned at farm',
# choices=constants.ANIMAL_CATEGORIES,
# method='filter_exact_animal_categories',
# help_text='Hold CTRL button to select multiple entries'
#)
class Meta:
model = Reg02Maininfo
#fields = ('regdate', 'farmername', 'farmermobile', 'hhhname', 'hhhmobile','hhhgender',
# 'hh_district', 'farmerhhhead',
# )
exclude = ('surveyid', 'deviceid', 'originid', 'icow', 'rowuuid',
'start_time', 'end_time', 'farmerhhhead', 'nmale0to5',
'nfem0to5', 'nmale6to14', 'nfem6to14', 'nmale15to64',
'nmaleo65', 'nfemo65', 'nfem15to64', 'gpsloc',
'welcomesent', 'apologysent', 'inpaidbundle',
'inadggbundle')
form = OptionsForm
def filter_animal_categories(self, queryset, name, value):
option = self.data['options']
if option == 'e':
items = [
item.pk for item in queryset
if set(value) == set(item.animals_categories_numbers)
]
elif option == 'a':
items = [
item.pk for item in queryset
if set(value).issubset(item.animals_categories_numbers)
]
elif option == 'o':
items = []
for item in queryset:
for el in value:
if el in item.animals_categories_numbers:
items.append(item.pk)
return queryset.filter(pk__in=items)
def filter_household_problems(self, queryset, name, value):
option = self.data['options']
if option == 'e':
items = [
item.pk for item in queryset
if set(value) == set(item.house_hold_problem_numbers)
]
elif option == 'a':
items = [
item.pk for item in queryset
if set(value).issubset(item.house_hold_problem_numbers)
]
elif option == 'o':
items = []
for item in queryset:
for el in value:
if el in item.house_hold_problem_numbers:
items.append(item.pk)
return queryset.filter(pk__in=items)
class VirtualMachineFilter(CustomFieldFilterSet):
id__in = NumericInFilter(name='id', lookup_expr='in')
q = django_filters.CharFilter(
method='search',
label='Search',
)
status = django_filters.MultipleChoiceFilter(choices=STATUS_CHOICES)
cluster_group_id = django_filters.ModelMultipleChoiceFilter(
name='cluster__group',
queryset=ClusterGroup.objects.all(),
label='Cluster group (ID)',
)
cluster_group = django_filters.ModelMultipleChoiceFilter(
name='cluster__group__slug',
queryset=ClusterGroup.objects.all(),
to_field_name='slug',
label='Cluster group (slug)',
)
cluster_id = django_filters.ModelMultipleChoiceFilter(
queryset=Cluster.objects.all(),
label='Cluster (ID)',
)
role_id = django_filters.ModelMultipleChoiceFilter(
queryset=DeviceRole.objects.all(),
label='Role (ID)',
)
role = django_filters.ModelMultipleChoiceFilter(
name='role__slug',
queryset=DeviceRole.objects.all(),
to_field_name='slug',
label='Role (slug)',
)
tenant_id = django_filters.ModelMultipleChoiceFilter(
queryset=Tenant.objects.all(),
label='Tenant (ID)',
)
tenant = django_filters.ModelMultipleChoiceFilter(
name='tenant__slug',
queryset=Tenant.objects.all(),
to_field_name='slug',
label='Tenant (slug)',
)
platform_id = django_filters.ModelMultipleChoiceFilter(
queryset=Platform.objects.all(),
label='Platform (ID)',
)
platform = django_filters.ModelMultipleChoiceFilter(
name='platform__slug',
queryset=Platform.objects.all(),
to_field_name='slug',
label='Platform (slug)',
)
class Meta:
model = VirtualMachine
fields = ['name', 'cluster']
def search(self, queryset, name, value):
if not value.strip():
return queryset
return queryset.filter(
Q(name__icontains=value) | Q(comments__icontains=value))
class InterfaceFilter(django_filters.FilterSet):
"""
Not using DeviceComponentFilterSet for Interfaces because we need to check for VirtualChassis membership.
"""
q = django_filters.CharFilter(
method='search',
label='Search',
)
device = MultiValueCharFilter(
method='filter_device',
field_name='name',
label='Device',
)
device_id = MultiValueNumberFilter(
method='filter_device_id',
field_name='pk',
label='Device (ID)',
)
cabled = django_filters.BooleanFilter(field_name='cable',
lookup_expr='isnull',
exclude=True)
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.CharFilter(method='filter_vlan',
label='Assigned VID')
type = django_filters.MultipleChoiceFilter(choices=IFACE_TYPE_CHOICES,
null_value=None)
class Meta:
model = Interface
fields = [
'id', 'name', 'connection_status', 'type', 'enabled', 'mtu',
'mgmt_only', 'mode', 'description'
]
def search(self, queryset, name, value):
if not value.strip():
return queryset
return queryset.filter(
Q(name__icontains=value)
| Q(description__icontains=value)).distinct()
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 = 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 VLANFilterSet(BaseFilterSet, TenancyFilterSet, CustomFieldFilterSet,
CreatedUpdatedFilterSet):
id__in = NumericInFilter(field_name='id', lookup_expr='in')
q = django_filters.CharFilter(
method='search',
label='Search',
)
region_id = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name='site__region',
lookup_expr='in',
label='Region (ID)',
)
region = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name='site__region',
lookup_expr='in',
to_field_name='slug',
label='Region (slug)',
)
site_id = django_filters.ModelMultipleChoiceFilter(
queryset=Site.objects.all(),
label='Site (ID)',
)
site = django_filters.ModelMultipleChoiceFilter(
field_name='site__slug',
queryset=Site.objects.all(),
to_field_name='slug',
label='Site (slug)',
)
group_id = django_filters.ModelMultipleChoiceFilter(
queryset=VLANGroup.objects.all(),
label='Group (ID)',
)
group = django_filters.ModelMultipleChoiceFilter(
field_name='group__slug',
queryset=VLANGroup.objects.all(),
to_field_name='slug',
label='Group',
)
role_id = django_filters.ModelMultipleChoiceFilter(
queryset=Role.objects.all(),
label='Role (ID)',
)
role = django_filters.ModelMultipleChoiceFilter(
field_name='role__slug',
queryset=Role.objects.all(),
to_field_name='slug',
label='Role (slug)',
)
status = django_filters.MultipleChoiceFilter(choices=VLANStatusChoices,
null_value=None)
tag = TagFilter()
class Meta:
model = VLAN
fields = ['vid', 'name']
def search(self, queryset, name, value):
if not value.strip():
return queryset
qs_filter = Q(name__icontains=value) | Q(description__icontains=value)
try:
qs_filter |= Q(vid=int(value.strip()))
except ValueError:
pass
return queryset.filter(qs_filter)
class IPAddressFilter(CustomFieldFilterSet, django_filters.FilterSet):
id__in = NumericInFilter(name='id', lookup_expr='in')
q = django_filters.CharFilter(
method='search',
label='Search',
)
parent = django_filters.CharFilter(
method='search_by_parent',
label='Parent prefix',
)
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(
name='vrf__rd',
queryset=VRF.objects.all(),
to_field_name='rd',
label='VRF (RD)',
)
tenant_id = django_filters.ModelMultipleChoiceFilter(
queryset=Tenant.objects.all(),
label='Tenant (ID)',
)
tenant = django_filters.ModelMultipleChoiceFilter(
name='tenant__slug',
queryset=Tenant.objects.all(),
to_field_name='slug',
label='Tenant (slug)',
)
device_id = django_filters.ModelMultipleChoiceFilter(
name='interface__device',
queryset=Device.objects.all(),
label='Device (ID)',
)
device = django_filters.ModelMultipleChoiceFilter(
name='interface__device__name',
queryset=Device.objects.all(),
to_field_name='name',
label='Device (name)',
)
virtual_machine_id = django_filters.ModelMultipleChoiceFilter(
name='interface__virtual_machine',
queryset=VirtualMachine.objects.all(),
label='Virtual machine (ID)',
)
virtual_machine = django_filters.ModelMultipleChoiceFilter(
name='interface__virtual_machine__name',
queryset=VirtualMachine.objects.all(),
to_field_name='name',
label='Virtual machine (name)',
)
interface_id = django_filters.ModelMultipleChoiceFilter(
queryset=Interface.objects.all(),
label='Interface (ID)',
)
status = django_filters.MultipleChoiceFilter(
choices=IPADDRESS_STATUS_CHOICES,
null_value=None
)
role = django_filters.MultipleChoiceFilter(
choices=IPADDRESS_ROLE_CHOICES
)
class Meta:
model = IPAddress
fields = ['family']
def search(self, queryset, name, value):
if not value.strip():
return queryset
qs_filter = (
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_mask_length(self, queryset, name, value):
if not value:
return queryset
return queryset.filter(address__net_mask_length=value)
class LastChangedFilter(django_filters.FilterSet):
telescope_class = django_filters.MultipleChoiceFilter(
choices=configdb.get_telescope_class_tuples())
class MultipleChoiceFieldFilterSet(django_filters.FilterSet):
is_featured = django_filters.MultipleChoiceFilter(
label="Is featured", choices=[(0, "Featured"), (1, "Not featured")]
)
class DriverRecordFilter(RecordFilter):
"""Extend RecordFilter to allow filtering on created date."""
created_min = django_filters.IsoDateTimeFilter(name="created",
lookup_expr='gte')
created_max = django_filters.IsoDateTimeFilter(name="created",
lookup_expr='lte')
created_by = django_filters.Filter(field_name='created_by',
method='filter_created_by')
weather = django_filters.MultipleChoiceFilter(choices=WEATHER_CHOICES)
archived = django_filters.BooleanFilter(name='archived')
outside_boundary = django_filters.Filter(field_name='geom',
method='filter_outside_boundary')
def __init__(self, data=None, *args, **kwargs):
# if filterset is bound, use initial values as defaults
if data is not None:
# get a mutable copy of the QueryDict
data = data.copy()
if not data.get('archived'):
data['archived'] = "False"
super(DriverRecordFilter, self).__init__(data, *args, **kwargs)
def filter_outside_boundary(self, queryset, field_name, boundary_uuid):
"""Filter records that fall outside the specified boundary."""
redis_conn = get_redis_connection('boundaries')
bounds_hexewkb = redis_conn.get(boundary_uuid)
one_month_seconds = 30 * 24 * 60 * 60
if bounds_hexewkb is None:
try:
boundary = Boundary.objects.get(pk=boundary_uuid)
except ValidationError:
raise ParseError('outside_boundary was passed an invalid UUID')
except Boundary.DoesNotExist:
raise NotFound('Boundary not found')
unioned_bounds = boundary.polygons.aggregate(
all_polys=Union('geom'))['all_polys']
# Full resolution is very slow, so simplify down to roughly 100m (DRIVER is in lat/lon).
unioned_bounds = unioned_bounds.simplify(tolerance=0.001,
preserve_topology=True)
redis_conn.set(boundary_uuid, str(unioned_bounds.hexewkb),
one_month_seconds)
else:
redis_conn.expire(boundary_uuid, one_month_seconds)
unioned_bounds = GEOSGeometry(bounds_hexewkb)
return queryset.exclude(geom__intersects=unioned_bounds)
def filter_created_by(self, queryset, name, value):
""" Filter records by the email or username of the creating user."""
if not is_admin_or_writer(self.request.user):
# Public users cannot filter by creating user
return queryset
return queryset.filter(
Q(recordauditlogentry__action=RecordAuditLogEntry.ActionTypes.
CREATE) & (Q(recordauditlogentry__username=value)
| Q(recordauditlogentry__user__email=value)))
class Meta:
model = DriverRecord
fields = ['created_min', 'created_max']
class VirtualMachineFilter(TenancyFilterSet, CustomFieldFilterSet):
id__in = NumericInFilter(field_name='id', lookup_expr='in')
q = django_filters.CharFilter(
method='search',
label='Search',
)
status = django_filters.MultipleChoiceFilter(choices=VM_STATUS_CHOICES,
null_value=None)
cluster_group_id = django_filters.ModelMultipleChoiceFilter(
field_name='cluster__group',
queryset=ClusterGroup.objects.all(),
label='Cluster group (ID)',
)
cluster_group = django_filters.ModelMultipleChoiceFilter(
field_name='cluster__group__slug',
queryset=ClusterGroup.objects.all(),
to_field_name='slug',
label='Cluster group (slug)',
)
cluster_type_id = django_filters.ModelMultipleChoiceFilter(
field_name='cluster__type',
queryset=ClusterType.objects.all(),
label='Cluster type (ID)',
)
cluster_type = django_filters.ModelMultipleChoiceFilter(
field_name='cluster__type__slug',
queryset=ClusterType.objects.all(),
to_field_name='slug',
label='Cluster type (slug)',
)
cluster_id = django_filters.ModelMultipleChoiceFilter(
queryset=Cluster.objects.all(),
label='Cluster (ID)',
)
region_id = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name='cluster__site__region__in',
label='Region (ID)',
)
region = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name='cluster__site__region__in',
to_field_name='slug',
label='Region (slug)',
)
site_id = django_filters.ModelMultipleChoiceFilter(
field_name='cluster__site',
queryset=Site.objects.all(),
label='Site (ID)',
)
site = django_filters.ModelMultipleChoiceFilter(
field_name='cluster__site__slug',
queryset=Site.objects.all(),
to_field_name='slug',
label='Site (slug)',
)
role_id = django_filters.ModelMultipleChoiceFilter(
queryset=DeviceRole.objects.all(),
label='Role (ID)',
)
role = django_filters.ModelMultipleChoiceFilter(
field_name='role__slug',
queryset=DeviceRole.objects.all(),
to_field_name='slug',
label='Role (slug)',
)
platform_id = django_filters.ModelMultipleChoiceFilter(
queryset=Platform.objects.all(),
label='Platform (ID)',
)
platform = django_filters.ModelMultipleChoiceFilter(
field_name='platform__slug',
queryset=Platform.objects.all(),
to_field_name='slug',
label='Platform (slug)',
)
mac_address = MultiValueMACAddressFilter(
field_name='interfaces__mac_address',
label='MAC address',
)
tag = TagFilter()
class Meta:
model = VirtualMachine
fields = ['id', 'name', 'cluster', 'vcpus', 'memory', 'disk']
def search(self, queryset, name, value):
if not value.strip():
return queryset
return queryset.filter(
Q(name__icontains=value) | Q(comments__icontains=value))
class MonsterInstanceFilter(django_filters.FilterSet):
monster = django_filters.NumberFilter()
monster__name = django_filters.CharFilter(method='filter_monster__name')
tags__pk = django_filters.ModelMultipleChoiceFilter(
queryset=MonsterTag.objects.all(), to_field_name='pk', conjoined=True)
monster__element = django_filters.MultipleChoiceFilter(
choices=Monster.ELEMENT_CHOICES)
monster__archetype = django_filters.MultipleChoiceFilter(
choices=Monster.TYPE_CHOICES)
monster__awaken_level = django_filters.MultipleChoiceFilter(
choices=Monster.AWAKEN_CHOICES)
priority = django_filters.MultipleChoiceFilter(
choices=MonsterInstance.PRIORITY_CHOICES)
monster__leader_skill__attribute = django_filters.MultipleChoiceFilter(
choices=LeaderSkill.ATTRIBUTE_CHOICES)
monster__leader_skill__area = django_filters.MultipleChoiceFilter(
choices=LeaderSkill.AREA_CHOICES)
monster__skills__scaling_stats__pk = django_filters.ModelMultipleChoiceFilter(
queryset=ScalingStat.objects.all(), to_field_name='pk', conjoined=True)
monster__skills__skill_effect__pk = django_filters.ModelMultipleChoiceFilter(
queryset=SkillEffect.objects.all(),
method='filter_monster__skills__skill_effect__pk')
effects_logic = django_filters.BooleanFilter(method='filter_effects_logic')
monster__fusion_food = django_filters.BooleanFilter(
method='filter_monster__fusion_food')
class Meta:
model = MonsterInstance
fields = {
'monster': ['exact'],
'monster__name': ['exact'],
'tags__pk': ['exact'],
'stars': ['gte', 'lte'],
'level': ['gte', 'lte'],
'monster__element': ['exact'],
'monster__archetype': ['exact'],
'priority': ['exact'],
'monster__awaken_level': ['exact'],
'monster__leader_skill__attribute': ['exact'],
'monster__leader_skill__area': ['exact'],
'monster__skills__skill_effect__pk': ['exact'],
'monster__skills__scaling_stats__pk': ['exact'],
'effects_logic': ['exact'],
'fodder': ['exact'],
'in_storage': ['exact'],
'monster__fusion_food': ['exact'],
}
def filter_monster__name(self, queryset, name, value):
if value:
return queryset.filter(monster__name__istartswith=value)
else:
return queryset
def filter_monster__fusion_food(self, queryset, name, value):
if value:
return queryset.filter(monster__fusion_food=True).exclude(
ignore_for_fusion=True)
else:
return queryset.filter(
Q(monster__fusion_food=False) | Q(ignore_for_fusion=True))
def filter_monster__skills__skill_effect__pk(self, queryset, name, value):
old_filtering = self.form.cleaned_data.get('effects_logic', False)
stat_scaling = self.form.cleaned_data.get(
'monster__skills__scaling_stats__pk', [])
if old_filtering:
# Filter if any skill on the monster has the designated fields
for effect in value:
queryset = queryset.filter(
monster__skills__skill_effect=effect)
for pk in stat_scaling:
queryset = queryset.filter(monster__skills__scaling_stats=pk)
return queryset.distinct()
else:
# Filter effects based on effects of each individual skill. This ensures a monster will not show up unless it has
# the desired effects on the same skill rather than across any skills.
skills = Skill.objects.all()
for effect in value:
skills = skills.filter(skill_effect=effect)
for pk in stat_scaling:
skills = skills.filter(scaling_stats=pk)
return queryset.filter(monster__skills__in=skills).distinct()
def filter_effects_logic(self, queryset, name, value):
# This field is just used to alter the logic of skill effect filter and is used in filter_monster__skills__skill_effect__pk()
return queryset
class RackFilterSet(NautobotFilterSet, TenancyFilterSet,
StatusModelFilterSetMixin):
q = django_filters.CharFilter(
method="search",
label="Search",
)
region_id = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name="site__region",
lookup_expr="in",
label="Region (ID)",
)
region = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name="site__region",
lookup_expr="in",
to_field_name="slug",
label="Region (slug)",
)
site_id = django_filters.ModelMultipleChoiceFilter(
queryset=Site.objects.all(),
label="Site (ID)",
)
site = django_filters.ModelMultipleChoiceFilter(
field_name="site__slug",
queryset=Site.objects.all(),
to_field_name="slug",
label="Site (slug)",
)
group_id = TreeNodeMultipleChoiceFilter(
queryset=RackGroup.objects.all(),
field_name="group",
lookup_expr="in",
label="Rack group (ID)",
)
group = TreeNodeMultipleChoiceFilter(
queryset=RackGroup.objects.all(),
field_name="group",
lookup_expr="in",
to_field_name="slug",
label="Rack group (slug)",
)
type = django_filters.MultipleChoiceFilter(choices=RackTypeChoices)
width = django_filters.MultipleChoiceFilter(choices=RackWidthChoices)
role_id = django_filters.ModelMultipleChoiceFilter(
queryset=RackRole.objects.all(),
label="Role (ID)",
)
role = django_filters.ModelMultipleChoiceFilter(
field_name="role__slug",
queryset=RackRole.objects.all(),
to_field_name="slug",
label="Role (slug)",
)
serial = django_filters.CharFilter(lookup_expr="iexact")
tag = TagFilter()
class Meta:
model = Rack
fields = [
"id",
"name",
"facility_id",
"asset_tag",
"u_height",
"desc_units",
"outer_width",
"outer_depth",
"outer_unit",
]
def search(self, queryset, name, value):
if not value.strip():
return queryset
return queryset.filter(
Q(name__icontains=value)
| Q(facility_id__icontains=value)
| Q(serial__icontains=value.strip())
| Q(asset_tag__icontains=value.strip())
| Q(comments__icontains=value))
class PersonFilter(django_filters.FilterSet):
city_of_birth_text = 'city of birth'
city_of_death_text = 'city of death'
city_of_residence_text = 'city of residence'
place_help = ' <span class="glyphicon glyphicon-question-sign" ' \
'title="When known, the MEDIATE database lists the {} of Persons. ' \
'In other cases, it lists a region, county, or other geographic entity."></span>'
short_name = django_filters.Filter(method='short_name_filter')
surname = django_filters.Filter(method='surname_filter')
sex = django_filters.MultipleChoiceFilter(
choices=Person.SEX_CHOICES,
widget=Select2MultipleWidget(
attrs={'data-placeholder': "Select multiple"}, ))
city_of_birth = django_filters.ModelMultipleChoiceFilter(
label=mark_safe(
_("Place of birth") + place_help.format(city_of_birth_text)),
queryset=Place.objects.all(),
widget=Select2MultipleWidget(
attrs={'data-placeholder': "Select multiple"}, ))
country_of_birth = django_filters.ModelMultipleChoiceFilter(
label="Country of birth",
queryset=Country.objects.all(),
widget=Select2MultipleWidget(
attrs={'data-placeholder': "Select multiple"}, ),
field_name='city_of_birth__country',
lookup_expr='in')
city_of_death = django_filters.ModelMultipleChoiceFilter(
label=mark_safe(
_("Place of death") + place_help.format(city_of_death_text)),
queryset=Place.objects.all(),
widget=Select2MultipleWidget(
attrs={'data-placeholder': "Select multiple"}, ))
country_of_death = django_filters.ModelMultipleChoiceFilter(
label="Country of death",
queryset=Country.objects.all(),
widget=Select2MultipleWidget(
attrs={'data-placeholder': "Select multiple"}, ),
field_name='city_of_death__country',
lookup_expr='in')
profession = django_filters.ModelMultipleChoiceFilter(
label="Profession",
queryset=Profession.objects.all(),
widget=Select2MultipleWidget(
attrs={'data-placeholder': "Select multiple"}, ),
field_name='personprofession__profession',
lookup_expr='in')
collection_roles = django_filters.ModelMultipleChoiceFilter(
label="Collection roles",
queryset=PersonCollectionRelationRole.objects.all(),
widget=Select2MultipleWidget(
attrs={'data-placeholder': "Select multiple"}, ),
field_name='personcollectionrelation__role',
lookup_expr='in')
item_roles = django_filters.ModelMultipleChoiceFilter(
label="Item roles",
queryset=PersonItemRelationRole.objects.all(),
widget=Select2MultipleWidget(
attrs={'data-placeholder': "Select multiple"}, ),
field_name='personitemrelation__role',
lookup_expr='in')
work_author = django_filters.BooleanFilter(label="Work author",
field_name='works',
lookup_expr='isnull',
exclude=True)
publisher = django_filters.BooleanFilter(label="Publisher",
field_name='publisher',
lookup_expr='isnull',
exclude=True)
religious_affiliation = django_filters.ModelMultipleChoiceFilter(
label="Religious affiliation",
queryset=Religion.objects.all(),
widget=Select2MultipleWidget(
attrs={'data-placeholder': "Select multiple"}, ),
field_name='religiousaffiliation__religion',
lookup_expr='in')
city_of_residence = django_filters.ModelMultipleChoiceFilter(
label=mark_safe(
_("Place of residence") +
place_help.format(city_of_residence_text)),
queryset=Place.objects.all(),
widget=Select2MultipleWidget(
attrs={'data-placeholder': "Select multiple"}, ),
field_name='residence__place',
lookup_expr='in')
country_of_residence = django_filters.ModelMultipleChoiceFilter(
label="Country of residence",
queryset=Country.objects.all(),
widget=Select2MultipleWidget(
attrs={'data-placeholder': "Select multiple"}, ),
field_name='residence__place__country',
lookup_expr='in')
related_to = django_filters.ModelMultipleChoiceFilter(
label="Related to",
queryset=Person.objects.all(),
widget=Select2MultipleWidget(
attrs={'data-placeholder': "Select multiple"}, ),
method='related_to_filter')
nature_of_relation = django_filters.ModelMultipleChoiceFilter(
label="Person relation types",
queryset=PersonPersonRelationType.objects.all(),
widget=Select2MultipleWidget(
attrs={'data-placeholder': "Select multiple"}, ),
method='nature_of_relation_filter')
class Meta:
model = Person
fields = [
'short_name', 'surname', 'sex', 'city_of_birth',
'country_of_birth', 'date_of_birth', 'city_of_death',
'country_of_death', 'date_of_death', 'profession',
'collection_roles', 'item_roles', 'work_author', 'publisher',
'religious_affiliation', 'city_of_residence',
'country_of_residence', 'related_to', 'nature_of_relation'
]
def short_name_filter(self, queryset, name, value):
from django.db.models import Q
if value:
short_name_q = Q(short_name__icontains=value)
alternative_short_name_q = Q(
alternative_names__short_name__icontains=value)
return queryset.filter(short_name_q | alternative_short_name_q)
return queryset
def surname_filter(self, queryset, name, value):
from django.db.models import Q
if value:
surname_q = Q(surname__icontains=value)
alternative_surname_q = Q(
alternative_names__surname__icontains=value)
return queryset.filter(surname_q | alternative_surname_q)
return queryset
def viaf_id_filter(self, queryset, name, value):
if value:
return queryset.filter(viaf_id=ViafAPI.uri_base + "/" + value)
return queryset
def related_to_filter(self, queryset, name, value):
if value:
first_person_query = Q(
relations_when_first__second_person__in=value)
second_person_query = Q(
relations_when_second__first_person__in=value)
return queryset.filter(first_person_query
| second_person_query).distinct()
return queryset
def nature_of_relation_filter(self, queryset, name, value):
if value:
first_person_query = Q(relations_when_first__type__in=value)
second_person_query = Q(relations_when_second__type__in=value)
return queryset.filter(first_person_query
| second_person_query).distinct()
return queryset
class PrefixFilter(TenancyFilterSet, CustomFieldFilterSet):
id__in = NumericInFilter(
field_name='id',
lookup_expr='in'
)
q = django_filters.CharFilter(
method='search',
label='Search',
)
prefix = django_filters.CharFilter(
method='filter_prefix',
label='Prefix',
)
within = django_filters.CharFilter(
method='search_within',
label='Within prefix',
)
within_include = django_filters.CharFilter(
method='search_within_include',
label='Within and including prefix',
)
contains = django_filters.CharFilter(
method='search_contains',
label='Prefixes which contain this prefix or IP',
)
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)',
)
site_id = django_filters.ModelMultipleChoiceFilter(
queryset=Site.objects.all(),
label='Site (ID)',
)
site = django_filters.ModelMultipleChoiceFilter(
field_name='site__slug',
queryset=Site.objects.all(),
to_field_name='slug',
label='Site (slug)',
)
vlan_id = django_filters.ModelMultipleChoiceFilter(
queryset=VLAN.objects.all(),
label='VLAN (ID)',
)
vlan_vid = django_filters.NumberFilter(
field_name='vlan__vid',
label='VLAN number (1-4095)',
)
role_id = django_filters.ModelMultipleChoiceFilter(
queryset=Role.objects.all(),
label='Role (ID)',
)
role = django_filters.ModelMultipleChoiceFilter(
field_name='role__slug',
queryset=Role.objects.all(),
to_field_name='slug',
label='Role (slug)',
)
status = django_filters.MultipleChoiceFilter(
choices=PREFIX_STATUS_CHOICES,
null_value=None
)
tag = TagFilter()
class Meta:
model = Prefix
fields = ['family', 'is_pool']
def search(self, queryset, name, value):
if not value.strip():
return queryset
qs_filter = Q(description__icontains=value)
try:
prefix = str(netaddr.IPNetwork(value.strip()).cidr)
qs_filter |= Q(prefix__net_contains_or_equals=prefix)
except (AddrFormatError, ValueError):
pass
return queryset.filter(qs_filter)
def filter_prefix(self, queryset, name, value):
if not value.strip():
return queryset
try:
query = str(netaddr.IPNetwork(value).cidr)
return queryset.filter(prefix=query)
except ValidationError:
return queryset.none()
def search_within(self, queryset, name, value):
value = value.strip()
if not value:
return queryset
try:
query = str(netaddr.IPNetwork(value).cidr)
return queryset.filter(prefix__net_contained=query)
except (AddrFormatError, ValueError):
return queryset.none()
def search_within_include(self, queryset, name, value):
value = value.strip()
if not value:
return queryset
try:
query = str(netaddr.IPNetwork(value).cidr)
return queryset.filter(prefix__net_contained_or_equal=query)
except (AddrFormatError, ValueError):
return queryset.none()
def search_contains(self, queryset, name, value):
value = value.strip()
if not value:
return queryset
try:
# Searching by prefix
if '/' in value:
return queryset.filter(prefix__net_contains_or_equals=str(netaddr.IPNetwork(value).cidr))
# Searching by IP address
else:
return queryset.filter(prefix__net_contains=str(netaddr.IPAddress(value)))
except (AddrFormatError, ValueError):
return queryset.none()
def filter_mask_length(self, queryset, name, value):
if not value:
return queryset
return queryset.filter(prefix__net_mask_length=value)
class RackFilter(TenancyFilterSet, CustomFieldFilterSet,
CreatedUpdatedFilterSet):
id__in = NumericInFilter(field_name='id', lookup_expr='in')
q = django_filters.CharFilter(
method='search',
label='Search',
)
region_id = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name='site__region__in',
label='Region (ID)',
)
region = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name='site__region__in',
to_field_name='slug',
label='Region (slug)',
)
site_id = django_filters.ModelMultipleChoiceFilter(
queryset=Site.objects.all(),
label='Site (ID)',
)
site = django_filters.ModelMultipleChoiceFilter(
field_name='site__slug',
queryset=Site.objects.all(),
to_field_name='slug',
label='Site (slug)',
)
group_id = django_filters.ModelMultipleChoiceFilter(
queryset=RackGroup.objects.all(),
label='Group (ID)',
)
group = django_filters.ModelMultipleChoiceFilter(
field_name='group__slug',
queryset=RackGroup.objects.all(),
to_field_name='slug',
label='Group',
)
status = django_filters.MultipleChoiceFilter(choices=RACK_STATUS_CHOICES,
null_value=None)
role_id = django_filters.ModelMultipleChoiceFilter(
queryset=RackRole.objects.all(),
label='Role (ID)',
)
role = django_filters.ModelMultipleChoiceFilter(
field_name='role__slug',
queryset=RackRole.objects.all(),
to_field_name='slug',
label='Role (slug)',
)
serial = django_filters.CharFilter(lookup_expr='iexact')
tag = TagFilter()
class Meta:
model = Rack
fields = [
'id',
'name',
'facility_id',
'asset_tag',
'type',
'width',
'u_height',
'desc_units',
'outer_width',
'outer_depth',
'outer_unit',
]
def search(self, queryset, name, value):
if not value.strip():
return queryset
return queryset.filter(
Q(name__icontains=value) | Q(facility_id__icontains=value)
| Q(serial__icontains=value.strip())
| Q(asset_tag__icontains=value.strip())
| Q(comments__icontains=value))
class MultipleChoiceFieldFilterSet(django_filters.FilterSet):
is_featured = django_filters.MultipleChoiceFilter(label='Is featured',
choices=[
(0, 'Featured'),
(1, 'Not featured')
])
class DeviceFilter(LocalConfigContextFilter, TenancyFilterSet,
CustomFieldFilterSet, CreatedUpdatedFilterSet):
id__in = NumericInFilter(field_name='id', lookup_expr='in')
q = django_filters.CharFilter(
method='search',
label='Search',
)
manufacturer_id = django_filters.ModelMultipleChoiceFilter(
field_name='device_type__manufacturer',
queryset=Manufacturer.objects.all(),
label='Manufacturer (ID)',
)
manufacturer = django_filters.ModelMultipleChoiceFilter(
field_name='device_type__manufacturer__slug',
queryset=Manufacturer.objects.all(),
to_field_name='slug',
label='Manufacturer (slug)',
)
device_type_id = django_filters.ModelMultipleChoiceFilter(
queryset=DeviceType.objects.all(),
label='Device type (ID)',
)
role_id = django_filters.ModelMultipleChoiceFilter(
field_name='device_role_id',
queryset=DeviceRole.objects.all(),
label='Role (ID)',
)
role = django_filters.ModelMultipleChoiceFilter(
field_name='device_role__slug',
queryset=DeviceRole.objects.all(),
to_field_name='slug',
label='Role (slug)',
)
platform_id = django_filters.ModelMultipleChoiceFilter(
queryset=Platform.objects.all(),
label='Platform (ID)',
)
platform = django_filters.ModelMultipleChoiceFilter(
field_name='platform__slug',
queryset=Platform.objects.all(),
to_field_name='slug',
label='Platform (slug)',
)
region_id = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name='site__region__in',
label='Region (ID)',
)
region = TreeNodeMultipleChoiceFilter(
queryset=Region.objects.all(),
field_name='site__region__in',
to_field_name='slug',
label='Region (slug)',
)
site_id = django_filters.ModelMultipleChoiceFilter(
queryset=Site.objects.all(),
label='Site (ID)',
)
site = django_filters.ModelMultipleChoiceFilter(
field_name='site__slug',
queryset=Site.objects.all(),
to_field_name='slug',
label='Site name (slug)',
)
rack_group_id = django_filters.ModelMultipleChoiceFilter(
field_name='rack__group',
queryset=RackGroup.objects.all(),
label='Rack group (ID)',
)
rack_id = django_filters.ModelMultipleChoiceFilter(
field_name='rack',
queryset=Rack.objects.all(),
label='Rack (ID)',
)
cluster_id = django_filters.ModelMultipleChoiceFilter(
queryset=Cluster.objects.all(),
label='VM cluster (ID)',
)
model = django_filters.ModelMultipleChoiceFilter(
field_name='device_type__slug',
queryset=DeviceType.objects.all(),
to_field_name='slug',
label='Device model (slug)',
)
status = django_filters.MultipleChoiceFilter(choices=DEVICE_STATUS_CHOICES,
null_value=None)
is_full_depth = django_filters.BooleanFilter(
field_name='device_type__is_full_depth',
label='Is full depth',
)
mac_address = MultiValueMACAddressFilter(
field_name='interfaces__mac_address',
label='MAC address',
)
serial = django_filters.CharFilter(lookup_expr='iexact')
has_primary_ip = django_filters.BooleanFilter(
method='_has_primary_ip',
label='Has a primary IP',
)
virtual_chassis_id = django_filters.ModelMultipleChoiceFilter(
field_name='virtual_chassis',
queryset=VirtualChassis.objects.all(),
label='Virtual chassis (ID)',
)
virtual_chassis_member = django_filters.BooleanFilter(
method='_virtual_chassis_member', label='Is a virtual chassis member')
console_ports = django_filters.BooleanFilter(
method='_console_ports',
label='Has console ports',
)
console_server_ports = django_filters.BooleanFilter(
method='_console_server_ports',
label='Has console server ports',
)
power_ports = django_filters.BooleanFilter(
method='_power_ports',
label='Has power ports',
)
power_outlets = django_filters.BooleanFilter(
method='_power_outlets',
label='Has power outlets',
)
interfaces = django_filters.BooleanFilter(
method='_interfaces',
label='Has interfaces',
)
pass_through_ports = django_filters.BooleanFilter(
method='_pass_through_ports',
label='Has pass-through ports',
)
tag = TagFilter()
class Meta:
model = Device
fields = [
'id', 'name', 'asset_tag', 'face', 'position', 'vc_position',
'vc_priority'
]
def search(self, queryset, name, value):
if not value.strip():
return queryset
return queryset.filter(
Q(name__icontains=value) | Q(serial__icontains=value.strip())
| Q(inventory_items__serial__icontains=value.strip())
| Q(asset_tag__icontains=value.strip())
| Q(comments__icontains=value)).distinct()
def _has_primary_ip(self, queryset, name, value):
if value:
return queryset.filter(
Q(primary_ip4__isnull=False) | Q(primary_ip6__isnull=False))
else:
return queryset.exclude(
Q(primary_ip4__isnull=False) | Q(primary_ip6__isnull=False))
def _virtual_chassis_member(self, queryset, name, value):
return queryset.exclude(virtual_chassis__isnull=value)
def _console_ports(self, queryset, name, value):
return queryset.exclude(consoleports__isnull=value)
def _console_server_ports(self, queryset, name, value):
return queryset.exclude(consoleserverports__isnull=value)
def _power_ports(self, queryset, name, value):
return queryset.exclude(powerports__isnull=value)
def _power_outlets(self, queryset, name, value):
return queryset.exclude(poweroutlets__isnull=value)
def _interfaces(self, queryset, name, value):
return queryset.exclude(interfaces__isnull=value)
def _pass_through_ports(self, queryset, name, value):
return queryset.exclude(frontports__isnull=value,
rearports__isnull=value)
class ExperimentFilterset(filters.FilterSet):
search = filters.CharFilter(
method="filter_search",
widget=SearchWidget(attrs={
"class": "form-control",
"placeholder": "Search Deliveries"
}),
)
type = filters.MultipleChoiceFilter(
choices=Experiment.TYPE_CHOICES,
conjoined=False,
widget=forms.SelectMultiple(attrs={
"class": "form-control",
"data-none-selected-text": "All Types"
}),
)
projects = filters.ModelMultipleChoiceFilter(
queryset=Project.objects.all(),
null_label="No Projects",
widget=forms.SelectMultiple(attrs={
"class": "form-control",
"data-none-selected-text": "All Projects"
}),
)
status = filters.ChoiceFilter(
empty_label="All Statuses",
choices=Experiment.STATUS_CHOICES,
widget=forms.Select(attrs={"class": "form-control"}),
)
firefox_channel = filters.ChoiceFilter(
empty_label="All Channels",
choices=Experiment.CHANNEL_CHOICES[1:],
widget=forms.Select(attrs={"class": "form-control"}),
)
firefox_version = filters.ChoiceFilter(
empty_label="All Versions",
choices=Experiment.VERSION_CHOICES[1:],
widget=forms.Select(attrs={"class": "form-control"}),
method="version_filter",
)
owner = filters.ModelChoiceFilter(
empty_label="All Owners",
queryset=get_user_model().objects.all().order_by("email"),
widget=forms.Select(attrs={"class": "form-control"}),
)
analysis_owner = filters.ModelChoiceFilter(
empty_label="All Data Scientists",
queryset=get_user_model().objects.all().order_by("email"),
widget=forms.Select(attrs={"class": "form-control"}),
)
archived = filters.BooleanFilter(
label="Show archived deliveries",
widget=forms.CheckboxInput(),
method="archived_filter",
)
experiment_date_field = filters.ChoiceFilter(
empty_label="No Date Restriction",
choices=[
(Experiment.EXPERIMENT_STARTS, "Delivery Starts"),
(Experiment.EXPERIMENT_PAUSES, "Delivery Pauses"),
(Experiment.EXPERIMENT_ENDS, "Delivery Ends"),
],
widget=forms.Select(attrs={"class": "form-control"}),
method="experiment_date_field_filter",
)
date_range = filters.DateFromToRangeFilter(
method="date_range_filter",
widget=DateRangeWidget(attrs={
"type": "date",
"class": "form-control"
}),
)
in_qa = filters.BooleanFilter(
label="Show only deliveries in QA",
widget=forms.CheckboxInput(),
method="in_qa_filter",
)
surveys = filters.BooleanFilter(
label="Show deliveries with surveys",
widget=forms.CheckboxInput(),
method="surveys_filter",
)
subscribed = filters.BooleanFilter(
label="Show subscribed deliveries",
widget=forms.CheckboxInput(),
method="subscribed_filter",
)
longrunning = filters.BooleanFilter(
label="Show long-running deliveries",
widget=forms.CheckboxInput(),
method="longrunning_filter",
)
is_paused = filters.BooleanFilter(
label="Show enrollment complete deliveries",
widget=forms.CheckboxInput(),
method="is_paused_filter",
)
completed_results = filters.BooleanFilter(
label="Show deliveries with results completed",
widget=forms.CheckboxInput(),
method="completed_results_filter",
)
class Meta:
model = Experiment
fields = (
"search",
"type",
"projects",
"status",
"firefox_channel",
"firefox_version",
"owner",
"analysis_owner",
"in_qa",
"surveys",
"archived",
"subscribed",
"longrunning",
"is_paused",
"completed_results",
)
def filter_search(self, queryset, name, value):
vector = SearchVector(
"name",
"short_description",
"owner__email",
"analysis_owner__email",
"slug",
"related_work",
"addon_experiment_id",
"pref_name",
"public_description",
"objectives",
"analysis",
"engineering_owner",
"bugzilla_id",
"recipe_slug",
"data_science_issue_url",
"feature_bugzilla_url",
)
query = SearchQuery(value)
return (queryset.annotate(
rank=SearchRank(vector, query),
search=vector).filter(search=value).order_by("-rank"))
def archived_filter(self, queryset, name, value):
if not value:
return queryset.exclude(archived=True)
return queryset
def experiment_date_field_filter(self, queryset, name, value):
# this custom method isn't doing anything. There has to
# be a custom method to be able to display the select
# filter that controls which date range we show
return queryset
def version_filter(self, queryset, name, value):
return queryset.filter(
Q(firefox_min_version__lte=value, firefox_max_version__gte=value)
| Q(firefox_min_version=value))
def date_range_filter(self, queryset, name, value):
date_type = self.form.cleaned_data["experiment_date_field"]
if date_type:
experiment_date_field = {
Experiment.EXPERIMENT_STARTS: "start_date",
Experiment.EXPERIMENT_PAUSES: "enrollment_end_date",
Experiment.EXPERIMENT_ENDS: "end_date",
}[date_type]
results = []
for experiment in queryset.all():
date = getattr(experiment, experiment_date_field)
# enrollment end dates are optional, so there won't always
# be a pause date for an experiment
if date:
if value.start and date < value.start.date():
continue
if value.stop and date > value.stop.date():
continue
results.append(experiment.id)
return queryset.filter(pk__in=results)
return queryset
def in_qa_filter(self, queryset, name, value):
if value:
return queryset.filter(review_qa_requested=True, review_qa=False)
return queryset
def surveys_filter(self, queryset, name, value):
if value:
return queryset.filter(survey_required=True)
return queryset
def subscribed_filter(self, queryset, name, value):
if value:
return queryset.filter(subscribers__in=[self.request.user.id])
return queryset
def longrunning_filter(self, queryset, name, value):
if value:
return (queryset.exclude(firefox_max_version__exact="").annotate(
firefox_min_int=Cast(
Func(
F("firefox_min_version"),
Value(ExperimentConstants.VERSION_REGEX.pattern),
function="substring",
),
IntegerField(),
),
firefox_max_int=Cast(
Func(
F("firefox_max_version"),
Value(ExperimentConstants.VERSION_REGEX.pattern),
function="substring",
),
IntegerField(),
),
version_count=F("firefox_max_int") - F("firefox_min_int"),
).filter(version_count__gte=3))
return queryset
def is_paused_filter(self, queryset, name, value):
if value:
return queryset.filter(is_paused=True,
status=Experiment.STATUS_LIVE)
return queryset
def completed_results_filter(self, queryset, name, value):
if value:
return queryset.exclude(
Q(results_url="") | Q(results_url=None),
Q(results_initial="") | Q(results_initial=None),
Q(results_lessons_learned="")
| Q(results_lessons_learned=None),
)
return queryset
def get_type_display_value(self):
return ", ".join([
dict(Experiment.TYPE_CHOICES)[type].replace(" Experiment", "")
for type in self.data.getlist("type")
])
def get_project_display_value(self):
project_ids = self.data.getlist("projects")
if project_ids:
if "null" in project_ids:
project_ids.remove("null")
project_name_list = Project.objects.filter(
id__in=project_ids).values_list("name")
if project_name_list:
return ", ".join(project_name[0]
for project_name in project_name_list)
return "No Projects"
def get_owner_display_value(self):
user_id = self.data.get("owner")
if user_id is not None:
return str(get_user_model().objects.get(id=user_id))
def get_display_start_date_info(self):
experiment_date_field = self.data.get("experiment_date_field")
date_after = self.data.get("date_range_after")
date_before = self.data.get("date_range_before")
if date_after and date_before:
return f"{experiment_date_field} between {date_after} and {date_before}"
elif date_after and date_before == "":
return f"{experiment_date_field} after {date_after}"
elif date_after == "" and date_before:
return f"{experiment_date_field} before {date_before}"
else:
return ""
class DeviceFilter(CustomFieldFilterSet):
id__in = NumericInFilter(field_name='id', lookup_expr='in')
q = django_filters.CharFilter(
method='search',
label='Search',
)
manufacturer_id = django_filters.ModelMultipleChoiceFilter(
field_name='device_type__manufacturer',
queryset=Manufacturer.objects.all(),
label='Manufacturer (ID)',
)
manufacturer = django_filters.ModelMultipleChoiceFilter(
field_name='device_type__manufacturer__slug',
queryset=Manufacturer.objects.all(),
to_field_name='slug',
label='Manufacturer (slug)',
)
device_type_id = django_filters.ModelMultipleChoiceFilter(
queryset=DeviceType.objects.all(),
label='Device type (ID)',
)
role_id = django_filters.ModelMultipleChoiceFilter(
field_name='device_role_id',
queryset=DeviceRole.objects.all(),
label='Role (ID)',
)
role = django_filters.ModelMultipleChoiceFilter(
field_name='device_role__slug',
queryset=DeviceRole.objects.all(),
to_field_name='slug',
label='Role (slug)',
)
tenant_id = django_filters.ModelMultipleChoiceFilter(
queryset=Tenant.objects.all(),
label='Tenant (ID)',
)
tenant = django_filters.ModelMultipleChoiceFilter(
field_name='tenant__slug',
queryset=Tenant.objects.all(),
to_field_name='slug',
label='Tenant (slug)',
)
platform_id = django_filters.ModelMultipleChoiceFilter(
queryset=Platform.objects.all(),
label='Platform (ID)',
)
platform = django_filters.ModelMultipleChoiceFilter(
field_name='platform__slug',
queryset=Platform.objects.all(),
to_field_name='slug',
label='Platform (slug)',
)
name = NullableCharFieldFilter()
asset_tag = NullableCharFieldFilter()
region_id = django_filters.NumberFilter(
method='filter_region',
field_name='pk',
label='Region (ID)',
)
region = django_filters.CharFilter(
method='filter_region',
field_name='slug',
label='Region (slug)',
)
site_id = django_filters.ModelMultipleChoiceFilter(
queryset=Site.objects.all(),
label='Site (ID)',
)
site = django_filters.ModelMultipleChoiceFilter(
field_name='site__slug',
queryset=Site.objects.all(),
to_field_name='slug',
label='Site name (slug)',
)
rack_group_id = django_filters.ModelMultipleChoiceFilter(
field_name='rack__group',
queryset=RackGroup.objects.all(),
label='Rack group (ID)',
)
rack_id = django_filters.ModelMultipleChoiceFilter(
field_name='rack',
queryset=Rack.objects.all(),
label='Rack (ID)',
)
cluster_id = django_filters.ModelMultipleChoiceFilter(
queryset=Cluster.objects.all(),
label='VM cluster (ID)',
)
model = django_filters.ModelMultipleChoiceFilter(
field_name='device_type__slug',
queryset=DeviceType.objects.all(),
to_field_name='slug',
label='Device model (slug)',
)
status = django_filters.MultipleChoiceFilter(choices=DEVICE_STATUS_CHOICES,
null_value=None)
is_full_depth = django_filters.BooleanFilter(
field_name='device_type__is_full_depth',
label='Is full depth',
)
mac_address = django_filters.CharFilter(
method='_mac_address',
label='MAC address',
)
has_primary_ip = django_filters.BooleanFilter(
method='_has_primary_ip',
label='Has a primary IP',
)
virtual_chassis_id = django_filters.ModelMultipleChoiceFilter(
field_name='virtual_chassis',
queryset=VirtualChassis.objects.all(),
label='Virtual chassis (ID)',
)
console_ports = django_filters.BooleanFilter(
method='_console_ports',
label='Has console ports',
)
console_server_ports = django_filters.BooleanFilter(
method='_console_server_ports',
label='Has console server ports',
)
power_ports = django_filters.BooleanFilter(
method='_power_ports',
label='Has power ports',
)
power_outlets = django_filters.BooleanFilter(
method='_power_outlets',
label='Has power outlets',
)
interfaces = django_filters.BooleanFilter(
method='_interfaces',
label='Has interfaces',
)
pass_through_ports = django_filters.BooleanFilter(
method='_pass_through_ports',
label='Has pass-through ports',
)
tag = TagFilter()
class Meta:
model = Device
fields = ['serial', 'position']
def search(self, queryset, name, value):
if not value.strip():
return queryset
return queryset.filter(
Q(name__icontains=value) | Q(serial__icontains=value.strip())
| Q(inventory_items__serial__icontains=value.strip())
| Q(asset_tag__icontains=value.strip())
| Q(comments__icontains=value)).distinct()
def filter_region(self, queryset, name, value):
try:
region = Region.objects.get(**{name: value})
except ObjectDoesNotExist:
return queryset.none()
return queryset.filter(
Q(site__region=region)
| Q(site__region__in=region.get_descendants()))
def _mac_address(self, queryset, name, value):
value = value.strip()
if not value:
return queryset
try:
mac = EUI(value.strip())
return queryset.filter(interfaces__mac_address=mac).distinct()
except AddrFormatError:
return queryset.none()
def _has_primary_ip(self, queryset, name, value):
if value:
return queryset.filter(
Q(primary_ip4__isnull=False) | Q(primary_ip6__isnull=False))
else:
return queryset.exclude(
Q(primary_ip4__isnull=False) | Q(primary_ip6__isnull=False))
def _console_ports(self, queryset, name, value):
return queryset.exclude(consoleports__isnull=value)
def _console_server_ports(self, queryset, name, value):
return queryset.exclude(consoleserverports__isnull=value)
def _power_ports(self, queryset, name, value):
return queryset.exclude(powerports__isnull=value)
def _power_outlets(self, queryset, name, value):
return queryset.exclude(poweroutlets_isnull=value)
def _interfaces(self, queryset, name, value):
return queryset.exclude(interfaces__isnull=value)
def _pass_through_ports(self, queryset, name, value):
return queryset.exclude(frontports__isnull=value,
rearports__isnull=value)