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')