class QuestionListFilter(FilterSet):
class Meta:
model = Question
fields = ["category", "author", "is_reviewed", "is_flagged"]
author = ModelChoiceFilter(queryset=User.objects.filter(
id__in=Question.objects.select_related("author").order_by(
"author").distinct("author").values_list("author", flat=True)))
answered = BooleanFilter(field_name="answered",
label="Is answered",
method="filter_answered",
widget=CustomBooleanWidget)
is_reviewed = BooleanFilter(field_name="is_reviewed",
label="Is reviewed",
widget=CustomBooleanWidget)
is_flagged = BooleanFilter(field_name="is_flagged",
label="Is flagged",
widget=CustomBooleanWidget)
def filter_answered(self, queryset, name, value):
if self.request:
user = self.request.user
history, created = History.objects.get_or_create(
user=user) # force init of history
if value is True:
queryset = queryset.filter(id__in=history.answered_questions())
elif value is False:
queryset = queryset.exclude(
id__in=history.answered_questions())
else: # None
queryset = queryset
return queryset
class UserFilter(FilterSet):
"""Filter that shows all users with/without 'can_supervise' permission"""
is_approved_supervisor = BooleanFilter(method='filter_approved_supervisor')
is_course_convener = BooleanFilter(method='filter_course_convener')
class Meta:
model = SrpmsUser
fields = []
# noinspection PyMethodMayBeStatic
def filter_approved_supervisor(self, queryset: QuerySet, name,
value: bool):
"""
Filter function.
Note that user being inside a group (with certain permission assigned to the group)
would not automatically assign user to a Permission object. Thus we refer the method
[here](https://stackoverflow.com/questions/378303/how-to-get-a-list-of-all-users-with-a-specific-permission-group-in-django)
to query user given a permission.
Args:
queryset: the queryset of the view
name: field name to apply the filter
value: value that would be used to filter the query set
"""
perm = Permission.objects.get(codename='can_supervise')
if value:
q = Q(groups__permissions=perm) | Q(user_permissions=perm) | Q(
is_superuser=True)
return queryset.filter(q).distinct()
else:
q = ~Q(groups__permissions=perm) & ~Q(user_permissions=perm) & Q(
is_superuser=False)
return queryset.filter(q).distinct()
# noinspection PyMethodMayBeStatic
def filter_course_convener(self, queryset: QuerySet, name, value: bool):
"""
Filter uses with 'can_convene' permission
Args:
queryset: the queryset of the view
name: field name to apply the filter
value: value that would be used to filter the query set
"""
perm = Permission.objects.get(codename='can_convene')
if value:
q = Q(groups__permissions=perm) | Q(user_permissions=perm) | Q(
is_superuser=True)
return queryset.filter(q).distinct()
else:
q = ~Q(groups__permissions=perm) & ~Q(user_permissions=perm) & Q(
is_superuser=False)
return queryset.filter(q).distinct()
class PaymentMethodFilter(FilterSet):
processor = CharFilter(name='payment_processor', lookup_expr='iexact')
canceled = BooleanFilter(name='canceled')
verified = BooleanFilter(name='verified')
class Meta:
model = PaymentMethod
fields = ['processor', 'canceled', 'verified']
class PaymentFilter(FilterSet):
is_overdue = BooleanFilter(name='overdue', lookup_type='exact')
visible = BooleanFilter(name='visible', lookup_type='exact')
status = CharFilter(name='status', lookup_type='exact')
class Meta:
model = Payment
fields = ['is_overdue', 'visible', 'status']
class ProfileFilter(FilterSet):
class Meta:
model = Profile
fields = (
"first_name",
"last_name",
"nickname",
"emails__email",
"emails__email_type",
"emails__primary",
"emails__verified",
"phones__phone",
"phones__phone_type",
"phones__primary",
"addresses__address",
"addresses__postal_code",
"addresses__city",
"addresses__country_code",
"addresses__address_type",
"addresses__primary",
"language",
"enabled_subscriptions",
)
first_name = CharFilter(lookup_expr="icontains")
last_name = CharFilter(lookup_expr="icontains")
nickname = CharFilter(lookup_expr="icontains")
emails__email = CharFilter(lookup_expr="icontains")
emails__email_type = ChoiceFilter(choices=EmailType.choices())
emails__primary = BooleanFilter()
emails__verified = BooleanFilter()
phones__phone = CharFilter(lookup_expr="icontains")
phones__phone_type = ChoiceFilter(choices=PhoneType.choices())
phones__primary = BooleanFilter()
addresses__address = CharFilter(lookup_expr="icontains")
addresses__postal_code = CharFilter(lookup_expr="icontains")
addresses__city = CharFilter(lookup_expr="icontains")
addresses__country_code = CharFilter(lookup_expr="icontains")
addresses__address_type = ChoiceFilter(choices=AddressType.choices())
addresses__primary = BooleanFilter()
language = CharFilter()
enabled_subscriptions = CharFilter(method="get_enabled_subscriptions")
order_by = PrimaryContactInfoOrderingFilter(fields=(
("first_name", "firstName"),
("last_name", "lastName"),
("nickname", "nickname"),
("language", "language"),
))
def get_enabled_subscriptions(self, queryset, name, value):
"""
Custom filter to join the enabled of subscription with subscription type correctly
"""
return queryset.filter(subscriptions__enabled=True,
subscriptions__subscription_type__code=value)
class ViewFilter(Filterset):
title = CharFilter(name='title')
addressCity = CharFilter(name='address_city')
addressGu = CharFilter(name='address_gu')
recruitStatus = BooleanFilter(name='recruit_status')
adultStatus = BooleanFilter(name='adult_status')
class Meta:
model = Post
fields = [
'title', 'addressCity', 'addressGu', 'recruitStatus', 'adultstatus'
]
class UserFilter(django_filters.FilterSet):
username = Filter(field_name='username', lookup_expr='icontains')
admin = BooleanFilter(field_name='admin')
active = BooleanFilter(field_name='active')
staff = BooleanFilter(field_name='staff')
timestamp = DateRangeFilter(field_name='timestamp',
lookup_expr="gte",
label="Bu Tarihten Sonraki")
class Meta:
model = User
fields = ['username', 'admin', 'staff', 'active', 'timestamp']
exclude = ['username', 'admin', 'staff', 'active', 'timestamp']
class PlanFilter(FilterSet):
name = CharFilter(name='name', lookup_type='icontains')
currency = CharFilter(name='currency', lookup_type='icontains')
enabled = BooleanFilter(name='enabled', lookup_type='iexact')
private = BooleanFilter(name='private', lookup_type='iexact')
interval = CharFilter(name='interval', lookup_type='icontains')
product_code = CharFilter(name='product_code', lookup_type='icontains')
provider = CharFilter(name='provider__company', lookup_type='icontains')
class Meta:
model = Plan
fields = ['name', 'currency', 'enabled', 'private', 'product_code',
'provider', 'interval']
class UserFilter(FilterSet):
class Meta:
model = User
fields = ['email', 'username', 'first_name', 'last_name', 'is_manager', 'is_staff', 'is_superuser', 'is_active',
'created']
email = CharFilter(label="Email contient", lookup_expr='icontains')
first_name = CharFilter(lookup_expr='icontains')
last_name = CharFilter(lookup_expr='icontains')
username = CharFilter(label="Username", lookup_expr='icontains')
created = DateTimeFilter(label="Cree le", lookup_expr="icontains")
is_superuser = BooleanFilter(label="Admin", widget=BooleanWidget())
is_manager = BooleanFilter(label="Chef de Projet", widget=BooleanWidget())
is_active = BooleanFilter(label="Active", widget=BooleanWidget())
is_staff = BooleanFilter(label="Staff", widget=BooleanWidget())
class EventFilter(FilterSet):
isPossibleInside = BooleanFilter(field_name='isPossibleInside')
isPossibleOutside = BooleanFilter(field_name='isPossibleOutside')
isPossibleDigital = BooleanFilter(field_name='isPossibleDigital')
isPossibleAlone = BooleanFilter(field_name='isPossibleAlone')
isPrepairationNeeded = BooleanFilter(field_name='isPrepairationNeeded')
isActive = BooleanFilter(field_name='isActive', method='get_isActive')
withoutCosts = BooleanFilter(method='get_CostRating',
field_name='costsRating')
filterTags = ModelMultipleChoiceFilter(field_name='tags__id',
to_field_name='id',
queryset=Tag.objects.all(),
method='get_tags')
isLvlOne = BooleanFilter(field_name='isLvlOne')
isLvlTwo = BooleanFilter(field_name='isLvlTwo')
isLvlThree = BooleanFilter(field_name='isLvlThree')
class Meta:
model = Event
fields = [
'isPossibleInside', 'isPossibleOutside', 'isPossibleAlone',
'isPossibleDigital', 'isPrepairationNeeded', 'isActive',
'withoutCosts', 'filterTags', 'isLvlOne', 'isLvlTwo', 'isLvlThree'
]
def get_CostRating(self, queryset, field_name, value):
if value:
return queryset.filter(costsRating=0)
return queryset
def get_isActive(self, queryset, field_name, value):
if not value:
if self.request.user.is_authenticated:
return queryset.filter(isActive=value)
return queryset.filter(isActive=True)
def get_tags(self, queryset, field_name, value):
tags_category = dict()
for val in value:
tags_category.setdefault(str(val.category.id), []).append(val.id)
for filter_elements in tags_category:
queryset = queryset.filter(
tags__id__in=tags_category[filter_elements]).distinct()
return queryset
class event(FilterSet):
def __init__(self, *args, **kwargs):
if not event_choices['level'] and kwargs['queryset'].count():
update_choices()
super().__init__(*args, **kwargs)
for attribute in event_choices:
self.filters[attribute].extra.update(
choices=event_choices[attribute])
self.filters[attribute].widget.attrs['size'] = min(
len(event_choices[attribute]), 50)
description = CharFilter(
label='Description', lookup_expr='icontains',
widget=Textarea(attrs={'class': 'form-control', 'rows': 3}),
help_text='')
type = MultipleChoiceFilter(
label='Type',
widget=SelectMultiple(attrs={'class': 'form-control'}), help_text='')
level = MultipleChoiceFilter(
label='Level',
widget=SelectMultiple(attrs={'class': 'form-control'}), help_text='')
source = MultipleChoiceFilter(
label='Source',
widget=SelectMultiple(attrs={'class': 'form-control'}), help_text='')
success = BooleanFilter(
label='Success',
widget=Select(choices=(('3', 'Unknown'), ('1', 'True'), ('0', 'False')),
attrs={'class': 'form-control'}), help_text='')
class Meta:
exclude = ('campaign', 'result', 'timestamp')
model = models.event
class ScheduleFilter(FilterSet):
is_active = BooleanFilter(label=_('is active'), method='is_active_filter')
class Meta:
model = Schedule
fields = {
'owner': ['exact'],
'name': ['exact', 'icontains'],
'url': ['exact', 'icontains'],
'trillians': ['contains'],
'start': ['gte', 'lte'],
'end': ['gte', 'lte', 'isnull'],
'frequency': ['exact'],
'is_public': ['exact'],
}
# noinspection PyUnusedLocal
def is_active_filter(self, queryset, name, value):
now = timezone.now()
started_before_today = Q(start__lt=now.date())
started_today = Q(start=now.date(), time__lt=now.time())
started = started_before_today | started_today
ended_before_today = Q(end__lt=now.date())
ended_today = Q(end=now.date(), time__lt=now.time())
ended = ended_before_today | ended_today
if value is True:
return queryset.filter(started & ~ended)
elif value is False:
return queryset.filter(~started | ended)
# We shouldn't get here
return queryset
class ProductionOrderFilter(django_filters.FilterSet):
customer = ModelChoiceFilter(label='Klient', queryset=Customer.objects.all())
order = CharFilter(field_name='order', label='Zamówienie nr', lookup_expr='icontains')
settlement = BooleanFilter(field_name='settlement', label="Rozliczenie")
date = DateFilter(
field_name='date',
label='Data',
lookup_expr='icontains',
input_formats=settings.DATE_INPUT_FORMATS,)
date_start = DateFilter(
field_name='date',
label='Data od:',
input_formats=settings.DATE_INPUT_FORMATS,
lookup_expr='gte'
)
date_end = DateFilter(
field_name='date',
label='Data do:',
input_formats=settings.DATE_INPUT_FORMATS,
lookup_expr='lte'
)
class Meta:
model = ProductionOrder
exclude = ['attachments']
class ProductDetailFilter(FilterSet):
search = CharFilter(method='filter_search')
monitored = BooleanFilter(method='filter_monitored')
def filter_search(self, queryset, name, value):
return queryset.filter(
Q(vendor__name__icontains=value) | Q(name__icontains=value))
def filter_monitored(self, queryset, name, value):
return queryset.filter(monitored=value)
sorted_by = OrderingFilter(
# tuple-mapping retains order
choices=(
('vendor__name', _('Vendor')),
('-vendor__name', _('Vendor (Desc)')),
('name', _('Product Name')),
('-name', _('Product Name (Desc)')),
('monitored', _('Monitored')),
('-monitored', _('Monitored (desc)')),
))
class Meta:
model = Product
fields = {
'name': ['icontains'],
'vendor__name': ['icontains'],
'monitored': ['exact'],
}
class TasksFilter(FilterSet):
label = ChoiceFilter(
method='filter_by_label',
label=gettext_lazy('Label'),
)
self_tasks = BooleanFilter(
method='filter_by_author',
label=gettext_lazy('Only my tasks'),
widget=CheckboxInput,
)
def filter_by_author(self, queryset, name, value):
if value:
return queryset.filter(author=self.request.user)
return queryset
def filter_by_label(self, queryset, name, value):
if value:
return queryset.filter(labels__id=value)
return queryset
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.filters['status'].label = gettext('Status')
self.filters['executor'].label = gettext('Executor')
# Load "label" choices in __init__ method.
# That way they will be loaded lazily.
self.filters['label'].extra['choices'] = (
(label.id, label.name) for label in Label.objects.all())
class Meta:
model = Task
fields = ['status', 'executor', 'label', 'self_tasks']
class BillingDocumentFilter(FilterSet):
state = CharFilter(name='state', lookup_type='iexact')
number = NumberFilter(name='number', lookup_type='iexact')
customer_name = CharFilter(name='customer__name', lookup_type='icontains')
customer_company = CharFilter(name='customer__company',
lookup_type='icontains')
provider_name = CharFilter(name='provider__name', lookup_type='icontains')
provider_company = CharFilter(name='provider__company',
lookup_type='icontains')
issue_date = DateFilter(name='issue_date', lookup_type='iexact')
due_date = DateFilter(name='due_date', lookup_type='iexact')
paid_date = DateFilter(name='due_date', lookup_type='iexact')
cancel_date = DateFilter(name='cancel_date', lookup_type='iexact')
currency = CharFilter(name='currency', lookup_type='icontains')
sales_tax_name = CharFilter(name='sales_tax_name', lookup_type='icontains')
is_overdue = BooleanFilter(name='overdue', method='filter_is_overdue')
def filter_is_overdue(self, queryset, _, value):
if value:
return queryset.overdue()
return queryset.not_overdue()
class Meta:
fields = ['state', 'number', 'customer_name', 'customer_company',
'issue_date', 'due_date', 'paid_date', 'cancel_date',
'currency', 'sales_tax_name', 'is_overdue']
class Filter(FilterSet):
is_own = BooleanFilter(
method='user_owns_object',
label=_('Mine'),
widget=forms.CheckboxInput())
class Meta:
model = SamplingEventDevice
fields = {
'created_by__username': ['icontains'],
'created_by__first_name': ['icontains'],
'created_by__last_name': ['icontains'],
'collection_device__physical_device': ['exact'],
'collection_device__physical_device__device__brand__name': ['icontains'],
'collection_device__physical_device__device__model': ['icontains'],
'collection_device__physical_device__device__device_type': ['exact'],
'created_on': ['gt', 'lt'],
'collection_device': ['exact'],
}
def user_owns_object(self, queryset, name, value):
if value:
user = self.request.user
return queryset.filter(collection_device__created_by=user)
return queryset
class PropertyBooleanFilterSet(PropertyFilterSet):
is_true = BooleanFilter(field_name='is_true', lookup_expr=lookup_xpr)
prop_is_true = PropertyBooleanFilter(field_name='prop_is_true', lookup_expr=lookup_xpr)
class Meta:
model = BooleanFilterModel
fields = ['prop_is_true']
class EmailFilter(filters.FilterSet):
date = DateTimeFromToRangeFilter()
sent = BooleanFilter(field_name='sent_date', lookup_expr='isnull', exclude=True, label="Email Sent?")
class Meta:
model = Email
fields = ['date', 'sent_date', 'sent']
class SearchFilter(FilterSet):
name = CharFilter(field_name="name", method="search_name")
comments = CharFilter(method="in_consultation")
affects = CharFilter(field_name="ages", lookup_expr="icontains")
screen = YesNoFilter(field_name="recommendation")
archived = BooleanFilter(method="include_archived",
widget=forms.CheckboxInput)
def search_name(self, queryset, name, value):
return queryset.search(value)
def in_consultation(self, queryset, name, value):
if value == SearchForm.CONSULTATION.open:
return queryset.open_for_comments()
elif value == SearchForm.CONSULTATION.closed:
return queryset.closed_for_comments()
else:
return queryset
def include_archived(self, queryset, name, value):
if value:
return queryset
else:
return queryset.exclude_archived()
class ObrasUsuariosFilterSet(FilterSet):
id_obra = NumberFilter(field_name='obra__id')
id_usuario = NumberFilter(field_name='usuario__id')
obra_pedido = NumberFilter(field_name='obra__pedido')
obra_data_lancamento__gte = DateFilter(field_name='obra__data_lancamento',
lookup_expr='gte')
obra_data_lancamento__lte = DateFilter(field_name='obra__data_lancamento',
lookup_expr='lte')
obra_data_inicio__gte = DateFilter(field_name='obra__data_inicio',
lookup_expr='gte')
obra_data_inicio__lte = DateFilter(field_name='obra__data_inicio',
lookup_expr='lte')
obra_data_final__gte = DateFilter(field_name='obra__data_final',
lookup_expr='gte')
obra_data_final__lte = DateFilter(field_name='obra__data_final',
lookup_expr='lte')
usuario_cpf = CharFilter(field_name='usuario__cpf')
usuario_matricula = NumberFilter(field_name='usuario__matricula')
encarregado = BooleanFilter(field_name='encarregado')
class Meta:
model = ObrasUsuarios
fields = ('id', 'encarregado')
class Filter(FilterSet):
is_own = BooleanFilter(method='user_owns_object',
label=_('Mine'),
widget=forms.CheckboxInput())
class Meta:
model = CollectionSite
fields = {
'created_by': ['exact'],
'created_by__username': ['icontains'],
'created_by__first_name': ['icontains'],
'created_by__last_name': ['icontains'],
'site_type': ['exact'],
'site__altitude': ['gt', 'lt'],
'site__latitude': ['gt', 'lt'],
'site__longitude': ['gt', 'lt'],
'site__name': ['icontains'],
'site__locality': ['icontains'],
'created_on': ['gt', 'lt']
}
def user_owns_object(self, queryset, name, value):
if value:
user = self.request.user
return queryset.filter(created_by=user)
return queryset
class PackageFilter(FilterSet):
type = CharFilter(method='filter_type')
monitored = BooleanFilter(method='filter_monitored')
def filter_type(self, queryset, name, value):
return queryset.filter(type__name=value)
def filter_monitored(self, queryset, name, value):
return queryset.filter(monitored=value)
sorted_by = OrderingFilter(choices=(
('name', _('Package Name')),
('-name', _('Package Name (Desc)')),
('type', _('Package Type')),
('-type', _('Package Type (Desc)')),
('monitored', _('Monitored')),
('-monitored', _('Monitored (desc)')),
))
class Meta:
model = Package
fields = {
'name': ['icontains', 'exact'],
'monitored': ['exact'],
}
class AllFiltersFilterSet(FilterSet):
number_AllValuesFilter = AllValuesFilter(field_name='number', lookup_expr='exact')
number_AllValuesMultipleFilter_OR = AllValuesMultipleFilter(field_name='number', lookup_expr='exact', conjoined=False) # OR
number_AllValuesMultipleFilter_AND = AllValuesMultipleFilter(field_name='number', lookup_expr='exact', conjoined=True) # AND
number_BaseCSVFilterNumber = BaseCSVFilterNumber(field_name='number', lookup_expr='in')
number_BaseInFilterNumber = BaseInFilterNumber(field_name='number', lookup_expr='in')
number_BaseRangeFilterNumber = BaseRangeFilterNumber(field_name='number', lookup_expr='range')
is_true_BooleanFilter = BooleanFilter(field_name='is_true', lookup_expr='exact')
text_CharFilter = CharFilter(field_name='text', lookup_expr='exact')
number_ChoiceFilter = ChoiceFilter(field_name='number', lookup_expr='exact', choices=NUMBER_CHOICES)
date_DateFilter = DateFilter(field_name='date', lookup_expr='exact')
date_DateFromToRangeFilter = DateFromToRangeFilter(field_name='date', lookup_expr='range')
date_DateRangeFilter = DateRangeFilter(field_name='date', lookup_expr='exact')
date_time_DateTimeFilter = DateTimeFilter(field_name='date_time', lookup_expr='exact')
date_time_DateTimeFromToRangeFilter = DateTimeFromToRangeFilter(field_name='date_time', lookup_expr='range')
duration_DurationFilter = DurationFilter(field_name='duration', lookup_expr='exact')
iso_date_time_IsoDateTimeFilter = IsoDateTimeFilter(field_name='iso_date_time', lookup_expr='lt')
iso_date_time_IsoDateTimeFromToRangeFilter = IsoDateTimeFromToRangeFilter(field_name='iso_date_time', lookup_expr='range')
number_MultipleChoiceFilter_OR = MultipleChoiceFilter(field_name='number', lookup_expr='exact', conjoined=False, choices=NUMBER_CHOICES)
number_MultipleChoiceFilter_AND = MultipleChoiceFilter(field_name='number', lookup_expr='exact', conjoined=True, choices=NUMBER_CHOICES)
number_NumberFilter = NumberFilter(field_name='number', lookup_expr='exact')
number_OrderingFilter = OrderingFilter(fields=('number', 'number'))
number_RangeFilter = RangeFilter(field_name='number', lookup_expr='range')
time_TimeFilter = TimeFilter(field_name='time', lookup_expr='exact')
time_TimeRangeFilter = TimeRangeFilter(field_name='time', lookup_expr='range')
number_TypedChoiceFilter = TypedChoiceFilter(field_name='number', lookup_expr='exact', choices=NUMBER_CHOICES)
text_TypedMultipleChoiceFilter_OR = TypedMultipleChoiceFilter(field_name='number', lookup_expr='exact', conjoined=False, choices=NUMBER_CHOICES)
text_TypedMultipleChoiceFilter_AND = TypedMultipleChoiceFilter(field_name='number', lookup_expr='exact', conjoined=True, choices=NUMBER_CHOICES)
uuid_UUIDFilter = UUIDFilter(field_name='uuid', lookup_expr='exact')
number_LookupChoiceFilter = LookupChoiceFilter(field_name='number')
class Meta:
model = BenchmarkModel
exclude = ['number', 'text', 'is_true', 'date', 'date_time', 'duration']
class DepartmentEmployeesTemplateTableFilter(EmployeesTemplateTableFilter):
"""
Filter for Department Employees filtering and template table column sorting.
"""
def __init__(self, *args, **kwargs):
self.department = kwargs.pop('department')
super().__init__(*args, **kwargs)
# By default display only department's employees.
if not self.data:
self.queryset = self.queryset.filter(department=self.department)
self.form.initial['in_the_department'] = True
in_the_department = BooleanFilter(
label=_('In the department'),
method='filter_employees',
widget=CheckboxInput(),
help_text=_(
'Uncheck if need to add new employees to this department.'))
def filter_employees(self, queryset, name, value):
if value:
queryset = queryset.filter(department=self.department)
else:
queryset = queryset.filter(
Q(organization__isnull=True)
| Q(organization=self.department.organization),
department__isnull=True)
return queryset
class Meta(EmployeesTemplateTableFilter.Meta):
form = DepartmentEmployeesTableFilterFlexForm
fields = ['city', 'city__country']
class EpicFilterSet(FilterSet):
finished = BooleanFilter(label=_("Finalizada"), method="finished_filter")
current_progress__gte = NumberFilter(
label=_("Avance actual mayor o igual que"),
field_name="annotated_current_progress",
lookup_expr="gte")
current_progress__lte = NumberFilter(
label=_("Avance actual menor o igual que"),
field_name="annotated_current_progress",
lookup_expr="lte")
def finished_filter(self, queryset, field_name, value):
condition = Q(annotated_current_progress=100)
if value is True:
return queryset.filter(condition)
elif value is False:
return queryset.exclude(condition)
else:
return queryset
class Meta:
model = Epic
fields = {
"id": ["exact", "in"],
"name": ["icontains"],
"description": ["icontains"],
"external_reference": ["icontains"],
"tags__name": ["in", "iexact", "icontains", "istartswith"],
}
class Filter(FilterSet):
is_own = BooleanFilter(method='user_owns_object',
label=_('Mine'),
widget=forms.CheckboxInput())
class Meta:
model = SamplingEvent
fields = {
'created_by': ['exact'],
'created_by__username': ['icontains'],
'created_by__first_name': ['icontains'],
'created_by__last_name': ['icontains'],
'sampling_event_type': ['exact'],
'collection_site__site__name': ['icontains'],
'started_on': ['gt', 'lt'],
'ended_on': ['gt', 'lt'],
'created_on': ['gt', 'lt'],
}
filter_overrides = {
models.DateTimeField: {
'filter_class': DateFilter,
'extra': lambda f: {
'widget': forms.DateInput(attrs={'class': 'datepicker'})
}
}
}
def user_owns_object(self, queryset, name, value):
if value:
user = self.request.user
return queryset.filter(created_by=user)
return queryset
class ObsoleteCalibreGroupFilter(ModelSearchFilter):
group_name = CharFilter(field_name='name',
lookup_expr='icontains',
label='Obsolete Calibre Group Name')
calibre_name = CharFilter(field_name='calibres__name',
lookup_expr='icontains',
label='Obsolete Calibre Name')
display_archived = BooleanFilter(label='Display Archived',
widget=CheckboxInput,
method='filter_display_archived')
def filter_display_archived(self, queryset, name, value):
if value:
return queryset
# filter archived calibre groups
return queryset.filter(is_active=True)
@property
def qs(self):
self.queryset = ObsoleteCalibreGroup.objects.annotate(
Count('calibres'))
# Filter archived querysets on first load as django_filters doesn't
# seem to apply filters on first load
if not self.form.data: # first page load
self.queryset = self.queryset.filter(is_active=True)
return super().qs
class Meta:
model = ObsoleteCalibreGroup
fields = []
class ReservationFilter(FilterSet):
start_gte = IsoDateTimeFilter('start', lookup_expr='gte')
start_lt = IsoDateTimeFilter('start', lookup_expr='lt')
missed = BooleanFilter('missed', widget=BooleanWidget())
class Meta:
model = Reservation
fields = []
class ResourceFilter(WorkbenchElementFilter):
class Meta:
model = Resource
fields = {
'type': BaseFilter.CHOICE_COMPERATORS,
'projects': BaseFilter.FOREIGNKEY_COMPERATORS,
'projects_recursive': BaseFilter.FOREIGNKEY_COMPERATORS,
'created_by': BaseFilter.FOREIGNKEY_COMPERATORS,
}
study_room = BooleanFilter(field_name='study_room_info',
lookup_expr='isnull',
exclude=True)
branch_library = ChoiceFilter(field_name='study_room_info__branch_library',
choices=StudyRoom.BRANCH_LIBRARY_CHOICES)
bookable_by_students = BooleanFilter(
field_name='study_room_info__is_bookable_by_students')
