class EntityFilter(filters.FilterSet):
entity_name = filters.BaseInFilter(field_name='entity_name', lookup_expr='in')
confidence_level = NumberChoices(method='filter_confidence_level', choices=CONFIDENCE_CHOICES,
help_text="Filter by confidence level: 0, 1, 2, 3") # FIXME should be custom
version = filters.CharFilter(method='version_lookup', help_text="Panel version")
tags = filters.BaseInFilter(field_name='tags__name', lookup_expr='in')
class Meta:
fields = ['entity_name', 'confidence_level', 'tags']
def filter_confidence_level(self, queryset, name, value):
field = 'saved_gel_status'
try:
value = int(value)
if value >= 3:
value = 3
field = field + '__gte'
except ValueError:
raise APIException(detail='Incorrect confidence level', code='incorrect_confidence_level')
return queryset.filter(**{field: value})
def version_lookup(self, queryset, name, value):
try:
major, minor = value.split('.')
except ValueError:
raise APIException(detail='Incorrect version supplied', code='incorrect_version')
return queryset.filter(panel__major_version=major, panel__minor_version=minor)
class EntitySearchFilter(filters.FilterSet):
type = filters.BaseInFilter(field_name='panel__panel__types__slug', lookup_expr='in')
tags = filters.BaseInFilter(field_name='tags__name', lookup_expr='in')
entity_name = filters.BaseInFilter(field_name='entity_name', lookup_expr='in')
class Meta:
fields = ['type', 'tags', 'entity_name']
class JoinRecordFilter(django_filters.FilterSet):
record_id = django_filters.BaseInFilter()
record_uuid = django_filters.BaseInFilter()
related_record_id = django_filters.BaseInFilter()
related_record_uuid = django_filters.BaseInFilter()
class Meta:
model = JoinRecord
fields = ('record_id', 'record_uuid', 'related_record_id',
'related_record_uuid')
class SiteProfileFilter(django_filters.FilterSet):
workflowlevel2_uuid = BaseInArrayFilter()
uuid = django_filters.BaseInFilter()
class Meta:
model = SiteProfile
fields = ('profiletype__id', 'uuid', 'workflowlevel2_uuid', )
class MembersFilter(filters.FilterSet):
"""
Filterset to filter members by skills, holiday and working hours
"""
skills = filters.BaseInFilter(field_name='skills__name')
holidays = filters.BooleanFilter(method='filter_is_on_holidays')
is_working = filters.BooleanFilter(method='filter_is_working')
class Meta:
model = Member
fields = (
'skills',
'project',
'holidays',
'is_working',
)
def filter_is_on_holidays(self, queryset, name, value):
if value:
return queryset.filter(Q(on_holidays_till__isnull=False) | Q(on_holidays_till__gt=datetime.now()))
return queryset.filter(Q(on_holidays_till__isnull=True) | Q(on_holidays_till__lt=datetime.now()))
def filter_is_working(self, queryset, name, value):
if value:
return queryset.filter(Q(workhours__start__lt=datetime.now()) & Q(workhours__end__gt=datetime.now()))
return queryset.filter(Q(workhours__start__gt=datetime.now()) | Q(workhours__end__lt=datetime.now()))
class NoteFilter(filters.FilterSet):
favorites = filters.BooleanFilter(name='is_favorite')
title = filters.BaseInFilter(name='title')
class Meta:
model = Note
fields = [
'id', 'title', 'content', 'is_favorite', 'created_at', 'updated_at'
]
class SecondaryDonorFilter(filters.FilterSet):
grants__in = filters.BaseInFilter(field_name="grants")
class Meta:
model = SecondaryDonor
fields = {
'name': ['exact', 'in'],
'code': ['exact', 'in'],
}
class PersonFilterSet(FilterSet):
class Meta:
model = Person
fields = {}
names = filters.BaseInFilter(method="filter_names")
def filter_names(self, qs, name, value):
return qs.filter(name__in=value)
class ProductFilter(rest_framework.FilterSet):
date_range = DateFromToRangeFilter(
widget=StartEndRangeWidget(attrs={'placeholder': 'DD-MM-YYYY'}),
method='filter_date_range')
ids = rest_framework.BaseInFilter(field_name='id')
status_in = rest_framework.BaseInFilter(field_name='status')
class Meta:
model = Product
fields = {
'status': ['exact'],
'ids': ['exact'],
'status_in': ['exact'],
}
def filter_date_range(self, queryset, name, value):
service = AvailableProductsService(value.start, value.stop)
return service.check_availability(queryset)
class AmbulanceFilterSet(filters.FilterSet):
vehicle_numbers = filters.BaseInFilter(field_name="vehicle_number")
primary_district = filters.CharFilter(field_name="primary_district_id")
secondary_district = filters.CharFilter(field_name="secondary_district_id")
third_district = filters.CharFilter(field_name="third_district_id")
primary_district_name = filters.CharFilter(field_name="primary_district__name", lookup_expr="icontains")
secondary_district_name = filters.CharFilter(field_name="secondary_district__name", lookup_expr="icontains")
third_district_name = filters.CharFilter(field_name="third_district__name", lookup_expr="icontains")
class ProductFilter(drf_filters.FilterSet):
price = drf_filters.RangeFilter()
rating = drf_filters.RangeFilter()
title = CharFilterDef(field_name = 'title', lookup_expr='in')
in_title = drf_filters.CharFilter(field_name = 'title', lookup_expr='contains')
in_desc = drf_filters.CharFilter(field_name = 'desc', lookup_expr='contains')
category = drf_filters.BaseInFilter(field_name = 'cid__pk', lookup_expr='in')
class Meta:
model = Product
fields = ['price', 'rating', 'title', 'in_title', 'in_desc', 'category',]
class ProductFilter(filters.FilterSet):
workflowlevel2_uuid = filters.BaseInFilter()
class Meta:
model = Product
fields = (
'type',
'name',
'workflowlevel2_uuid',
'part_number',
)
class PetFilter(filters.FilterSet):
pet_ids = filters.BaseInFilter(field_name="id", required=True)
last_update = filters.IsoDateTimeFilter(field_name="updated_at",
method='filter_last_update',
required=False)
def filter_last_update(self, queryset, name, value):
return queryset.filter(
Q(updated_at__gt=value) | Q(shelter__updated_at__gt=value))
class Meta:
model = Pet
fields = ['pet_ids', 'last_update']
class PersonFilterSet(FilterSet):
class Meta:
model = Person
fields = {"name": ["in"]}
names = filters.BaseInFilter(method="filter_names")
def filter_names(self, qs, name, value):
"""
This custom filter take a string as input with comma separated values.
Note that the value here is already a list as it has been transformed by the BaseInFilter class.
"""
return qs.filter(name__in=value)
class ProductFilter(filters.FilterSet):
section = filters.NumberFilter(method='filter_by_section')
exclude = filters.BaseInFilter(method='filter_by_excluded')
include_all = filters.BaseInFilter(method='filter_by_all_included')
include_any = filters.BaseInFilter(method='filter_by_any_included')
class Meta:
model = Product
fields = ['section', 'exclude', 'include_all', 'include_any']
def filter_by_section(self, queryset, name, value):
sections_ids = Section.objects.get(pk=value).get_most_nested()
return queryset.filter(section__in=sections_ids)
def filter_by_excluded(self, queryset, name, value):
return queryset.exclude_all(value)
def filter_by_all_included(self, queryset, name, value):
return queryset.include_all(value)
def filter_by_any_included(self, queryset, name, value):
return queryset.include_any(value)
class GrantFilter(filters.FilterSet):
business_areas__in = filters.BaseInFilter(field_name="business_areas")
class Meta:
model = Grant
fields = {
'donor': ['exact'],
'code': ['exact', 'in'],
'year': ['exact', 'in'],
'theme': ['exact', 'in'],
'business_areas': ['exact', 'in'],
'expiry_date': ['lte', 'gte', 'gt', 'lt'],
'financial_close_date': ['lte', 'gte', 'gt', 'lt'],
}
class VariantFilter(df_filters.FilterSet):
gene = df_filters.ModelChoiceFilter(queryset=Gene.objects.all())
gene_symbol = df_filters.CharFilter(field_name='gene__symbol',
label='Gene Symbol')
name = df_filters.CharFilter(field_name='name')
description = df_filters.CharFilter(field_name='description')
so_name = df_filters.AllValuesFilter(field_name='so_name',
label='Sequence Ontology Name')
sources = df_filters.BaseInFilter(field_name='sources',
lookup_expr='contains')
in_svip = df_filters.BooleanFilter(label='Is SVIP Variant?',
method='filter_has_svipdata')
# noinspection PyMethodMayBeStatic
def filter_has_svipdata(self, queryset, name, value):
if value:
# we require the .distinct() here because we occasionally have multiple VariantInSVIP entries
# keyed to the same variant (although that's clearly not great), and this implicit join
# causes those variants to be repeated as many times as there are referring VinSVIP entries
return queryset.filter(variantinsvip__isnull=False).distinct()
# otherwise, return all the variants, svip data or not
return queryset
class PanelsFilter(filters.FilterSet):
type = filters.BaseInFilter(field_name='panel__types__slug', lookup_expr='in')
class Meta:
fields = ['type', ]
class AmbulanceFilterSet(filters.FilterSet):
vehicle_numbers = filters.BaseInFilter(field_name='vehicle_number')
class PostsFilter(filters.FilterSet):
blog_id = filters.BaseInFilter(field_name="blog_id", lookup_expr="in")
class SummarySiteFilterSet(filters.FilterSet):
project_id = filters.BaseInFilter(method='id_lookup')
project_name = filters.BaseInFilter(method="char_lookup")
country_id = filters.BaseInFilter(method='id_lookup')
country_name = filters.BaseInFilter(method="char_lookup")
tag_id = filters.BaseInFilter(field_name='tags', method='json_id_lookup')
tag_name = filters.BaseInFilter(field_name="tags",
method="json_name_lookup")
management_regime_id = filters.BaseInFilter(
field_name='management_regimes', method='json_id_lookup')
management_regime_name = filters.BaseInFilter(
field_name='management_regimes', method='json_name_lookup')
project_admins = filters.BaseInFilter(method="json_name_lookup")
geometry = filters.CharFilter(method='site_by_multipoly')
date_min = filters.DateFromToRangeFilter()
date_max = filters.DateFromToRangeFilter()
include_test = filters.BooleanFilter(method='test_data_included')
class Meta:
model = SummarySiteView
fields = [
'site_id', 'site_name', 'project_id', 'project_name',
'project_admins', 'data_policy_beltfish', 'data_policy_benthiclit',
'data_policy_benthicpit', 'data_policy_habitatcomplexity',
'data_policy_bleachingqc', "country_id", 'country_name', 'tag_id',
'tag_name', 'management_regime_id', 'management_regime_name',
'geometry', 'date_min', 'date_max'
]
filter_overrides = {
models.CharField: {
'filter_class': filters.CharFilter,
'extra': lambda f: {
'lookup_expr': 'icontains',
},
},
}
def str_or_lookup(self,
queryset,
name,
value,
key=None,
lookup_expr="iexact"):
if not isinstance(name, (list, set, tuple)):
name = [name]
q = Q()
for n in name:
fieldname = "{}__{}".format(n, lookup_expr)
for v in set(value):
if v is not None and v != "":
predicate = {fieldname: str(v).strip()}
if key is not None:
predicate = {fieldname: [{key: str(v).strip()}]}
q |= Q(**predicate)
return queryset.filter(q).distinct()
def id_lookup(self, queryset, name, value):
return self.str_or_lookup(queryset, name, value)
def char_lookup(self, queryset, name, value):
return self.str_or_lookup(queryset,
name,
value,
lookup_expr="icontains")
def json_id_lookup(self, queryset, name, value):
return self.str_or_lookup(queryset, name, value, "id", "contains")
def json_name_lookup(self, queryset, name, value):
return self.str_or_lookup(queryset, name, value, "name", "contains")
def site_by_multipoly(self, queryset, name, value):
poly = valid_poly(value)
sql = """
ST_Within(
ST_Point(lon, lat),
ST_GeomFromGeoJSON('{}')
)
""".format(poly)
return queryset.extra(where=[sql])
def test_data_included(self, queryset, name, value):
if value is True:
return queryset.union(
SummarySiteView.objects.filter(
project_status=SummarySiteView.TEST))
