class WorkerFilter(BaseFilterSet):
name = filters.CharFilter()
last_heartbeat = IsoDateTimeFilter()
online = filters.BooleanFilter(method="filter_online")
missing = filters.BooleanFilter(method="filter_missing")
class Meta:
model = Worker
fields = {
"name": NAME_FILTER_OPTIONS,
"last_heartbeat": DATETIME_FILTER_OPTIONS,
"online": ["exact"],
"missing": ["exact"],
}
def filter_online(self, queryset, name, value):
online_workers = Worker.objects.online_workers()
if value:
return queryset.filter(pk__in=online_workers)
else:
return queryset.exclude(pk__in=online_workers)
def filter_missing(self, queryset, name, value):
missing_workers = Worker.objects.missing_workers()
if value:
return queryset.filter(pk__in=missing_workers)
else:
return queryset.exclude(pk__in=missing_workers)
class WorkerFilter(BaseFilterSet):
name = filters.CharFilter()
last_heartbeat = IsoDateTimeFilter()
online = filters.BooleanFilter(method='filter_online')
missing = filters.BooleanFilter(method='filter_missing')
class Meta:
model = Worker
fields = {
'name': NAME_FILTER_OPTIONS,
'last_heartbeat': DATETIME_FILTER_OPTIONS,
'online': ['exact'],
'missing': ['exact']
}
def filter_online(self, queryset, name, value):
online_workers = Worker.objects.online_workers()
if value:
return queryset.filter(pk__in=online_workers)
else:
return queryset.exclude(pk__in=online_workers)
def filter_missing(self, queryset, name, value):
missing_workers = Worker.objects.missing_workers()
if value:
return queryset.filter(pk__in=missing_workers)
else:
return queryset.exclude(pk__in=missing_workers)
class RecipeFilterSet(LocalizationFilterSet):
input_id = filters.NumberFilter(method="filter_input")
output_id = filters.NumberFilter(method="filter_output")
is_event = filters.BooleanFilter(method="filter_event")
requires_backer = filters.BooleanFilter(method="filter_backer")
class Meta:
model = Recipe
fields = [
"machine",
]
def filter_input(self, queryset, name, value):
return queryset.filter(
Q(levels__inputs__item__game_id=value)
| Q(levels__inputs__group__members__game_id=value))
def filter_output(self, queryset, name, value):
return queryset.filter(output__game_id=value)
def filter_event(self, queryset, name, value):
if value:
queryset = queryset.filter(required_event__isnull=False)
elif value is False:
queryset = queryset.filter(required_event__isnull=True)
return queryset
def filter_backer(self, queryset, name, value):
if value:
queryset = queryset.filter(required_backer_tier__isnull=False)
elif value is False:
queryset = queryset.filter(required_backer_tier__isnull=True)
return queryset
class ItemFilterSet(LocalizationFilterSet):
has_colors = filters.BooleanFilter(
label=_("Filters out items with/without colors"),
method="filter_colors",
)
has_metal_variants = filters.BooleanFilter(
label=_("Filters out items with/without metal variants"),
method="filter_metals",
)
has_world_colors = filters.BooleanFilter(
label=_("Filters out items that vary from world to world with "
"colors (rock, grass, wood, etc.)"),
method="filter_world_colors",
)
class Meta:
model = Item
fields = [
"string_id",
"item_subtitle_id",
"list_type__string_id",
"is_resource",
]
def filter_colors(self, queryset, name, value):
if value:
queryset = queryset.filter(game_id__in=get_block_color_item_ids())
elif value is False:
queryset = queryset.exclude(game_id__in=get_block_color_item_ids())
return queryset
def filter_metals(self, queryset, name, value):
if value:
queryset = queryset.filter(game_id__in=get_block_metal_item_ids())
elif value is False:
queryset = queryset.exclude(game_id__in=get_block_metal_item_ids())
return queryset
def filter_world_colors(self, queryset, name, value):
if value:
queryset = queryset.filter(
game_id__in=get_world_block_color_item_ids())
elif value is False:
queryset = queryset.exclude(
game_id__in=get_world_block_color_item_ids())
return queryset
class AdminNewsFilter(FilterSet):
current_verdict = filters.ChoiceFilter(field_name="current_verdict",
choices=NEWS_FINAL_VERDICT_TYPES)
is_duplicate = filters.BooleanFilter(field_name="is_duplicate")
deleted = filters.BooleanFilter(field_name="deleted")
is_sensitive = filters.BooleanFilter(field_name="is_sensitive")
class Meta:
model = News
fields = (
"current_verdict",
"is_duplicate",
"deleted",
"is_sensitive",
)
class Pulp2RepositoriesFilter(BaseFilterSet):
"""
Filter for Pulp2Repositories ViewSet.
"""
pulp2_repo_id = filters.CharFilter()
is_migrated = filters.BooleanFilter()
not_in_plan = filters.BooleanFilter()
class Meta:
model = Pulp2Repository
fields = {
'pulp2_repo_id': ['exact', 'in'],
'is_migrated': ['exact'],
'not_in_plan': ['exact']
}
class UserNameListFilterSet(FilterSet):
username = filters.CharFilter(lookup_expr='icontains', min_length=3)
is_active = filters.BooleanFilter(field_name='is_active')
profile_department_code = filters.ModelMultipleChoiceFilter(
queryset=_get_department_queryset(),
to_field_name='code',
field_name='profile__departments__code')
class NewsVerifiedFilter(FilterSet):
current_verdict = filters.ChoiceFilter(
choices=NEWS_CURRENT_VERDICT_CHOICES)
is_duplicate = filters.BooleanFilter(field_name="is_duplicate")
is_about_corona_virus = filters.BooleanFilter(
field_name="is_about_corona_virus")
is_assigned_to_me = filters.BooleanFilter(field_name="is_assigned_to_me")
class Meta:
model = News
fields = (
"current_verdict",
"is_duplicate",
"is_about_corona_virus",
"is_assigned_to_me",
)
class Pulp2RepositoriesFilter(BaseFilterSet):
"""
Filter for Pulp2Repositories ViewSet.
"""
pulp2_repo_id = filters.CharFilter()
is_migrated = filters.BooleanFilter()
not_in_plan = filters.BooleanFilter()
class Meta:
model = Pulp2Repository
fields = {
"pulp2_repo_id": ["exact", "in"],
"is_migrated": ["exact"],
"not_in_plan": ["exact"],
}
class FactCheckerNewsFilter(FilterSet):
is_opined = filters.BooleanFilter(field_name="is_opined")
origin = filters.ChoiceFilter(field_name="origin",
choices=NewsOrigin.choices)
class Meta:
model = News
fields = ("is_opined", "origin")
class ExpertNewsFilter(FilterSet):
current_verdict = filters.ChoiceFilter(
choices=NEWS_CURRENT_VERDICT_CHOICES)
is_duplicate = filters.BooleanFilter(field_name="is_duplicate")
is_about_corona_virus = filters.BooleanFilter(
field_name="is_about_corona_virus")
is_spam = filters.BooleanFilter(field_name="is_spam")
is_sensitive = filters.BooleanFilter(field_name="is_sensitive")
class Meta:
model = News
fields = (
"current_verdict",
"is_duplicate",
"is_about_corona_virus",
"is_spam",
"is_sensitive",
)
class MacFilter(FilterSet):
naam = filters.CharFilter()
eigenaar = filters.CharFilter()
eigenaar__faillissement = filters.BooleanFilter()
bezoekadres__correctie = filters.BooleanFilter()
class Meta:
model = models.MaatschappelijkeActiviteit
fields = (
'eigenaar',
'naam',
'bezoekadres__correctie',
'eigenaar__faillissement',
)
ordering = ('id',)
class CrewUsersFilter(FilterSet):
specialization = filters.ChoiceFilter(
field_name="specialization", choices=UserSpecializationType.choices)
created = filters.DateFromToRangeFilter(field_name="created_at")
is_active = filters.BooleanFilter(field_name="is_active")
class Meta:
model = User
fields = ("specialization", "created", "is_active")
class NewsVerifiedFilter(FilterSet):
current_verdict = filters.ChoiceFilter(
choices=NEWS_CURRENT_VERDICT_CHOICES)
is_assigned_to_me = filters.BooleanFilter(field_name="is_assigned_to_me")
is_duplicate = filters.BooleanFilter(field_name="is_duplicate")
is_published = filters.BooleanFilter(field_name="is_published")
origin = filters.ChoiceFilter(field_name="origin",
choices=NewsOrigin.choices)
class Meta:
model = News
fields = (
"current_verdict",
"is_assigned_to_me",
"is_duplicate",
"is_published",
"origin",
)
class AccessPolicyFilter(BaseFilterSet):
"""
FilterSet for AccessPolicy.
"""
customized = filters.BooleanFilter()
class Meta:
model = AccessPolicy
fields = {"viewset_name": NAME_FILTER_OPTIONS, "customized": ["exact"]}
class ExpertNewsFilter(FilterSet):
assigned_to_me = filters.BooleanFilter(field_name="is_assigned_to_me")
current_verdict = filters.ChoiceFilter(
choices=NEWS_CURRENT_VERDICT_CHOICES)
is_duplicate = filters.BooleanFilter(field_name="is_duplicate")
is_sensitive = filters.BooleanFilter(field_name="is_sensitive")
is_spam = filters.BooleanFilter(field_name="is_spam")
origin = filters.ChoiceFilter(field_name="origin",
choices=NewsOrigin.choices)
class Meta:
model = News
fields = (
"assigned_to_me",
"current_verdict",
"is_duplicate",
"is_sensitive",
"is_spam",
"origin",
)
class ContainerFilter(FilterSet):
in_bammens = filters.BooleanFilter(method='in_bammens_filter',
label='in_bammens')
class Meta(object):
model = EnevoContainer
fields = ('site_id', 'site_content_type_id', 'container_slot_id',
'container_type_id', 'customer_key', 'valid')
def in_bammens_filter(self, qs, name, value):
return qs.filter(valid=value)
class KilogramFilter(FilterSet):
id = filters.CharFilter()
in_bbox = filters.CharFilter(method='in_bbox_filter', label='bbox')
detailed = filters.BooleanFilter(method='detailed_filter',
label='detailed view')
weigh_at_gt = filters.DateTimeFilter('weigh_at', lookup_expr='gt')
weigh_at_lt = filters.DateTimeFilter('weigh_at', lookup_expr='lt')
location = filters.CharFilter(method="locatie_filter", label='x,y,r')
fractie = filters.ChoiceFilter(choices=settings.WASTE_CHOICES,
label='waste name')
# stadsdeel = filters.ChoiceFilter(choices=STADSDELEN)
# buurt_code = filters.ChoiceFilter(choices=buurt_choices)
class Meta(object):
model = KilogramWeighMeasurement
fields = (
"id",
"seq_id",
"fractie",
"weigh_at",
"weigh_at_gt",
"weigh_at_lt",
"stadsdeel",
"buurt_code",
"site_id",
"first_weight",
"second_weight",
"net_weight",
"in_bbox",
"location",
"detailed",
"valid",
)
def in_bbox_filter(self, qs, name, value):
bbox_values, err = bbox.valid_bbox(value)
lat1, lon1, lat2, lon2 = bbox_values
poly_bbox = Polygon.from_bbox((lon1, lat1, lon2, lat2))
if err:
raise ValidationError(f"bbox invalid {err}:{bbox_values}")
return qs.filter(geometrie__bboverlaps=(poly_bbox))
def locatie_filter(self, qs, name, value):
point, radius = bbox.parse_xyr(value)
return qs.filter(geometrie__dwithin=(point, radius))
def detailed_filter(self, qs, name, valie):
return qs
class ItemResourceCountFilterSet(BaseFilterSet):
is_exo = filters.BooleanFilter(label=_("Filter out exo/non exoworlds"),
method="filter_exo")
is_sovereign = filters.BooleanFilter(
label=_("Filter out Sovereign/non Sovereign worlds"),
method="filter_sovereign",
)
class Meta:
model = ResourceCount
fields = [
"world_poll__world__tier",
"world_poll__world__region",
"world_poll__world__world_type",
"world_poll__world__name",
"world_poll__world__display_name",
]
def filter_exo(self, queryset, name, value):
if value:
queryset = queryset.filter(
world_poll__world__assignment__isnull=False,
world_poll__world__owner__isnull=True,
world_poll__world__end__isnull=False,
)
elif value is False:
queryset = queryset.exclude(
world_poll__world__assignment__isnull=False,
world_poll__world__owner__isnull=True,
world_poll__world__end__isnull=False,
)
return queryset
def filter_sovereign(self, queryset, name, value):
if value:
queryset = queryset.filter(world_poll__world__owner__isnull=False)
elif value is False:
queryset = queryset.filter(world_poll__world__owner__isnull=True)
return queryset
class ManagementNewsFilter(FilterSet):
current_verdict = filters.ChoiceFilter(field_name="current_verdict",
choices=NEWS_FINAL_VERDICT_TYPES)
deleted = filters.BooleanFilter(field_name="deleted")
is_duplicate = filters.BooleanFilter(field_name="is_duplicate")
is_pinned = filters.BooleanFilter(field_name="is_pinned")
is_published = filters.BooleanFilter(field_name="is_published")
is_sensitive = filters.BooleanFilter(field_name="is_sensitive")
origin = filters.ChoiceFilter(field_name="origin",
choices=NewsOrigin.choices)
class Meta:
model = News
fields = (
"current_verdict",
"deleted",
"is_duplicate",
"is_pinned",
"is_published",
"is_sensitive",
"origin",
)
class PostFilter(FilterSet):
text = filters.CharFilter(field_name="text", lookup_expr="icontains")
is_current = filters.BooleanFilter(method='filter_is_current')
class Meta:
model = Post
fields = ['author', 'text', 'pub_date']
def filter_is_current(self, queryset, name, value):
set1 = queryset.filter(pub_date__year=2021)
set2 = queryset.filter(pub_date__month=5)
return set1 & set2
class SiteFilter(FilterSet):
no_site = filters.BooleanFilter(method='in_site_filter',
label='in_bammens')
class Meta(object):
model = EnevoSite
fields = {
'site_id': ['exact'],
'no_site': ['exact'],
}
def in_site_filter(self, qs, name, value):
return qs.filter(site_id__isnull=not (value))
class ItemColorFilterSet(WorldBlockColorFilterSet):
show_inactive_colors = filters.BooleanFilter(
label=_("Include previous avaiable Sovereign colors"),
method="filter_null",
)
show_inactive = filters.BooleanFilter(
label=_("Include inactive worlds (no longer in game API)"),
method="filter_null",
)
class Meta:
model = WorldBlockColor
fields = [
"active",
"is_default",
"color__game_id",
"world__active",
"world__tier",
"world__region",
"world__world_type",
"world__name",
"world__display_name",
]
def filter_null(self, queryset, name, value):
return queryset
def filter_queryset(self, queryset):
queryset = super().filter_queryset(queryset)
if (self.form.cleaned_data["show_inactive_colors"] is not True
and self.form.cleaned_data["active"] is None):
queryset = queryset.filter(active=True)
if (self.form.cleaned_data["show_inactive"] is not True
and self.form.cleaned_data["world__active"] is None):
queryset = queryset.filter(world__active=True)
return queryset
class InvoiceFilter(FilterSet):
lease = filters.NumberFilter()
going_to_sap = filters.BooleanFilter(method="filter_going_to_sap",
label=_("Going to SAP"))
class Meta:
model = Invoice
fields = ["lease", "state", "type"]
def filter_going_to_sap(self, queryset, name, value):
if value:
return queryset.filter(due_date__gte=datetime.date.today(),
sent_to_sap_at__isnull=True)
return queryset
class JurisdictionFilter(FilterSet):
whitelisted = filters.BooleanFilter()
slug = filters.ChoiceFilter(choices=jur_choices, label='Name')
name_long = filters.CharFilter(label='Long Name')
class Meta:
model = models.Jurisdiction
fields = [
'id',
'name',
'name_long',
'whitelisted',
'slug',
]
class SubjectFilter(FilterSet):
"""
Filter subjecten.
"""
buurt = filters.CharFilter(method="buurt_filter", label='buurt')
zakelijk_recht = filters.NumberFilter(method="recht_filter", label='recht')
bewoners = filters.BooleanFilter(method="bewoners_filter")
class Meta(object):
model = models.KadastraalSubject
fields = (
'naam',
'type',
'buurt',
'kvknummer',
'statutaire_naam',
'zakelijk_recht',
)
def buurt_filter(self, queryset, _filter_name, value):
"""
Buurt code 4 chars
"""
recht_type = 2 # eigenaar
if 'zakelijk_recht' in self.request.GET:
recht_type = self.request.GET['zakelijk_recht']
if len(value) != 4:
raise drf_serializers.ValidationError('Buurt vollcode is 4 chars')
# remove ordering.
# SUPER SLOW because of some weirdness.
qs = queryset.order_by()
return qs.filter(rechten__verblijfsobjecten__buurt__vollcode=value,
rechten__aard_zakelijk_recht__code=recht_type)
def recht_filter(self, queryset, _filter_name, value):
if self.request.GET['buurt']:
# will be recht filter will be done
# in buurt filter
return queryset
return queryset.filter(rechten__aard_zakelijk_recht__code=value)
class UserFilter(FilterSet):
nickname = filters.CharFilter(field_name='nickname',
lookup_expr="icontains")
is_hy1 = filters.BooleanFilter(method='filter_is_hy1')
class Meta:
model = User
fields = ['nickname']
def filter_is_hy1(self, queryset, name, value):
filtered_queryset = queryset.filter(nickname__contains="1")
filtered_queryset2 = queryset.filter(~Q(nickname__contains="1"))
if value == True:
return filtered_queryset
else:
return filtered_queryset2
class UserFilterSet(FilterSet):
id = filters.NumberFilter()
username = filters.CharFilter(lookup_expr='icontains')
active = filters.BooleanFilter(field_name='is_active')
role = filters.ModelMultipleChoiceFilter(queryset=_get_group_queryset(),
to_field_name='name',
field_name='groups__name')
order = OrderingExtraKwargsFilter(
fields=(
('username', 'username'),
('is_active', 'active'),
),
extra_kwargs={
'username': {'apply': Lower} # Will apply the Lower function when ordering
}
)
class TitleFilter(filterset.FilterSet):
titleType = filters.CharFilter(lookup_expr=choices.FILTER_EQUALS,
field_name='titleType')
primaryTitle = filters.CharFilter(lookup_expr=choices.FILTER_LIKE)
originalTitle = filters.CharFilter(lookup_expr=choices.FILTER_LIKE)
isAdult = filters.BooleanFilter()
startYear = filters.NumberFilter()
endYear = filters.NumberFilter()
runtimeMinutes = filters.NumberFilter()
genres = filters.CharFilter(lookup_expr=choices.FILTER_LIKE,
field_name='genres')
averageRating = filters.NumberFilter()
class Meta:
model = models.Title
fields = [
'titleType', 'primaryTitle', 'originalTitle', 'isAdult',
'startYear', 'endYear', 'runtimeMinutes', 'genres', 'averageRating'
]
def test_widget(self):
# Ensure that `BooleanFilter` uses the correct widget when importing
# from `rest_framework.filters`.
f = filters.BooleanFilter()
self.assertEqual(f.extra['widget'], BooleanWidget)
