class MetadataTypesFilter(filters.FilterSet):
group = django_filters.CharFilter(field_name="group__group_name")
class Meta:
model = models.MetadataType
fields = ["for_context", "type_i18n"]
class CollectionVersionFilter(ContentFilter):
"""
FilterSet for Ansible CollectionVersions.
"""
namespace = filters.CharFilter(field_name="namespace")
name = filters.CharFilter(field_name="name")
is_highest = filters.BooleanFilter(field_name="is_highest", method="get_highest")
deprecated = filters.BooleanFilter(field_name="collection__deprecated")
q = filters.CharFilter(field_name="q", method="filter_by_q")
tags = filters.CharFilter(
field_name="tags",
method="filter_by_tags",
help_text=_("Filter by comma separate list of tags that must all be matched"),
)
def filter_by_q(self, queryset, name, value):
"""
Full text search provided by the 'q' option.
Args:
queryset: The query to add the additional full-text search filtering onto
name: The name of the option specified, i.e. 'q'
value: The string to search on
Returns:
The Django queryset that was passed in, additionally filtered by full-text search.
"""
search_query = SearchQuery(value)
qs = queryset.filter(search_vector=search_query)
ts_rank_fn = Func(
F("search_vector"),
search_query,
32, # RANK_NORMALIZATION = 32
function="ts_rank",
output_field=db_fields.FloatField(),
)
return qs.annotate(rank=ts_rank_fn).order_by("-rank")
def filter_by_tags(self, qs, name, value):
"""
Filter queryset qs by list of tags.
Args:
qs (django.db.models.query.QuerySet): CollectionVersion queryset
value (string): A comma separated list of tags
Returns:
Queryset of CollectionVersion that matches all tags
"""
for tag in value.split(","):
qs = qs.filter(tags__name=tag)
return qs
def get_highest(self, qs, name, value):
"""
Filter queryset qs by is_highest filter.
"""
latest_pks = []
namespace_name_dict = defaultdict(lambda: defaultdict(list))
for collection in qs.all():
version_entry = (parse(collection.version), collection.pk)
namespace_name_dict[collection.namespace][collection.name].append(version_entry)
for namespace, name_dict in namespace_name_dict.items():
for name, version_list in name_dict.items():
version_list.sort(reverse=True)
latest_pk = version_list[0][1]
latest_pks.append(latest_pk)
return qs.filter(pk__in=latest_pks)
class Meta:
model = CollectionVersion
fields = ["namespace", "name", "version", "q", "is_highest", "tags"]
class ProductFilter(FilterSet):
name = filters.CharFilter(field_name="name", lookup_expr="icontains")
class Meta:
model = Product
fields = ["name"]
class DevicesFilter(FilterSet):
STATUS_NEVER_SEEN = 'never_seen'
active = filters.TypedChoiceFilter(
choices=[(None, ''), ('true', 'Active Only'),
('false', 'Inactive Only')],
coerce=strtobool,
widget=forms.Select(
attrs={
'style': 'width: 150px',
'data-placeholder': 'Filter by Active',
'class': 'chosen-select-deselect'
}))
status = filters.TypedChoiceFilter(
method='status_filter',
required=False,
choices=((None, ''), ) + Device.STATUS_CHOICES +
((STATUS_NEVER_SEEN, 'Never Seen'), ),
widget=forms.Select(
attrs={
'style': 'width: 150px',
'data-placeholder': 'Filter by Status',
'class': 'chosen-select'
}))
tags = filters.CharFilter(lookup_expr='icontains',
required=False,
widget=forms.TextInput(
attrs={
'placeholder': 'Filter by Tags',
'class': 'form-control',
'style': 'height: 28px',
}))
name = filters.CharFilter(lookup_expr='icontains',
required=False,
widget=forms.TextInput(
attrs={
'placeholder': 'Filter by Name',
'class': 'form-control',
'style': 'height: 28px',
}))
mac = filters.CharFilter(lookup_expr='icontains',
required=False,
widget=forms.TextInput(
attrs={
'placeholder': 'Filter by Mac',
'class': 'form-control',
'style': 'height: 28px',
}))
address = filters.CharFilter(lookup_expr='icontains',
required=False,
widget=forms.TextInput(
attrs={
'placeholder': 'Filter by Address',
'class': 'form-control',
'style': 'height: 28px',
}))
feature = filters.MultipleChoiceFilter(
method='feature_filter',
required=False,
choices=DeviceFeature.FEATURE_CHOICES,
widget=forms.SelectMultiple(
attrs={
'style': 'width: 200px',
'data-placeholder': 'Filter by Feature',
'class': 'chosen-select'
}))
order_by = CustomDeviceOrderingFilter(fields=[
'id', 'name', 'address', 'mac', 'status', 'active', 'username',
'password', 'tags'
])
def status_filter(self, queryset, name, value):
if value == self.STATUS_NEVER_SEEN:
return queryset.filter(status=Device.STATUS_DOWN, last_seen=None)
elif value == Device.STATUS_DOWN:
return queryset.filter(status=Device.STATUS_DOWN).exclude(
last_seen=None)
return queryset.filter(status=value)
def feature_filter(self, queryset, name, value):
return queryset.filter(**{
'feature__feature__in': value,
'feature__active': True
}).distinct()
class Meta:
model = Device
fields = ['status', 'active', 'feature', 'tags', 'name', 'address']
class EducationGroupFilter(FilterSet):
academic_year = filters.ModelChoiceFilter(
queryset=AcademicYear.objects.all(),
required=False,
empty_label=pgettext_lazy("plural", "All"),
label=_('Ac yr.'))
category = filters.ChoiceFilter(
choices=list(Categories.choices()),
required=False,
label=_('Category'),
field_name='education_group_type__category',
empty_label=pgettext_lazy("plural", "All"))
education_group_type = filters.ModelChoiceFilter(
queryset=EducationGroupType.objects.none(),
required=False,
empty_label=pgettext_lazy("plural", "All"),
label=_('Type'),
widget=SelectWithData)
management_entity = filters.CharFilter(
method='filter_with_entity_subordinated', label=_('Entity'))
with_entity_subordinated = filters.BooleanFilter(
method=lambda queryset, *args, **kwargs: queryset,
label=_('Include subordinate entities'),
widget=forms.CheckboxInput)
acronym = filters.CharFilter(
field_name="acronym",
lookup_expr='icontains',
max_length=40,
required=False,
label=_('Acronym/Short title'),
)
title = filters.CharFilter(field_name="title",
lookup_expr='icontains',
max_length=255,
required=False,
label=_('Title'))
partial_acronym = filters.CharFilter(
field_name="partial_acronym",
lookup_expr='icontains',
max_length=15,
required=False,
label=_('Code'),
)
order_by_field = 'ordering'
ordering = OrderingFilter(
fields=(('acronym', 'acronym'), ('partial_acronym', 'code'),
('academic_year__year', 'academic_year'), ('title', 'title'),
('education_group_type__name',
'type'), ('management_entity__entityversion__acronym',
'management_entity')),
widget=forms.HiddenInput)
class Meta:
model = EducationGroupYear
fields = [
'acronym',
'partial_acronym',
'title',
'education_group_type__name',
'management_entity',
'with_entity_subordinated',
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.form.fields[
'education_group_type'].queryset = EducationGroupType.objects.all(
).order_by_translated_name()
self.form.fields['academic_year'].initial = current_academic_year()
self.form.fields[
'category'].initial = education_group_categories.TRAINING
self.form.fields["with_entity_subordinated"].initial = kwargs.pop(
'with_entity_subordinated', True)
def filter_with_entity_subordinated(self, queryset, name, value):
with_subordinated = self.form.cleaned_data['with_entity_subordinated']
if value:
entity_ids = get_entities_ids(value, with_subordinated)
queryset = queryset.filter(management_entity__in=entity_ids)
return queryset
class ObjectFilterSet(FilterSet):
type = filters.CharFilter(field_name="object_type",
help_text=get_help_text("core.Object",
"object_type"))
date = filters.DateFilter(
method="filter_date",
help_text=
_("Display record data for the specified formal date, i.e. the specified "
"date would be between `startAt` and `endAt` attributes. The default value is today"
),
)
registrationDate = filters.DateFilter(
method="filter_registration_date",
help_text=
_("Display record data for the specified registration date, i.e. the specified "
"date would be between `registrationAt` attributes of different records"
),
)
data_attrs = filters.CharFilter(
method="filter_data_attrs",
validators=[validate_data_attrs],
help_text=_(
"""Only include objects that have attributes with certain values.
Data filtering expressions are comma-separated and are structured as follows:
A valid parameter value has the form `key__operator__value`.
`key` is the attribute name, `operator` is the comparison operator to be used and `value` is the attribute value.
Note: Values can be string or numeric. Dates are not supported.
Valid operator values are:
%(operator_choices)s
`value` may not contain double underscore or comma characters.
`key` may not contain comma characters and includes double underscore only if it indicates nested attributes.
Example: in order to display only objects with `height` equal to 100, query `data_attrs=height__exact__100`
should be used. If `height` is nested inside `dimensions` attribute, query should look like
`data_attrs=dimensions__height__exact__100`
""") % {"operator_choices": display_choice_values_for_help_text(Operators)},
)
class Meta:
model = Object
fields = ("type", "data_attrs", "date", "registrationDate")
form = ObjectFilterForm
def filter_data_attrs(self, queryset, name, value):
parts = value.split(",")
for value_part in parts:
variable, operator, val = value_part.rsplit("__", 2)
val_numeric = float(val) if is_number(val) else None
if operator == "exact":
# for exact operator try to filter on string and numeric values
in_vals = [val]
if is_number(val):
in_vals.append(val_numeric)
queryset = queryset.filter(
**{f"records__data__{variable}__in": in_vals})
else:
# only numeric
queryset = queryset.filter(
**{f"records__data__{variable}__{operator}": val_numeric})
return queryset
def filter_date(self, queryset, name, value):
return queryset.filter_for_date(value)
def filter_registration_date(self, queryset, name, value):
return queryset.filter_for_registration_date(value)
class ChangesetFilter(GeoFilterSet):
"""Allows to filter Changesets by any of its fields, except 'uuid' (id of
OSM user). The 'reasons' and the 'harmful_reasons' fields can be filtered
by the exact match (filter changesets that have all the search reasons) or
by contains match (filter changesets that have any of the reasons).
"""
geometry = GeometryFilter(
name='bbox',
lookup_expr='intersects',
help_text="""Geospatial filter of changeset whose bbox intersects with
another geometry. You can use any geometry type in this filter."""
)
checked_by = filters.CharFilter(
name='check_user',
method='filter_checked_by',
help_text="""Filter changesets that were checked by a user. Use commas
to search for more than one user."""
)
users = filters.CharFilter(
name='user',
method='filter_users',
help_text="""Filter changesets created by a user. Use commas to search
for more than one user."""
)
ids = filters.CharFilter(
name='id',
method='filter_ids',
help_text="""Filter changesets by its ID. Use commas to search for more
than one id."""
)
uids = filters.CharFilter(
name='uid',
method='filter_uids',
help_text="""Filter changesets by its uid. The uid is a unique identifier
of each user in OSM. Use commas to search for more than one uid."""
)
checked = filters.BooleanFilter(
widget=BooleanWidget(),
help_text="""Filter changesets that were checked or not. Use true/false,
1/0 values."""
)
harmful = filters.BooleanFilter(
widget=BooleanWidget(),
help_text="""Filter changesets that were marked as harmful or not.
Use true/false, 1/0 values."""
)
is_suspect = filters.BooleanFilter(
widget=BooleanWidget(),
help_text='Filter changesets that were considered suspect by OSMCHA.'
)
powerfull_editor = filters.BooleanFilter(
widget=BooleanWidget(),
help_text="""Filter changesets that were created using a software editor
considered powerfull (those that allow to create, modify or delete
data in a batch)."""
)
order_by = filters.CharFilter(
name=None,
method='order_queryset',
help_text="""Order the Changesets by one of the following fields: id,
date, check_date, create, modify, delete or number_reasons. Use a
minus sign (-) before the field name to reverse the ordering.
Default ordering is '-id'."""
)
hide_whitelist = filters.BooleanFilter(
name=None,
method='filter_whitelist',
widget=BooleanWidget(),
help_text="""If True, it will exclude the changesets created by the
users that you whitelisted."""
)
area_lt = filters.CharFilter(
name=None,
method='filter_area_lt',
help_text="""Filter changesets that have a bbox area lower than X times
the area of your geospatial filter. For example, if the bbox or
geometry you defined in your filter has an area of 1 degree and you
set 'area_lt=2', it will filter the changesets whose bbox area is
lower than 2 degrees."""
)
create__gte = filters.NumberFilter(
name='create',
lookup_expr='gte',
help_text="""Filter changesets whose number of elements created are
greater than or equal to a number."""
)
create__lte = filters.NumberFilter(
name='create',
lookup_expr='lte',
help_text="""Filter changesets whose number of elements created are
lower than or equal to a number."""
)
modify__gte = filters.NumberFilter(
name='modify',
lookup_expr='gte',
help_text="""Filter changesets whose number of elements modified are
greater than or equal to a number."""
)
modify__lte = filters.NumberFilter(
name='modify',
lookup_expr='lte',
help_text="""Filter changesets whose number of elements modified are
lower than or equal to a number."""
)
delete__gte = filters.NumberFilter(
name='delete',
lookup_expr='gte',
help_text="""Filter changesets whose number of elements deleted are
greater than or equal to a number."""
)
delete__lte = filters.NumberFilter(
name='delete',
lookup_expr='lte',
help_text="""Filter changesets whose number of elements deleted are
lower than or equal to a number."""
)
date__gte = filters.DateTimeFilter(
name='date',
lookup_expr='gte',
help_text="""Filter changesets whose date is greater than or equal to a
date or a datetime value."""
)
date__lte = filters.DateTimeFilter(
name='date',
lookup_expr='lte',
help_text="""Filter changesets whose date is lower than or equal to a
date or a datetime value."""
)
check_date__gte = filters.DateTimeFilter(
name='check_date',
lookup_expr='gte',
help_text="""Filter changesets whose check_date is greater than or equal
to a date or a datetime value."""
)
check_date__lte = filters.DateTimeFilter(
name='check_date',
lookup_expr='lte',
help_text="""Filter changesets whose check_date is lower than or equal
to a date or a datetime value."""
)
editor = filters.CharFilter(
name='editor',
lookup_expr='icontains',
help_text="""Filter changesets created with a software editor. It uses
the icontains lookup expression, so a query for 'josm' will return
changesets created or last modified with all JOSM versions."""
)
comment = filters.CharFilter(
name='comment',
lookup_expr='icontains',
help_text="""Filter changesets by its comment field using the icontains
lookup expression."""
)
source = filters.CharFilter(
name='source',
lookup_expr='icontains',
help_text="""Filter changesets by its source field using the icontains
lookup expression."""
)
imagery_used = filters.CharFilter(
name='imagery_used',
lookup_expr='icontains',
help_text="""Filter changesets by its imagery_used field using the
icontains lookup expression."""
)
reasons = filters.CharFilter(
name='reasons',
method='filter_any_reasons',
help_text="""Filter changesets that have one or more of the Suspicion
Reasons. Inform the Suspicion Reasons ids separated by commas."""
)
all_reasons = filters.CharFilter(
name='reasons',
method='filter_all_reasons',
help_text="""Filter changesets that have ALL the Suspicion Reasons of a
list. Inform the Suspicion Reasons ids separated by commas."""
)
number_reasons__gte = filters.NumberFilter(
name='number_reasons',
method='filter_number_reasons',
help_text="""Filter changesets whose number of Suspicion Reasons is
equal or greater than a value."""
)
tags = filters.CharFilter(
name='tags',
method='filter_any_reasons',
help_text="""Filter changesets that have one or more of the Tags. Inform
the Tags ids separated by commas."""
)
all_tags = filters.CharFilter(
name='tags',
method='filter_all_reasons',
help_text="""Filter changesets that have ALL the Tags of a list. Inform
the Tags ids separated by commas."""
)
def filter_whitelist(self, queryset, name, value):
if self.request.user.is_authenticated and value:
whitelist = self.request.user.whitelists.values_list(
'whitelist_user',
flat=True
)
return queryset.exclude(user__in=whitelist)
else:
return queryset
def filter_checked_by(self, queryset, name, value):
lookup = '__'.join([name, 'name__in'])
users = [t.strip() for t in value.split(',')]
return queryset.filter(**{lookup: users})
def filter_users(self, queryset, name, value):
lookup = '__'.join([name, 'in'])
users_array = [t.strip() for t in value.split(',')]
return queryset.filter(**{lookup: users_array})
def filter_ids(self, queryset, name, value):
lookup = '__'.join([name, 'in'])
values = [int(n) for n in value.split(',')]
return queryset.filter(**{lookup: values})
def filter_uids(self, queryset, name, value):
lookup = '__'.join([name, 'in'])
values = [n for n in value.split(',')]
return queryset.filter(**{lookup: values})
def filter_any_reasons(self, queryset, name, value):
lookup = '__'.join([name, 'id', 'in'])
values = [int(t) for t in value.split(',')]
return queryset.filter(**{lookup: values}).distinct()
def filter_all_reasons(self, queryset, name, value):
lookup = '__'.join([name, 'id'])
values = [int(t) for t in value.split(',')]
for term in values:
queryset = queryset.filter(**{lookup: term})
return queryset
def filter_number_reasons(self, queryset, name, value):
lookup = '__'.join([name, 'gte'])
queryset = queryset.annotate(number_reasons=Count('reasons'))
return queryset.filter(**{lookup: value})
def order_queryset(self, queryset, name, value):
allowed_fields = [
'date', '-date', 'id', 'check_date', '-check_date', 'create',
'modify', 'delete', '-create', '-modify', '-delete',
'number_reasons', '-number_reasons'
]
if value in allowed_fields:
if value in ['number_reasons', '-number_reasons']:
queryset = queryset.annotate(number_reasons=Count('reasons'))
return queryset.order_by(value)
else:
return queryset
def filter_area_lt(self, queryset, name, value):
"""This filter method was designed to exclude changesets that are much
bigger than the filter area. For example, if you want to exclude
changesets that are greater than 5 times the filter area, you need to
set the value to 5.
"""
if 'geometry' in self.data.keys():
try:
filter_area = self.data['geometry'].area
except AttributeError:
filter_area = GeometryField().to_internal_value(
self.data['geometry']
).area
return queryset.filter(area__lt=float(value)*filter_area)
elif 'in_bbox' in self.data.keys():
try:
filter_area = Polygon.from_bbox(
(float(n) for n in self.data['in_bbox'].split(','))
).area
return queryset.filter(area__lt=float(value)*filter_area)
except ValueError:
return queryset
else:
return queryset
class Meta:
model = Changeset
fields = []
class CollectionByCollectionVersionFilter(
pulp_ansible_viewsets.CollectionVersionFilter):
"""pulp_ansible CollectionVersion filter for Collection viewset."""
versioning_class = versioning.UIVersioning
keywords = filters.CharFilter(field_name="keywords", method="filter_by_q")
deprecated = filters.BooleanFilter()
class MisconfiguredFilter(FilterSet):
text = filters.CharFilter(lookup_expr='icontains')
class Meta:
model = BasicModel
fields = ['text']
class RequiredFieldsFilter(SeveralFieldsFilter):
required_text = filters.CharFilter(required=True)
class Meta(SeveralFieldsFilter.Meta):
fields = SeveralFieldsFilter.Meta.fields + ['required_text']
class IngeschrevenPersoonFilter(FilterSet):
burgerservicenummer = filters.CharFilter()
geboorte__datum = filters.CharFilter()
geboorte__plaats = filters.CharFilter()
geslachtsaanduiding = filters.CharFilter() # Add enum
inclusiefoverledenpersonen = filters.BooleanFilter()
naam__geslachtsnaam = filters.CharFilter()
naam__voornamen = filters.CharFilter()
verblijfplaats__gemeentevaninschrijving = filters.CharFilter()
verblijfplaats__huisletter = filters.CharFilter()
verblijfplaats__huisnummer = filters.NumberFilter()
verblijfplaats__huisnummertoevoeging = filters.CharFilter()
verblijfplaats__identificatiecodenummeraanduiding = filters.CharFilter()
verblijfplaats__naamopenbareruimte = filters.CharFilter()
verblijfplaats__postcode = filters.CharFilter()
naam__voorvoegsel = filters.CharFilter()
class ZaakFilter(FilterSet):
maximale_vertrouwelijkheidaanduiding = MaximaleVertrouwelijkheidaanduidingFilter(
field_name="vertrouwelijkheidaanduiding",
help_text=(
"Zaken met een vertrouwelijkheidaanduiding die beperkter is dan de "
"aangegeven aanduiding worden uit de resultaten gefiltered."
),
)
rol__betrokkene_identificatie__natuurlijk_persoon__inp_bsn = filters.CharFilter(
field_name="rol__natuurlijkpersoon__inp_bsn",
help_text=get_help_text("datamodel.NatuurlijkPersoon", "inp_bsn"),
max_length=get_field_attribute(
"datamodel.NatuurlijkPersoon", "inp_bsn", "max_length"
),
)
rol__betrokkene_identificatie__natuurlijk_persoon__anp_identificatie = (
filters.CharFilter(
field_name="rol__natuurlijkpersoon__anp_identificatie",
help_text=get_help_text("datamodel.NatuurlijkPersoon", "anp_identificatie"),
max_length=get_field_attribute(
"datamodel.NatuurlijkPersoon", "anp_identificatie", "max_length"
),
)
)
rol__betrokkene_identificatie__natuurlijk_persoon__inp_a_nummer = (
filters.CharFilter(
field_name="rol__natuurlijkpersoon__inp_a_nummer",
help_text=get_help_text("datamodel.NatuurlijkPersoon", "inp_a_nummer"),
max_length=get_field_attribute(
"datamodel.NatuurlijkPersoon", "inp_a_nummer", "max_length"
),
)
)
rol__betrokkene_identificatie__niet_natuurlijk_persoon__inn_nnp_id = (
filters.CharFilter(
field_name="rol__nietnatuurlijkpersoon__inn_nnp_id",
help_text=get_help_text("datamodel.NietNatuurlijkPersoon", "inn_nnp_id"),
)
)
rol__betrokkene_identificatie__niet_natuurlijk_persoon__ann_identificatie = (
filters.CharFilter(
field_name="rol__nietnatuurlijkpersoon__ann_identificatie",
help_text=get_help_text(
"datamodel.NietNatuurlijkPersoon", "ann_identificatie"
),
max_length=get_field_attribute(
"datamodel.NietNatuurlijkPersoon", "ann_identificatie", "max_length"
),
)
)
rol__betrokkene_identificatie__vestiging__vestigings_nummer = filters.CharFilter(
field_name="rol__vestiging__vestigings_nummer",
help_text=get_help_text("datamodel.Vestiging", "vestigings_nummer"),
max_length=get_field_attribute(
"datamodel.Vestiging", "vestigings_nummer", "max_length"
),
)
rol__betrokkene_identificatie__medewerker__identificatie = filters.CharFilter(
field_name="rol__medewerker__identificatie",
help_text=get_help_text("datamodel.Medewerker", "identificatie"),
max_length=get_field_attribute(
"datamodel.Medewerker", "identificatie", "max_length"
),
)
rol__betrokkene_identificatie__organisatorische_eenheid__identificatie = (
filters.CharFilter(
field_name="rol__organisatorischeeenheid__identificatie",
help_text=get_help_text(
"datamodel.OrganisatorischeEenheid", "identificatie"
),
)
)
ordering = filters.OrderingFilter(
fields=(
"startdatum",
"einddatum",
"publicatiedatum",
"archiefactiedatum",
),
help_text="Het veld waarop de resultaten geordend worden.",
)
expand = ExpandFilter(
serializer_class=ZaakSerializer,
help_text="Haal details van inline resources direct op.",
)
class Meta:
model = Zaak
fields = {
"identificatie": ["exact"],
"bronorganisatie": ["exact"],
"zaaktype": ["exact"],
"archiefnominatie": ["exact", "in"],
"archiefactiedatum": ["exact", "lt", "gt"],
"archiefstatus": ["exact", "in"],
"startdatum": ["exact", "gt", "gte", "lt", "lte"],
# filters for werkvoorraad
"rol__betrokkene_type": ["exact"],
"rol__betrokkene": ["exact"],
"rol__omschrijving_generiek": ["exact"],
}
class RolFilter(FilterSet):
betrokkene_identificatie__natuurlijk_persoon__inp_bsn = filters.CharFilter(
field_name="natuurlijkpersoon__inp_bsn",
help_text=get_help_text("datamodel.NatuurlijkPersoon", "inp_bsn"),
)
betrokkene_identificatie__natuurlijk_persoon__anp_identificatie = (
filters.CharFilter(
field_name="natuurlijkpersoon__anp_identificatie",
help_text=get_help_text("datamodel.NatuurlijkPersoon", "anp_identificatie"),
)
)
betrokkene_identificatie__natuurlijk_persoon__inp_a_nummer = filters.CharFilter(
field_name="natuurlijkpersoon__inp_a_nummer",
help_text=get_help_text("datamodel.NatuurlijkPersoon", "inp_a_nummer"),
)
betrokkene_identificatie__niet_natuurlijk_persoon__inn_nnp_id = filters.CharFilter(
field_name="nietnatuurlijkpersoon__inn_nnp_id",
help_text=get_help_text("datamodel.NietNatuurlijkPersoon", "inn_nnp_id"),
)
betrokkene_identificatie__niet_natuurlijk_persoon__ann_identificatie = (
filters.CharFilter(
field_name="nietnatuurlijkpersoon__ann_identificatie",
help_text=get_help_text(
"datamodel.NietNatuurlijkPersoon", "ann_identificatie"
),
)
)
betrokkene_identificatie__vestiging__vestigings_nummer = filters.CharFilter(
field_name="vestiging__vestigings_nummer",
help_text=get_help_text("datamodel.Vestiging", "vestigings_nummer"),
)
betrokkene_identificatie__organisatorische_eenheid__identificatie = (
filters.CharFilter(
field_name="organisatorischeeenheid__identificatie",
help_text=get_help_text(
"datamodel.OrganisatorischeEenheid", "identificatie"
),
)
)
betrokkene_identificatie__medewerker__identificatie = filters.CharFilter(
field_name="medewerker__identificatie",
help_text=get_help_text("datamodel.Medewerker", "identificatie"),
)
class Meta:
model = Rol
fields = (
"zaak",
"betrokkene",
"betrokkene_type",
"betrokkene_identificatie__natuurlijk_persoon__inp_bsn",
"betrokkene_identificatie__natuurlijk_persoon__anp_identificatie",
"betrokkene_identificatie__natuurlijk_persoon__inp_a_nummer",
"betrokkene_identificatie__niet_natuurlijk_persoon__inn_nnp_id",
"betrokkene_identificatie__niet_natuurlijk_persoon__ann_identificatie",
"betrokkene_identificatie__vestiging__vestigings_nummer",
"betrokkene_identificatie__organisatorische_eenheid__identificatie",
"betrokkene_identificatie__medewerker__identificatie",
"roltype",
"omschrijving",
"omschrijving_generiek",
)
class ChangesetFilter(GeoFilterSet):
"""Allows to filter Changesets by any of its fields, except 'uuid' (id of
OSM user). The 'reasons' and the 'harmful_reasons' fields can be filtered
by the exact match (filter changesets that have all the search reasons) or
by contains match (filter changesets that have any of the reasons).
"""
geometry = GeometryFilter(
field_name='bbox',
lookup_expr='intersects',
help_text="""Geospatial filter of changeset whose bbox intersects with
another geometry. You can use any geometry type in this filter.""")
checked_by = filters.CharFilter(
field_name='check_user',
method='filter_checked_by',
help_text="""Filter changesets that were checked by a user. Use commas
to search for more than one user.""")
users = filters.CharFilter(
field_name='user',
method='filter_users',
help_text="""Filter changesets created by a user. Use commas to search
for more than one user.""")
ids = filters.CharFilter(
field_name='id',
method='filter_ids',
help_text="""Filter changesets by its ID. Use commas to search for more
than one id.""")
uids = filters.CharFilter(
field_name='uid',
method='filter_uids',
help_text="""Filter changesets by its uid. The uid is a unique identifier
of each user in OSM. Use commas to search for more than one uid.""")
checked = filters.BooleanFilter(
field_name='checked',
widget=BooleanWidget(),
help_text="""Filter changesets that were checked or not. Use true/false,
1/0 values.""")
harmful = filters.BooleanFilter(
field_name='harmful',
widget=BooleanWidget(),
help_text="""Filter changesets that were marked as harmful or not.
Use true/false, 1/0 values.""")
is_suspect = filters.BooleanFilter(
field_name='is_suspect',
widget=BooleanWidget(),
help_text='Filter changesets that were considered suspect by OSMCHA.')
powerfull_editor = filters.BooleanFilter(
field_name='powerfull_editor',
widget=BooleanWidget(),
help_text="""Filter changesets that were created using a software editor
considered powerfull (those that allow to create, modify or delete
data in a batch).""")
order_by = filters.CharFilter(
field_name='order',
method='order_queryset',
help_text="""Order the Changesets by one of the following fields: id,
date, check_date, create, modify, delete or number_reasons. Use a
minus sign (-) before the field name to reverse the ordering.
Default ordering is '-id'.""")
hide_whitelist = filters.BooleanFilter(
field_name='user',
method='filter_whitelist',
widget=BooleanWidget(),
help_text="""If True, it will exclude the changesets created by the
users that you whitelisted.""")
blacklist = filters.BooleanFilter(
field_name='user',
method='filter_blacklist',
widget=BooleanWidget(),
help_text="""If True, it will get only the changesets created by the
users that you blacklisted.""")
mapping_teams = filters.CharFilter(
field_name='user',
method='filter_mapping_team',
help_text="""Filter changesets created by users that are on a Mapping
Team. It accepts a list of teams separated by commas.""")
exclude_teams = filters.CharFilter(
field_name='user',
method='exclude_mapping_team',
help_text="""Exclude changesets created by users that are on a Mapping
Team. It accepts a list of teams separated by commas.""")
exclude_trusted_teams = filters.BooleanFilter(
field_name='user',
method='filter_hide_trusted_teams',
widget=BooleanWidget(),
help_text="""If True, it will exclude the changesets created by the
users that are part of trusted teams.""")
area_lt = filters.CharFilter(
field_name='user',
method='filter_area_lt',
help_text="""Filter changesets that have a bbox area lower than X times
the area of your geospatial filter. For example, if the bbox or
geometry you defined in your filter has an area of 1 degree and you
set 'area_lt=2', it will filter the changesets whose bbox area is
lower than 2 degrees.""")
create__gte = filters.NumberFilter(
field_name='create',
lookup_expr='gte',
help_text="""Filter changesets whose number of elements created are
greater than or equal to a number.""")
create__lte = filters.NumberFilter(
field_name='create',
lookup_expr='lte',
help_text="""Filter changesets whose number of elements created are
lower than or equal to a number.""")
modify__gte = filters.NumberFilter(
field_name='modify',
lookup_expr='gte',
help_text="""Filter changesets whose number of elements modified are
greater than or equal to a number.""")
modify__lte = filters.NumberFilter(
field_name='modify',
lookup_expr='lte',
help_text="""Filter changesets whose number of elements modified are
lower than or equal to a number.""")
delete__gte = filters.NumberFilter(
field_name='delete',
lookup_expr='gte',
help_text="""Filter changesets whose number of elements deleted are
greater than or equal to a number.""")
delete__lte = filters.NumberFilter(
field_name='delete',
lookup_expr='lte',
help_text="""Filter changesets whose number of elements deleted are
lower than or equal to a number.""")
comments_count__gte = filters.NumberFilter(
field_name='comments_count',
lookup_expr='gte',
help_text="""Filter changesets whose number of comments are greater than
or equal to a number.""")
comments_count__lte = filters.NumberFilter(
field_name='comments_count',
lookup_expr='lte',
help_text="""Filter changesets whose number of comments are lower than
or equal to a number.""")
date__gte = filters.DateTimeFilter(
field_name='date',
lookup_expr='gte',
help_text="""Filter changesets whose date is greater than or equal to a
date or a datetime value.""")
date__lte = filters.DateTimeFilter(
field_name='date',
lookup_expr='lte',
help_text="""Filter changesets whose date is lower than or equal to a
date or a datetime value.""")
check_date__gte = filters.DateTimeFilter(
field_name='check_date',
lookup_expr='gte',
help_text="""Filter changesets whose check_date is greater than or equal
to a date or a datetime value.""")
check_date__lte = filters.DateTimeFilter(
field_name='check_date',
lookup_expr='lte',
help_text="""Filter changesets whose check_date is lower than or equal
to a date or a datetime value.""")
editor = filters.CharFilter(
field_name='editor',
lookup_expr='icontains',
help_text="""Filter changesets created with a software editor. It uses
the icontains lookup expression, so a query for 'josm' will return
changesets created or last modified with all JOSM versions.""")
comment = filters.CharFilter(
field_name='comment',
lookup_expr='icontains',
help_text="""Filter changesets by its comment field using the icontains
lookup expression.""")
source = filters.CharFilter(
field_name='source',
lookup_expr='icontains',
help_text="""Filter changesets by its source field using the icontains
lookup expression.""")
imagery_used = filters.CharFilter(
field_name='imagery_used',
lookup_expr='icontains',
help_text="""Filter changesets by its imagery_used field using the
icontains lookup expression.""")
reasons = filters.CharFilter(
field_name='reasons',
method='filter_any_reasons',
help_text="""Filter changesets that have one or more of the Suspicion
Reasons. Inform the Suspicion Reasons ids separated by commas.""")
all_reasons = filters.CharFilter(
field_name='reasons',
method='filter_all_reasons',
help_text="""Filter changesets that have ALL the Suspicion Reasons of a
list. Inform the Suspicion Reasons ids separated by commas.""")
number_reasons__gte = filters.NumberFilter(
field_name='number_reasons',
method='filter_number_reasons',
help_text="""Filter changesets whose number of Suspicion Reasons is
equal or greater than a value.""")
tags = filters.CharFilter(
field_name='tags',
method='filter_any_reasons',
help_text="""Filter changesets that have one or more of the Tags. Inform
the Tags ids separated by commas.""")
all_tags = filters.CharFilter(
field_name='tags',
method='filter_all_reasons',
help_text="""Filter changesets that have ALL the Tags of a list. Inform
the Tags ids separated by commas.""")
metadata = filters.CharFilter(
field_name='metadata',
method='filter_metadata',
help_text="""Filter changesets by the metadata fields.""")
def filter_metadata(self, queryset, name, value):
values = [
[i.strip()
for i in t.split('=')] # remove leading and ending spaces
for t in value.split(',') if len(t.split('=')) == 2
]
for query in values:
if '__' in query[0]:
# handle both int values and other lookup options like __exact or __contains
key = 'metadata__{}'.format(query[0].replace(
'__min', '__gte').replace('__max', '__lte'))
try:
value = int(query[1])
except ValueError:
value = query[1]
elif query[1] == '*':
key = 'metadata__has_key'
value = query[0]
else:
# default option is to use the icontains condition
key = key = 'metadata__{}__icontains'.format(query[0])
value = query[1]
queryset = queryset.filter(**{key: value})
return queryset
def filter_whitelist(self, queryset, name, value):
if value:
whitelist = self.request.user.whitelists.values_list(
'whitelist_user', flat=True)
return queryset.exclude(user__in=whitelist)
else:
return queryset
def filter_blacklist(self, queryset, name, value):
if value:
blacklist = self.request.user.blacklisteduser_set.values_list(
'uid', flat=True)
return queryset.filter(uid__in=blacklist)
else:
return queryset
def get_username_from_teams(self, teams):
users = []
for i in teams.values_list('users', flat=True):
values = i
if type(values) in [str, bytes, bytearray]:
values = json.loads(values)
for e in values:
users.append(e.get('username'))
return users
def filter_mapping_team(self, queryset, name, value):
try:
# added `if team` to avoid empty strings
teams = MappingTeam.objects.filter(
name__in=[team.strip() for team in value.split(',') if team])
users = self.get_username_from_teams(teams)
return queryset.filter(user__in=users)
except MappingTeam.DoesNotExist:
return queryset
def exclude_mapping_team(self, queryset, name, value):
try:
teams = MappingTeam.objects.filter(
name__in=[team.strip() for team in value.split(',') if team])
users = self.get_username_from_teams(teams)
return queryset.exclude(user__in=users)
except MappingTeam.DoesNotExist:
return queryset
def filter_hide_trusted_teams(self, queryset, name, value):
teams = MappingTeam.objects.filter(trusted=True)
users = self.get_username_from_teams(teams)
if users:
return queryset.exclude(user__in=users)
else:
return queryset
def filter_checked_by(self, queryset, name, value):
if (self.request is None
or self.request.user.is_authenticated) and value:
lookup = '__'.join([name, 'name__in'])
users = [t.strip() for t in value.split(',')]
return queryset.filter(**{lookup: users})
else:
return queryset
def filter_users(self, queryset, name, value):
if (self.request is None
or self.request.user.is_authenticated) and value:
lookup = '__'.join([name, 'in'])
users_array = [t.strip() for t in value.split(',')]
return queryset.filter(**{lookup: users_array})
else:
return queryset
def filter_ids(self, queryset, name, value):
lookup = '__'.join([name, 'in'])
values = [int(n) for n in value.split(',')]
return queryset.filter(**{lookup: values})
def filter_uids(self, queryset, name, value):
if (self.request is None
or self.request.user.is_authenticated) and value:
lookup = '__'.join([name, 'in'])
values = [n for n in value.split(',')]
return queryset.filter(**{lookup: values})
else:
return queryset
def filter_any_reasons(self, queryset, name, value):
lookup = '__'.join([name, 'id', 'in'])
values = [int(t) for t in value.split(',')]
return queryset.filter(**{lookup: values}).distinct()
def filter_all_reasons(self, queryset, name, value):
lookup = '__'.join([name, 'id'])
values = [int(t) for t in value.split(',')]
for term in values:
queryset = queryset.filter(**{lookup: term})
return queryset
def filter_number_reasons(self, queryset, name, value):
lookup = '__'.join([name, 'gte'])
queryset = queryset.annotate(number_reasons=Count('reasons'))
return queryset.filter(**{lookup: value})
def order_queryset(self, queryset, name, value):
allowed_fields = [
'date', '-date', 'id', 'check_date', '-check_date', 'create',
'modify', 'delete', '-create', '-modify', '-delete',
'number_reasons', '-number_reasons', 'comments_count',
'-comments_count'
]
if value in allowed_fields:
if value in ['number_reasons', '-number_reasons']:
queryset = queryset.annotate(number_reasons=Count('reasons'))
return queryset.order_by(value)
else:
return queryset
def filter_area_lt(self, queryset, name, value):
"""This filter method was designed to exclude changesets that are much
bigger than the filter area. For example, if you want to exclude
changesets that are greater than 5 times the filter area, you need to
set the value to 5.
"""
if 'geometry' in self.data.keys():
try:
filter_area = self.data['geometry'].area
except AttributeError:
filter_area = GeometryField().to_internal_value(
self.data['geometry']).area
return queryset.filter(area__lt=float(value) * filter_area)
elif 'in_bbox' in self.data.keys():
try:
filter_area = Polygon.from_bbox(
(float(n) for n in self.data['in_bbox'].split(','))).area
return queryset.filter(area__lt=float(value) * filter_area)
except ValueError:
return queryset
else:
return queryset
class Meta:
model = Changeset
fields = ['geometry', 'users', 'area_lt']
class LineFilter(EDDObjectFilter):
contact = django_filters.ModelChoiceFilter(
field_name="contact",
help_text=_("ID of the user set as the Line contact"),
queryset=User.objects.all(),
)
control = django_filters.BooleanFilter(
field_name="control",
help_text=_(
"Filter on Lines marked as controls (True/1/yes or false/0/no)"),
)
experimenter = django_filters.ModelChoiceFilter(
field_name="experimenter",
help_text=_("ID of the user set as the Line experimenter"),
queryset=User.objects.all(),
)
in_study = django_filters.CharFilter(
field_name="study",
help_text=_("An identifier for the study; can use ID, UUID, or Slug"),
method=filter_in_study,
)
replicates = django_filters.CharFilter(
help_text=_("Flag to organize Lines by grouping together replicates"),
method="group_replicates",
)
strain = django_filters.CharFilter(
field_name="strains",
help_text=_(
"Search on a strain UUID or registry URLs, separated by commas"),
method="filter_strains",
)
study = django_filters.ModelChoiceFilter(
field_name="study",
help_text=_("ID of the study the Line(s) are linked to"),
queryset=models.Study.objects.all(),
)
class Meta:
model = models.Line
fields = []
def filter_strains(self, queryset, name, values):
# split out multiple values similar to other django_filters 'in' param processing
uuid_values, url_values = [], []
for value in values.split(","):
try:
uuid_values.append(UUID(value))
except ValueError:
url_values.append(value)
match_uuid = Q(strains__registry_id__in=uuid_values)
match_url = Q(strains__registry_url__in=url_values)
return queryset.filter(match_uuid | match_url)
def group_replicates(self, queryset, name, value):
if self.truthy(value):
replicate_type = models.MetadataType.system("Replicate")
# extract replicate key from metadata
replicate = Func(
F("metadata"),
Value(f"{replicate_type.id}"),
function="jsonb_extract_path_text",
output_field=CharField(),
)
# define fallback of line's UUID when no metadata replicate value
replicate_key = Coalesce(replicate,
Cast("uuid", output_field=CharField()))
return queryset.annotate(replicate_key=replicate_key)
return queryset
class BaseFilterableItemFilter(FilterSet):
text = filters.CharFilter()
class Meta:
model = BaseFilterableItem
fields = '__all__'
class MeasurementFilter(filters.FilterSet):
active = django_filters.BooleanFilter(
field_name="active",
help_text=
_("Filter on currently active/visible items (True/1/yes or false/0/no)"
),
)
assay = ModelChoiceInFilter(
field_name="assay",
help_text=_("IDs of assay(s) to limit measurements"),
queryset=models.Assay.objects.all(),
)
created_before = django_filters.IsoDateTimeFilter(
field_name="created__mod_time",
help_text=_("Use an ISO-8601-like datetime: 2020-01-01 00:00:00"),
lookup_expr="lte",
)
created_after = django_filters.IsoDateTimeFilter(
field_name="created__mod_time",
help_text=_("Use an ISO-8601-like datetime: 2020-01-01 00:00:00"),
lookup_expr="gte",
)
compartment = django_filters.ChoiceFilter(
choices=models.Measurement.Compartment.CHOICE,
field_name="compartment",
help_text=
_("One of the compartment codes, 0, 1, 2 for N/A, Intracellular, Extracellular"
),
)
format = django_filters.ChoiceFilter(
choices=models.Measurement.Format.CHOICE,
field_name="measurement_format",
help_text=_("One of the format codes; currently only '0' for Scalar "
"format values is supported"),
)
in_study = django_filters.CharFilter(
field_name="study",
help_text=_("An identifier for the study; can use ID, UUID, or Slug"),
method=filter_in_study,
)
line = ModelChoiceInFilter(
field_name="assay__line",
help_text=_("IDs of line(s) to limit measurements"),
queryset=models.Line.objects.all(),
)
protocol = ModelChoiceInFilter(
field_name="assay__protocol",
help_text=_("IDs of protocol(s) to limit measurements"),
queryset=models.Protocol.objects.all(),
)
type = ModelChoiceInFilter(
field_name="measurement_type",
help_text=_("IDs of measurement type(s) to limit measurements"),
queryset=models.MeasurementType.objects.all(),
)
x_units = ModelChoiceInFilter(
field_name="x_units",
help_text=_("IDs of unit(s) used on the x-axis to limit measurements"),
queryset=models.MeasurementUnit.objects.all(),
)
y_units = ModelChoiceInFilter(
field_name="y_units",
help_text=_("IDs of unit(s) used on the y-axis to limit measurements"),
queryset=models.MeasurementUnit.objects.all(),
)
class Meta:
model = models.Measurement
fields = []
class RepositoryCollectionFilter(CollectionVersionFilter):
versioning_class = versioning.UIVersioning
keywords = filters.CharFilter(field_name="keywords", method="filter_by_q")