class TextVersionListFilter(django_filters.FilterSet):
legacy_id = django_filters.LookupChoiceFilter(
field_class=forms.CharField,
lookup_choices=LOOKUP_CHOICES,
help_text=TextVersion._meta.get_field('legacy_id').help_text,
label=TextVersion._meta.get_field('legacy_id').verbose_name)
text_id__participant_id = django_filters.ModelMultipleChoiceFilter(
queryset=Participant.objects.all(),
help_text=Text._meta.get_field('participant_id').help_text,
label=Text._meta.get_field('participant_id').verbose_name)
text_id__participant_id__learner_id__gender = django_filters.ChoiceFilter(
choices=GENDER_CHOICES, help_text="Gender", label="Gender")
text_id__participant_id__institution_level = django_filters.ChoiceFilter(
choices=[(x[0], x[0]) for x in list(
set(Participant.objects.all().values_list('institution_level')))],
help_text="Institution Level",
label="Institution Level")
text_id__participant_id__clil = django_filters.ChoiceFilter(
choices=YES_NO_OTHER, help_text="clil", label="clil")
text_id__participant_id__learner_id__nationality = django_filters.ModelMultipleChoiceFilter(
queryset=Place.objects.all(),
help_text="Nationality",
label="Nationality")
text_id__participant_id__learner_id__lang_l = django_filters.ModelMultipleChoiceFilter(
queryset=SkosConcept.objects.exclude(is_lang_l_of=None),
help_text="mother tongue",
label="mother tongue")
text_id__participant_id__learner_id__lang_mother = django_filters.ModelMultipleChoiceFilter(
queryset=SkosConcept.objects.exclude(is_mother_lang_of=None),
help_text="lang mother",
label="lang mother")
text_id__participant_id__learner_id__lang_father = django_filters.ModelMultipleChoiceFilter(
queryset=SkosConcept.objects.exclude(is_father_lang_of=None),
help_text="lang father",
label="lang father")
text_id__participant_id__learner_id__lang_second = django_filters.ModelMultipleChoiceFilter(
queryset=SkosConcept.objects.exclude(is_second_lang_of=None),
help_text="second language",
label="second language ≠ foreign language")
text_id__participant_id__learner_id__lang_third = django_filters.ModelMultipleChoiceFilter(
queryset=SkosConcept.objects.exclude(is_third_lang_of=None),
help_text="third language",
label="third language ≠ foreign language")
text_id__participant_id__learner_profile_id__lang_spoken_home = django_filters.ChoiceFilter(
choices=[(x[0], x[0]) for x in list(
set(LearnerProfile.objects.all().values_list('lang_spoken_home')))
],
help_text=
"(if more than one language is spoken, provide the % of use of each language)\
format: Bosnian: 50% Slovenian: 50%",
label="description of language use at home")
text_id__participant_id__learner_profile_id__lang_instruction_primary = django_filters.ModelMultipleChoiceFilter(
queryset=SkosConcept.objects.exclude(is_lang_instruction_primary=None),
help_text="Language of instruction in primary school",
label="Language of instruction in primary school")
text_id__participant_id__learner_profile_id__proficiency_level = django_filters.ChoiceFilter(
choices=[(x[0], x[0]) for x in list(
set(LearnerProfile.objects.all().values_list('proficiency_level')))
],
help_text="A1;A2;B1;B2;C1;C2",
label="Latest CEF score/placement")
text_id__grade = django_filters.RangeFilter()
text_id__medium = django_filters.ModelMultipleChoiceFilter(
queryset=SkosConcept.objects.filter(
scheme__dc_title__icontains="text_medium"),
help_text=Text._meta.get_field('medium').help_text,
label=Text._meta.get_field('medium').verbose_name,
widget=forms.CheckboxSelectMultiple(
attrs={'class': 'chbx-select-multi'}))
text_id__mode = django_filters.ModelMultipleChoiceFilter(
queryset=SkosConcept.objects.filter(
scheme__dc_title__icontains="text_mode"),
help_text=Text._meta.get_field('mode').help_text,
label=Text._meta.get_field('mode').verbose_name,
widget=forms.CheckboxSelectMultiple(
attrs={'class': 'chbx-select-multi'}))
text_id__text_type = django_filters.ModelMultipleChoiceFilter(
queryset=SkosConcept.objects.filter(
scheme__dc_title__icontains="text_type"),
help_text=Text._meta.get_field('text_type').help_text,
label=Text._meta.get_field('text_type').verbose_name,
widget=forms.CheckboxSelectMultiple(
attrs={'class': 'chbx-select-multi'}))
text_id__clil_text = django_filters.ChoiceFilter(
choices=[
(x[0], x[0])
for x in list(set(Text.objects.all().values_list('clil_text')))
],
help_text=
"(if more than one language is spoken, provide the % of use of each language)\
format: Bosnian: 50% Slovenian: 50%",
label="description of language use at home")
text_id__assignment_id = django_filters.ModelMultipleChoiceFilter(
queryset=Assignment.objects,
help_text=Assignment._meta.get_field('title').help_text,
label='Select Assignment Title',
widget=forms.CheckboxSelectMultiple(
attrs={'class': 'chbx-select-multi'}))
text_id__assignment_id__title = django_filters.LookupChoiceFilter(
field_class=forms.CharField,
lookup_choices=LOOKUP_CHOICES,
help_text=Assignment._meta.get_field('title').help_text,
label=Assignment._meta.get_field('title').verbose_name)
class Meta:
model = TextVersion
fields = "__all__"
class RackFilterSet(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=RackStatusChoices,
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 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 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().filter(
id__in=Experiment.objects.all().values_list(
"analysis_owner__id", flat=True)).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 DeviceTypeComponentFilterSet(django_filters.FilterSet):
devicetype_id = django_filters.ModelMultipleChoiceFilter(
queryset=DeviceType.objects.all(),
label='Device type (ID)',
)
class ModelMultipleChoiceFieldFilterSet(django_filters.FilterSet):
categories = django_filters.ModelMultipleChoiceFilter(
label='Category', queryset=Category.objects.all())
class PrefixFilter(CustomFieldFilterSet, django_filters.FilterSet):
q = django_filters.MethodFilter(
action='search',
label='Search',
)
parent = django_filters.MethodFilter(
action='search_by_parent',
label='Parent prefix',
)
vrf_id = NullableModelMultipleChoiceFilter(
name='vrf_id',
queryset=VRF.objects.all(),
label='VRF',
)
vrf = NullableModelMultipleChoiceFilter(
name='vrf',
queryset=VRF.objects.all(),
to_field_name='rd',
label='VRF (RD)',
)
tenant_id = NullableModelMultipleChoiceFilter(
name='tenant',
queryset=Tenant.objects.all(),
label='Tenant (ID)',
)
tenant = NullableModelMultipleChoiceFilter(
name='tenant',
queryset=Tenant.objects.all(),
to_field_name='slug',
label='Tenant (slug)',
)
site_id = NullableModelMultipleChoiceFilter(
name='site',
queryset=Site.objects.all(),
label='Site (ID)',
)
site = NullableModelMultipleChoiceFilter(
name='site',
queryset=Site.objects.all(),
to_field_name='slug',
label='Site (slug)',
)
vlan_id = django_filters.ModelMultipleChoiceFilter(
name='vlan',
queryset=VLAN.objects.all(),
label='VLAN (ID)',
)
vlan_vid = django_filters.NumberFilter(
name='vlan__vid',
label='VLAN number (1-4095)',
)
role_id = NullableModelMultipleChoiceFilter(
name='role',
queryset=Role.objects.all(),
label='Role (ID)',
)
role = NullableModelMultipleChoiceFilter(
name='role',
queryset=Role.objects.all(),
to_field_name='slug',
label='Role (slug)',
)
class Meta:
model = Prefix
fields = [
'family', 'site_id', 'site', 'vlan_id', 'vlan_vid', 'status',
'role_id', 'role'
]
def search(self, queryset, value):
qs_filter = Q(description__icontains=value)
try:
prefix = str(IPNetwork(value.strip()).cidr)
qs_filter |= Q(prefix__net_contains_or_equals=prefix)
except AddrFormatError:
pass
return queryset.filter(qs_filter)
def search_by_parent(self, queryset, value):
value = value.strip()
if not value:
return queryset
try:
query = str(IPNetwork(value).cidr)
return queryset.filter(prefix__net_contained_or_equal=query)
except AddrFormatError:
return queryset.none()
def _tenant(self, queryset, value):
if str(value) == '':
return queryset
return queryset.filter(
Q(tenant__slug=value)
| Q(tenant__isnull=True, vrf__tenant__slug=value))
def _tenant_id(self, queryset, value):
try:
value = int(value)
except ValueError:
return queryset.none()
return queryset.filter(
Q(tenant__pk=value)
| Q(tenant__isnull=True, vrf__tenant__pk=value))
class VLANFilter(CustomFieldFilterSet, django_filters.FilterSet):
q = django_filters.MethodFilter(
action='search',
label='Search',
)
site_id = django_filters.ModelMultipleChoiceFilter(
name='site',
queryset=Site.objects.all(),
label='Site (ID)',
)
site = django_filters.ModelMultipleChoiceFilter(
name='site',
queryset=Site.objects.all(),
to_field_name='slug',
label='Site (slug)',
)
group_id = NullableModelMultipleChoiceFilter(
name='group',
queryset=VLANGroup.objects.all(),
label='Group (ID)',
)
group = NullableModelMultipleChoiceFilter(
name='group',
queryset=VLANGroup.objects.all(),
to_field_name='slug',
label='Group',
)
name = django_filters.CharFilter(
name='name',
lookup_type='icontains',
label='Name',
)
vid = django_filters.NumberFilter(
name='vid',
label='VLAN number (1-4095)',
)
tenant_id = NullableModelMultipleChoiceFilter(
name='tenant',
queryset=Tenant.objects.all(),
label='Tenant (ID)',
)
tenant = NullableModelMultipleChoiceFilter(
name='tenant',
queryset=Tenant.objects.all(),
to_field_name='slug',
label='Tenant (slug)',
)
role_id = NullableModelMultipleChoiceFilter(
name='role',
queryset=Role.objects.all(),
label='Role (ID)',
)
role = NullableModelMultipleChoiceFilter(
name='role',
queryset=Role.objects.all(),
to_field_name='slug',
label='Role (slug)',
)
class Meta:
model = VLAN
fields = [
'site_id', 'site', 'vid', 'name', 'status', 'role_id', 'role'
]
def search(self, queryset, value):
qs_filter = Q(name__icontains=value) | Q(description__icontains=value)
try:
qs_filter |= Q(vid=int(value))
except ValueError:
pass
return queryset.filter(qs_filter)
class IPAddressFilter(CustomFieldFilterSet, django_filters.FilterSet):
q = django_filters.MethodFilter(
action='search',
label='Search',
)
parent = django_filters.MethodFilter(
action='search_by_parent',
label='Parent prefix',
)
vrf_id = NullableModelMultipleChoiceFilter(
name='vrf_id',
queryset=VRF.objects.all(),
label='VRF',
)
vrf = NullableModelMultipleChoiceFilter(
name='vrf',
queryset=VRF.objects.all(),
to_field_name='rd',
label='VRF (RD)',
)
tenant_id = NullableModelMultipleChoiceFilter(
name='tenant',
queryset=Tenant.objects.all(),
label='Tenant (ID)',
)
tenant = NullableModelMultipleChoiceFilter(
name='tenant',
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',
queryset=Device.objects.all(),
to_field_name='name',
label='Device (name)',
)
interface_id = django_filters.ModelMultipleChoiceFilter(
name='interface',
queryset=Interface.objects.all(),
label='Interface (ID)',
)
class Meta:
model = IPAddress
fields = [
'q', 'family', 'status', 'device_id', 'device', 'interface_id'
]
def search(self, queryset, value):
qs_filter = Q(description__icontains=value)
try:
ipaddress = str(IPNetwork(value.strip()))
qs_filter |= Q(address__net_host=ipaddress)
except AddrFormatError:
pass
return queryset.filter(qs_filter)
def search_by_parent(self, queryset, value):
value = value.strip()
if not value:
return queryset
try:
query = str(IPNetwork(value).cidr)
return queryset.filter(address__net_contained_or_equal=query)
except AddrFormatError:
return queryset.none()
