class BerthApplicationFilter(django_filters.FilterSet):
switch_applications = django_filters.BooleanFilter(
field_name="berth_switch", method="filter_berth_switch")
no_customer = django_filters.BooleanFilter(field_name="customer",
lookup_expr="isnull")
application_code = django_filters.BooleanFilter(
field_name="application_code", method="filter_application_code")
order_by = django_filters.OrderingFilter(
fields=("created_at", ),
label="Supports only `createdAt` and `-createdAt`.",
)
name = django_filters.CharFilter(method="filter_name")
def filter_name(self, qs, name, value):
for part in value.split():
qs = qs.filter(
Q(first_name__icontains=part) | Q(last_name__icontains=part))
return qs
def filter_berth_switch(self, queryset, name, value):
lookup = "__".join([name, "isnull"])
return queryset.filter(**{lookup: not value})
def filter_application_code(self, queryset, name, value):
lookup = "__".join([name, "exact"])
return (queryset.exclude(**{lookup: ""}) if value else queryset.filter(
**{lookup: ""}))
class ItemTypeFilter(django_filters.FilterSet):
o = django_filters.OrderingFilter(
# tuple-mapping retains order
fields=(
('created_at', 'created_at'),
('category', 'category'),
('text', 'text'),
),
# # labels do not need to retain order
# field_labels={
# 'username': '******',
# }
)
# def user_filtering(self, queryset, name, value):
# return queryset.filter(
# Q(user__slug=value)
# )
#
# user = django_filters.CharFilter(method='user_filtering')
class Meta:
model = ItemType
fields = ['is_archived', 'category', 'slug']
class ProductFilter(django_filters.FilterSet):
name = django_filters.CharFilter(method='filter_by_name')
min_price = django_filters.CharFilter(method='filter_from_min_price', label='min_price')
max_price = django_filters.CharFilter(method='filter_until_max_price', label='max_price')
description = django_filters.CharFilter(method='filter_by_description')
ordering = django_filters.OrderingFilter(
fields={
'name': 'name',
'price': 'price'
}
)
class Meta:
model = Product
fields = ('name', 'description')
def filter_by_name(self, queryset, name, value):
return queryset.get_products_by_name(value)
def filter_by_description(self, queryset, name, value):
return queryset.get_products_by_description(value)
def filter_from_min_price(self, queryset, name, value):
return queryset.get_products_price_more_than(value)
def filter_until_max_price(self, queryset, name, value):
return queryset.get_products_price_less_than(value)
class InsuranceRequirementFilter(django_filters.FilterSet):
o = django_filters.OrderingFilter(
# tuple-mapping retains order
fields=(
('id', 'id'),
('text', 'text'),
('description', 'description'),
('is_archived', 'is_archived'),
),
# # labels do not need to retain order
# field_labels={
# 'username': '******',
# }
)
class Meta:
model = InsuranceRequirement
fields = [
# 'id',
# 'title',
# 'is_closed',
# 'type_of',
'is_archived',
]
class BadgeAwardsFilter(AMYFilterSet):
awarded_after = django_filters.DateFilter(field_name='awarded',
lookup_expr='gte')
awarded_before = django_filters.DateFilter(field_name='awarded',
lookup_expr='lte')
event = django_filters.ModelChoiceFilter(
queryset=Event.objects.all(),
label='Event',
widget=ModelSelect2Widget(
data_view='event-lookup',
attrs=SELECT2_SIDEBAR,
),
)
order_by = django_filters.OrderingFilter(fields=(
'awarded',
'person__family',
),
field_labels={
'awarded': 'Awarded date',
'person__family': 'Person',
})
class Meta:
model = Award
fields = (
'awarded_after',
'awarded_before',
'event',
)
class HowHearAboutUsItemFilter(django_filters.FilterSet):
o = django_filters.OrderingFilter(
# tuple-mapping retains order
fields=(
('sort_number', 'sort_number'),
('text', 'text'),
('is_for_associate', 'is_for_associate'),
('is_for_customer', 'is_for_customer'),
('is_for_staff', 'is_for_staff'),
('is_for_partner', 'is_for_partner'),
('is_archived', 'is_archived'),
),
# # labels do not need to retain order
# field_labels={
# 'username': '******',
# }
)
class Meta:
model = HowHearAboutUsItem
fields = [
# 'id',
# 'title',
# 'is_closed',
# 'type_of',
'is_archived',
]
class TeamEventFilterSet(django_filters.FilterSet):
year = django_filters.NumberFilter(method='get_year', field_name='year')
event = django_filters.CharFilter(method='get_event', field_name='event')
team = django_filters.NumberFilter(method='get_team', field_name='team')
o = django_filters.OrderingFilter(fields=(
('time', 'time'),
('team', 'team'),
('year', 'year'),
), )
def get_year(self, queryset, field_name, value):
if value:
return queryset.filter(year=value)
return queryset
def get_event(self, queryset, field_name, value):
if value:
return queryset.filter(event=value)
return queryset
def get_team(self, queryset, field_name, value):
if value:
return queryset.filter(team=value)
return queryset
class Meta:
model = TeamEvent
fields = ['year', 'event', 'team']
class PlaybookFilter(DateFilter):
ansible_version = django_filters.CharFilter(field_name="ansible_version",
lookup_expr="icontains")
controller = django_filters.CharFilter(field_name="controller",
lookup_expr="icontains")
name = django_filters.CharFilter(field_name="name",
lookup_expr="icontains")
path = django_filters.CharFilter(field_name="path",
lookup_expr="icontains")
status = django_filters.MultipleChoiceFilter(
field_name="status",
choices=ara_models.Playbook.STATUS,
lookup_expr="iexact")
label = django_filters.CharFilter(field_name="labels",
lookup_expr="name__iexact")
# fmt: off
order = django_filters.OrderingFilter(fields=(
("id", "id"),
("created", "created"),
("updated", "updated"),
("started", "started"),
("ended", "ended"),
("duration", "duration"),
))
class TeamFilterSet(django_filters.FilterSet):
team = django_filters.NumberFilter(method=get_team, field_name="team")
active = django_filters.NumberFilter(method=get_active,
field_name="active")
state = django_filters.CharFilter(method=get_state, field_name="state")
country = django_filters.CharFilter(method=get_country,
field_name="country")
district = django_filters.CharFilter(method=get_district,
field_name="district")
o = django_filters.OrderingFilter(fields=(
("team", "team"),
("elo", "elo"),
("elo_recent", "elo_recent"),
("elo_mean", "elo_mean"),
("elo_max", "elo_max"),
("wins", "wins"),
("losses", "losses"),
("ties", "ties"),
("winrate", "winrate"),
))
class Meta:
model = Team
fields = ["team", "active", "state", "country", "district"]
class TaskFilter(DateFilter):
playbook = django_filters.NumberFilter(field_name="playbook__id",
lookup_expr="exact")
status = django_filters.MultipleChoiceFilter(
field_name="status",
choices=ara_models.Task.STATUS,
lookup_expr="iexact")
name = django_filters.CharFilter(field_name="name",
lookup_expr="icontains")
action = django_filters.CharFilter(field_name="action",
lookup_expr="iexact")
path = django_filters.CharFilter(field_name="file__path",
lookup_expr="icontains")
handler = django_filters.BooleanFilter(field_name="handler",
lookup_expr="exact")
# fmt: off
order = django_filters.OrderingFilter(fields=(
("id", "id"),
("created", "created"),
("updated", "updated"),
("started", "started"),
("ended", "ended"),
("duration", "duration"),
))
class ResultFilter(DateFilter):
playbook = django_filters.NumberFilter(field_name="playbook__id",
lookup_expr="exact")
task = django_filters.NumberFilter(field_name="task__id",
lookup_expr="exact")
play = django_filters.NumberFilter(field_name="play__id",
lookup_expr="exact")
host = django_filters.NumberFilter(field_name="host__id",
lookup_expr="exact")
changed = django_filters.BooleanFilter(field_name="changed",
lookup_expr="exact")
status = django_filters.MultipleChoiceFilter(
field_name="status",
choices=ara_models.Result.STATUS,
lookup_expr="iexact")
ignore_errors = django_filters.BooleanFilter(field_name="ignore_errors",
lookup_expr="exact")
# fmt: off
order = django_filters.OrderingFilter(fields=(
("id", "id"),
("created", "created"),
("updated", "updated"),
("started", "started"),
("ended", "ended"),
("duration", "duration"),
))
class AwayLogFilter(django_filters.FilterSet):
o = django_filters.OrderingFilter(
# tuple-mapping retains order
fields=(
('id', 'id'),
('associate__indexed_text', 'associate_name'),
('created', 'created'),
('last_modified', 'last_modified'),
('was_deleted', 'was_deleted'),
('start_date', 'start_date'),
('until_date', 'until_date'),
('until_further_notice', 'until_further_notice'),
),
# # labels do not need to retain order
# field_labels={
# 'username': '******',
# }
)
class Meta:
model = AwayLog
fields = [
'id', 'associate', 'associate_id', 'associates', 'created',
'created_by', 'created_by_id', 'last_modified', 'last_modified_by',
'last_modified_by_id', 'reason', 'reason_other', 'start_date',
'until_date', 'until_further_notice', 'was_deleted'
]
class WatchCommentFilter(django_filters.FilterSet):
o = django_filters.OrderingFilter(
# tuple-mapping retains order
fields=(
('id', 'id'),
('comment__text', 'text'),
('watch', 'watch'),
('created_at', 'created_at'),
),
# # labels do not need to retain order
# field_labels={
# 'username': '******',
# }
)
def watch_filtering(self, queryset, name, value):
return queryset.filter(watch__slug=value)
# return queryset.filter(
# Q(contact__last_name__icontains=value) |
# Q(contact__last_name__istartswith=value) |
# Q(contact__last_name__iendswith=value) |
# Q(contact__last_name__exact=value) |
# Q(contact__last_name__icontains=value)
# )
watch = django_filters.CharFilter(method='watch_filtering')
class Meta:
model = WatchComment
fields = [
'watch',
'created_at',
]
class AdvertFilterSet(df.FilterSet):
"""Filters for Advert object"""
user = df.NumberFilter(field_name='user__id')
title = df.CharFilter(field_name='title', lookup_expr='icontains')
category = df.NumberFilter(field_name='category__id',
method='category_filter')
price__gte = df.NumberFilter(field_name='price', lookup_expr='gte')
price__lte = df.NumberFilter(field_name='price', lookup_expr='lte')
location = df.NumberFilter(field_name='location__id')
ordering = df.OrderingFilter(fields=(('price', 'price'), ('date_refreshed',
'date')))
def category_filter(self, queryset, name, value):
"""Category filter to include child categories in results"""
criteria = \
Q(category__id=value) | \
Q(category__parent__id=value) | \
Q(category__parent__parent__id=value) | \
Q(category__parent__parent__parent__id=value)
# query = queryset.filter(criteria).query
return queryset.filter(criteria)
class PartnerFilter(django_filters.FilterSet):
text_search = django_filters.CharFilter(method='my_text_search', label="Arama", widget=forms.TextInput(attrs={'placeholder': 'Ara...', 'class': ' form-control custom-shadow custom-radius bg-white'}))
sort = django_filters.OrderingFilter(
fields=(
('first_name', 'first_name'),
),
field_labels={
'first_name': 'Ada Göre',
'-first_name': 'Ada Göre (azalan)',
},
)
class Meta:
model = Partner
fields = ['text_search',"sort"]
def __init__(self,data=None, queryset=None, *, request=None, prefix=None):
super(PartnerFilter, self).__init__(data=data, queryset=queryset, request=request, prefix=prefix)
self.filters['text_search'].field.widget.attrs.update({'class': ' form-control'})
self.filters['sort'].field.widget.attrs.update({'class': ' custom-select custom-select-set form-control bg-white custom-shadow custom-radius'})
self.filters["sort"].field.empty_label = "Sırala"
def my_text_search(self, queryset, name, value):
return Partner.objects.filter(
Q(first_name__icontains=value) | Q(last_name__icontains=value) |
Q(email__icontains=value) | Q(phone__icontains=value) |
Q(city__name__icontains=value) | Q(district__name__icontains=value) |
Q(description__icontains=value)
)
class OfferingUserFilter(OfferingFilterMixin, django_filters.FilterSet):
user_uuid = django_filters.UUIDFilter(field_name='user__uuid')
o = django_filters.OrderingFilter(fields=('created', ))
class Meta:
model = models.OfferingUser
fields = []
class JournalIssueFilter(django_filters.FilterSet):
journalissue_title_text = django_filters.CharFilter(label=FieldJournalIssue.TITLE, lookup_expr='icontains', widget=forms.TextInput(attrs={'class': 'list__form--input'}))
journalissue_publisher = django_filters.ModelChoiceFilter(label=FieldJournalIssue.PUBLISHERS,
queryset=Institution.objects.all(),
widget=autocomplete.ModelSelect2(url='institution-autocomplete'))
journalissue_category = django_filters.ModelMultipleChoiceFilter(label=FieldJournalIssue.CATEGORY,
queryset=PublicationCategory.objects.all(),
widget=autocomplete.ModelSelect2Multiple(url='publicationcategory-autocomplete'))
journalissue_journal = django_filters.ModelMultipleChoiceFilter(label=FieldJournalIssue.JOURNAL,
queryset=Journal.objects.all(),
widget=autocomplete.ModelSelect2Multiple(url='journal-autocomplete'))
journalissue_publication_date = django_filters.DateFilter(label=FieldJournalIssue.PUBLICATION_DATE, lookup_expr='exact', widget=forms.DateTimeInput(attrs={'class': 'datepicker list__form--input'}))
journalissue_keywords = django_filters.ModelMultipleChoiceFilter(label=FieldJournalIssue.KEYWORDS,
queryset=Tag.objects.all(),
widget=autocomplete.ModelSelect2Multiple(url='tag-autocomplete'))
journalissue_is_accepted = django_filters.BooleanFilter(label=FieldJournalIssue.IS_ACCEPTED,
widget=NullBooleanSelect(attrs={'class': 'select2'}))
o = django_filters.OrderingFilter(
fields=(
('journalissue_is_promoted', 'journalissue_is_promoted'),
('journalissue_date_add', 'journalissue_date_add'),
('journalissue_title_text', 'journalissue_title_text'),
),
)
strict = True
class Meta:
model = JournalIssue
form = JournalIssueFilterForm
fields = ['journalissue_title_text', 'journalissue_publisher',
'journalissue_category', 'journalissue_publication_date',
'journalissue_keywords', 'journalissue_is_accepted']
class HostFilter(BaseFilter):
playbook = django_filters.NumberFilter(field_name="playbook__id", lookup_expr="exact")
name = django_filters.CharFilter(field_name="name", lookup_expr="icontains")
# For example: /api/v1/hosts/failed__gt=0 to return hosts with 1 failure or more
changed__gt = django_filters.NumberFilter(field_name="changed", lookup_expr="gt")
changed__lt = django_filters.NumberFilter(field_name="changed", lookup_expr="lt")
failed__gt = django_filters.NumberFilter(field_name="failed", lookup_expr="gt")
failed__lt = django_filters.NumberFilter(field_name="failed", lookup_expr="lt")
ok__gt = django_filters.NumberFilter(field_name="ok", lookup_expr="gt")
ok__lt = django_filters.NumberFilter(field_name="ok", lookup_expr="lt")
skipped__gt = django_filters.NumberFilter(field_name="skipped", lookup_expr="gt")
skipped__lt = django_filters.NumberFilter(field_name="skipped", lookup_expr="lt")
unreachable__gt = django_filters.NumberFilter(field_name="unreachable", lookup_expr="gt")
unreachable__lt = django_filters.NumberFilter(field_name="unreachable", lookup_expr="lt")
# fmt: off
order = django_filters.OrderingFilter(
fields=(
("id", "id"),
("created", "created"),
("updated", "updated"),
("name", "name"),
("changed", "changed"),
("failed", "failed"),
("ok", "ok"),
("skipped", "skipped"),
("unreachable", "unreachable"),
)
)
class EventFilterSet(django_filters.FilterSet):
event = django_filters.CharFilter(method='get_event', field_name='event')
year = django_filters.NumberFilter(method='get_year', field_name='year')
o = django_filters.OrderingFilter(fields=(
('year', 'year'),
('elo_max', 'elo_max'),
('elo_top8', 'elo_top8'),
('elo_top24', 'elo_top24'),
('elo_mean', 'elo_mean'),
), )
def get_event(self, queryset, field_name, value):
if value:
return queryset.filter(event=value)
return queryset
def get_year(self, queryset, field_name, value):
if value:
return queryset.filter(year=value)
return queryset
class Meta:
model = Event
fields = ['event', 'year']
class DistinctHostFilter(BaseFilter):
playbook = django_filters.NumberFilter(field_name="latest__playbook__id", lookup_expr="exact")
name = django_filters.CharFilter(field_name="latest__name", lookup_expr="icontains")
changed__gt = django_filters.NumberFilter(field_name="latest__changed", lookup_expr="gt")
changed__lt = django_filters.NumberFilter(field_name="latest__changed", lookup_expr="lt")
failed__gt = django_filters.NumberFilter(field_name="latest__failed", lookup_expr="gt")
failed__lt = django_filters.NumberFilter(field_name="latest__failed", lookup_expr="lt")
ok__gt = django_filters.NumberFilter(field_name="latest__ok", lookup_expr="gt")
ok__lt = django_filters.NumberFilter(field_name="latest__ok", lookup_expr="lt")
skipped__gt = django_filters.NumberFilter(field_name="latest__skipped", lookup_expr="gt")
skipped__lt = django_filters.NumberFilter(field_name="latest__skipped", lookup_expr="lt")
unreachable__gt = django_filters.NumberFilter(field_name="latest__unreachable", lookup_expr="gt")
unreachable__lt = django_filters.NumberFilter(field_name="latest__unreachable", lookup_expr="lt")
# fmt: off
order = django_filters.OrderingFilter(
fields=(
("id", "id"),
("created", "created"),
("updated", "updated"),
("name", "name"),
("changed", "changed"),
("failed", "failed"),
("ok", "ok"),
("skipped", "skipped"),
("unreachable", "unreachable"),
)
)
class AwardFilter(django_filters.FilterSet):
o = django_filters.OrderingFilter(
# tuple-mapping retains order
fields=(
('created_at', 'created_at'),
('type_of', 'type_of'),
('user', 'user'),
),
# # labels do not need to retain order
# field_labels={
# 'username': '******',
# }
)
def user_filtering(self, queryset, name, value):
return queryset.filter(Q(user__slug=value))
user = django_filters.CharFilter(method='user_filtering')
class Meta:
model = Award
fields = [
'user',
'is_archived',
'type_of',
]
class UserFilter(django_filters.FilterSet):
full_name = django_filters.CharFilter(lookup_expr='icontains')
username = django_filters.CharFilter()
native_name = django_filters.CharFilter(lookup_expr='icontains')
job_title = django_filters.CharFilter(lookup_expr='icontains')
email = django_filters.CharFilter(lookup_expr='icontains')
is_active = django_filters.BooleanFilter()
o = django_filters.OrderingFilter(
fields=('full_name', 'native_name', 'organization',
'organization_approved', 'email', 'phone_number',
'description', 'job_title', 'username', 'is_active',
'registration_method'))
class Meta(object):
model = User
fields = [
'full_name',
'native_name',
'organization',
'organization_approved',
'email',
'phone_number',
'description',
'job_title',
'username',
'civil_number',
'is_active',
'registration_method',
]
class TaskFilter(AMYFilterSet):
event = django_filters.ModelChoiceFilter(
queryset=Event.objects.all(),
label='Event',
widget=ModelSelect2Widget(
data_view='event-lookup',
attrs=SELECT2_SIDEBAR,
),
)
order_by = django_filters.OrderingFilter(fields=(
('event__slug', 'event'),
('person__family', 'person'),
('role', 'role'),
),
field_labels={
'event__slug': 'Event',
'person__family': 'Person',
'role': 'Role',
})
class Meta:
model = Task
fields = [
'event',
# can't filter on person because person's name contains 3 fields:
# person.personal, person.middle, person.family
# 'person',
'role',
]
class UserPermissionFilter(django_filters.FilterSet):
user = django_filters.UUIDFilter(name='user__uuid')
user_url = core_filters.URLFilter(
view_name='user-detail',
name='user__uuid',
)
username = django_filters.CharFilter(
name='user__username',
lookup_expr='exact',
)
full_name = django_filters.CharFilter(
name='user__full_name',
lookup_expr='icontains',
)
native_name = django_filters.CharFilter(
name='user__native_name',
lookup_expr='icontains',
)
o = django_filters.OrderingFilter(fields=(
('user__username', 'username'),
('user__full_name', 'full_name'),
('user__native_name', 'native_name'),
('user__email', 'email'),
('expiration_time', 'expiration_time'),
('created', 'created'),
('role', 'role'),
))
class UserCaseFilter(CrispyFilterMixin, CaseFilterMixin, django_filters.FilterSet):
def __init__(self, *args, **kwargs):
kwargs["queryset"] = kwargs.pop("queryset").order_by(
"-%s" % (Case.USER_ORDER_DEFAULT_FIELD)
)
super().__init__(*args, **kwargs)
name = django_filters.CharFilter(label=_("Subject"), lookup_expr="icontains")
created_on = django_filters.DateRangeFilter(label=_("Created on"))
last_send = django_filters.DateRangeFilter(label=_("Last send"))
o = django_filters.OrderingFilter(
fields=["last_send", "pk", "created_on"],
help_text=None,
initial="last_send",
field_labels={
"last_send": _("Last send"),
"pk": _("ID"),
"created_on": _("Created on"),
},
)
class Meta:
model = Case
fields = ["name", "created_on", "last_send"]
order_by_field = "last_send"
class EventRequestFilter(AMYFilterSet):
assigned_to = ForeignKeyAllValuesFilter(Person)
country = AllCountriesFilter()
active = django_filters.ChoiceFilter(
choices=(('all', 'All'), ('true', 'Open'), ('false', 'Closed')),
label='Status',
method=filter_active_eventrequest,
widget=widgets.RadioSelect,
)
workshop_type = django_filters.ChoiceFilter(
choices=(('', 'All'), ('swc', 'Software-Carpentry'),
('dc', 'Data-Carpentry')),
label='Workshop type',
widget=widgets.RadioSelect,
)
order_by = django_filters.OrderingFilter(fields=('created_at', ), )
class Meta:
model = EventRequest
fields = [
'assigned_to',
'workshop_type',
'active',
'country',
]
class TaskItemFilter(django_filters.FilterSet):
id = django_filters.AllValuesMultipleFilter(
name="id",
label="ID",
)
title = django_filters.AllValuesMultipleFilter(
name="title",
label="Title",
)
o = django_filters.OrderingFilter(
# tuple-mapping retains order
fields=(
('due_date', 'due_date'),
('title', 'title'),
('type_of', 'type_of'),
('job__customer__indexed_text', 'customer_name'),
('job__associate__indexed_text', 'associate_name'),
),
# # labels do not need to retain order
# field_labels={
# 'username': '******',
# }
)
class Meta:
model = TaskItem
fields = [
'id',
'title',
'is_closed',
'type_of',
]
class MembershipFilter(AMYFilterSet):
organization_name = django_filters.CharFilter(
label='Organization name',
field_name='organization__fullname',
lookup_expr='icontains',
)
MEMBERSHIP_CHOICES = (('', 'Any'), ) + Membership.MEMBERSHIP_CHOICES
variant = django_filters.ChoiceFilter(choices=MEMBERSHIP_CHOICES)
CONTRIBUTION_CHOICES = (('', 'Any'), ) + Membership.CONTRIBUTION_CHOICES
contribution_type = django_filters.ChoiceFilter(
choices=CONTRIBUTION_CHOICES)
order_by = django_filters.OrderingFilter(fields=(
'organization__fullname',
'organization__domain',
'agreement_start',
'agreement_end',
), )
class Meta:
model = Membership
fields = [
'organization_name',
'variant',
'contribution_type',
]
class WorkOrderFilter(django_filters.FilterSet):
o = django_filters.OrderingFilter(
# tuple-mapping retains order
fields=(
('id', 'id'),
('customer__indexed_text', 'customer_name'),
('associate__indexed_text', 'associate_name'),
('customer__type_of', 'type_of'),
('assignment_date', 'assignment_date'),
('start_date', 'start_date'),
('completion_date', 'completion_date'),
('state', 'state'),
),
# # labels do not need to retain order
# field_labels={
# 'username': '******',
# }
)
class Meta:
model = WorkOrder
fields = [
'customer',
'state',
]
class TestFilter(filters.FilterSet):
is_passed = filters.BooleanFilter(field_name='results',
label='Is passed',
method='filter_passed')
name = filters.CharFilter(field_name='name',
label='Search by name',
method='search_by_name')
ordering = filters.OrderingFilter(fields=(('created', 'created'), ),
field_labels={
'created': 'Date Created',
})
def search_by_name(self, queryset, name, value):
lookup = '__'.join([name, 'icontains'])
return queryset.filter(**{lookup: value})
def filter_passed(self, queryset, name, value):
user = getattr(self.request, 'user', None)
if user:
if value is not None:
lookup = '__'.join([name, 'user', 'exact'])
if value:
return queryset.filter(**{lookup: user})
else:
return queryset.filter(~Q(**{lookup: user}))
return queryset
class Meta:
model = Test
fields = ['is_passed', 'name']
