class LandRentFilter(FilterSet):
person = ModelChoiceFilter(queryset=Person.objects.all())
land_plot = ModelChoiceFilter(queryset=LandPlot.objects.all())
class Meta:
model = LandRent
fields = ('person', )
class TitleFilter(FilterSet):
name = CharFilter(lookup_expr='contains')
genre = ModelChoiceFilter(queryset=Genre.objects.all(),
to_field_name='slug')
category = ModelChoiceFilter(queryset=Category.objects.all(),
to_field_name='slug')
class Meta:
model = Title
fields = ('name', 'category', 'genre', 'year')
class LandPlotFilter(FilterSet):
area = NumberFilter(field_name='area')
purpose = ModelChoiceFilter(queryset=LandPurpose.objects.all())
quarter__zone = ModelChoiceFilter(queryset=LandZone.objects.all())
code = NumberFilter()
quarter__code = NumberFilter()
quarter__zone__code = NumberFilter()
quarter__zone__unit__code = NumberFilter()
class Meta:
model = LandPlot
fields = ('area', 'purpose', 'quarter__zone', 'code', 'quarter__code',
'quarter__zone__code', 'quarter__zone__unit__code')
class PriceFilter(FilterSet):
min_price = NumberFilter(field_name='price', lookup_expr='gte')
max_price = NumberFilter(field_name='price', lookup_expr='lte')
company = ModelChoiceFilter(queryset=Company.objects.all())
product__category = ModelChoiceFilter(queryset=Category.objects.all(),
label='Category')
class Meta:
model = Price
fields = [
'product__name', 'company', 'product__category', 'min_price',
'max_price'
]
class BooksListFilter(FilterSet):
"""
Кастомный фильтр для BooksViewSet:
выбор категорий,
выбор автора,
выбор библиотеки
"""
categories = ModelMultipleChoiceFilter(queryset=Categories.objects.all())
author = ModelChoiceFilter(queryset=Authors.objects.all())
lib_available__library = ModelChoiceFilter(
queryset=Libraries.objects.all())
class Meta:
model = Books
fields = ['categories', 'author', 'lib_available__library']
class ClassroomFilter(FilterSet):
role = CharFilter(method="filter_has_role_for")
parent = ModelChoiceFilter(queryset=Facility.objects.all())
def filter_has_role_for(self, queryset, name, value):
requesting_user = self.request.user
if requesting_user.is_superuser:
return queryset
if requesting_user.is_anonymous():
return queryset.none()
# filter queryset by admin role and coach role
roles = requesting_user.roles.exclude(kind=role_kinds.ASSIGNABLE_COACH)
if roles.filter(collection_id=requesting_user.facility_id,
kind=role_kinds.ADMIN).exists():
return queryset
if value == role_kinds.COACH:
roles = roles.filter(kind=value)
return queryset.filter(
Q(id__in=roles.values("collection_id"))
| Q(parent_id__in=roles.values("collection_id")))
class Meta:
model = Classroom
fields = ["role", "parent"]
class ProductFilter(FilterSet):
# explicit filter declaration
max_price = NumberFilter(field_name="price",
lookup_expr='lte',
label='highest price')
max_sub_price = NumberFilter(field_name="subproduct__sub_price",
lookup_expr='lte')
sub = NumberFilter(field_name="subproduct", lookup_expr='exact')
int_id = NumberFilter(method='filter_method_typed')
number_id = NumberFilter(method='filter_method_untyped',
help_text='some injected help text')
number_id_ext = NumberFilter(method=external_filter_method)
# implicit filter declaration
subproduct__sub_price = NumberFilter() # reverse relation
other_sub_product__uuid = UUIDFilter() # forward relation
# special cases
ordering = OrderingFilter(
fields=('price', 'in_stock'),
field_labels={
'price': 'Price',
'in_stock': 'in stock'
},
)
in_categories = BaseInFilter(field_name='category')
is_free = BooleanFilter(field_name='price', lookup_expr='isnull')
price_range = RangeFilter(field_name='price')
model_multi_cat = ModelMultipleChoiceFilter(field_name='category',
queryset=Product.objects.all())
model_single_cat = ModelChoiceFilter(field_name='category',
queryset=Product.objects.all())
all_values = AllValuesFilter(field_name='price')
custom_filter = CustomBooleanFilter(field_name='price',
lookup_expr='isnull')
custom_underspec_filter = CustomBaseInFilter(field_name='category')
model_multi_cat_relation = ModelMultipleChoiceFilter(
field_name='other_sub_product', queryset=OtherSubProduct.objects.all())
price_range_vat = RangeFilter(field_name='price_vat')
price_range_vat_decorated = extend_schema_field(OpenApiTypes.INT)(
RangeFilter(field_name='price_vat'))
class Meta:
model = Product
fields = [
'category',
'in_stock',
'max_price',
'max_sub_price',
'sub',
'subproduct__sub_price',
'other_sub_product__uuid',
]
def filter_method_typed(self, queryset, name, value: int):
return queryset.filter(id=int(value))
def filter_method_untyped(self, queryset, name, value):
return queryset.filter(id=int(value)) # pragma: no cover
class ActivityHistoryStatsFilter(FilterSet):
group = ModelChoiceFilter(queryset=groups_queryset)
user = ModelMultipleChoiceFilter(queryset=users_queryset, field_name='users')
date = IsoDateTimeFromToRangeFilter(field_name='activity__date__startswith')
class Meta:
model = History
fields = ['group', 'user']
class PersonFilter(FilterSet):
city = ModelChoiceFilter(field_name='city', queryset=City.objects.all())
address = CharFilter(field_name="address", lookup_expr='icontains')
additional_info = CharFilter(field_name="additional_info",
lookup_expr='icontains')
class Meta:
model = Person
fields = ('city', 'address', 'additional_info')
class EmployeeFilter(df.FilterSet):
title = ModelChoiceFilter(queryset=Title.objects.all())
talent = ModelChoiceFilter(queryset=TitleEntry.objects.all(),
lookup_expr='contain')
location = ModelChoiceFilter(queryset=Location.objects.all())
title_id_in = NumberInFilter(field_name='title', lookup_expr='in')
location_id_in = NumberInFilter(field_name='location', lookup_expr='in')
availability_gte = df.DateTimeFilter(field_name="availability",
lookup_expr='gte')
availability_lte = df.DateTimeFilter(field_name="availability",
lookup_expr='lte')
is_free = df.BooleanFilter(field_name="is_free")
class Meta:
model = Employee
fields = [
'title_id_in', 'location_id_in', 'availability_gte',
'availability_lte', 'is_free'
]
class FacilityUserFilter(FilterSet):
member_of = ModelChoiceFilter(
method="filter_member_of", queryset=Collection.objects.all()
)
def filter_member_of(self, queryset, name, value):
return queryset.filter(Q(memberships__collection=value) | Q(facility=value))
class Meta:
model = FacilityUser
fields = ["member_of"]
class FacilityUserFilter(FilterSet):
member_of = ModelChoiceFilter(method="filter_member_of",
queryset=Collection.objects.all())
def filter_member_of(self, queryset, name, value):
return HierarchyRelationsFilter(queryset).filter_by_hierarchy(
target_user=F("id"), ancestor_collection=value)
class Meta:
model = FacilityUser
fields = ["member_of"]
class ClassroomFilter(FilterSet):
role = CharFilter(method="filter_has_role_for")
parent = ModelChoiceFilter(queryset=Facility.objects.all())
def filter_has_role_for(self, queryset, name, value):
requesting_user = self.request.user
if requesting_user.is_superuser:
return queryset
# filter queryset by admin role and coach role
return HierarchyRelationsFilter(queryset).filter_by_hierarchy(
source_user=requesting_user,
role_kind=role_kinds.ADMIN,
descendant_collection=F("id"),
) | HierarchyRelationsFilter(queryset).filter_by_hierarchy(
source_user=requesting_user, role_kind=value, descendant_collection=F("id")
)
class Meta:
model = Classroom
fields = ["role", "parent"]
class LancamentoDiarioFilter(FilterSet):
data = DateFilter()
escola_periodo_escolar = ModelChoiceFilter(
to_field_name='uuid', queryset=EscolaPeriodoEscolar.objects.all())
