class TransactionFilter(FilterSet):
withdraw = BooleanFilter(field_name='withdraw_id', method='filter_not_empty')
deposit = BooleanFilter(field_name='deposit_id', method='filter_not_empty')
transaction = BooleanFilter(label='transaction', method='filter_transaction')
def filter_not_empty(self, queryset, name, value):
"""
check value exists in row (is null or not)
"""
lookup = '__'.join([name, 'isnull'])
return queryset.filter(**{lookup: not value})
def filter_transaction(self, queryset, name, value):
f_bool = not value
if value:
return queryset.filter(deposit_id__isnull=f_bool, withdraw_id__isnull=f_bool)
return queryset.filter(Q(deposit_id__isnull=f_bool) | Q(withdraw_id__isnull=f_bool))
class Meta:
model = Transaction
fields = [
'currency',
'deposit',
'withdraw',
'transaction',
'title',
'created',
'updated',
]
class ChannelMetadataFilter(FilterSet):
available = BooleanFilter(method="filter_available")
has_exercise = BooleanFilter(method="filter_has_exercise")
class Meta:
model = models.ChannelMetadata
fields = (
'available',
'has_exercise',
)
def filter_has_exercise(self, queryset, name, value):
channel_ids = []
for channel in queryset:
channel_has_exercise = channel.root.get_descendants() \
.filter(available=True) \
.filter(kind=content_kinds.EXERCISE) \
.exists()
if channel_has_exercise:
channel_ids.append(channel.id)
return queryset.filter(id__in=channel_ids)
def filter_available(self, queryset, name, value):
return queryset.filter(root__available=value)
class DocumentFilter(FilterSet):
seq_annotations__isnull = BooleanFilter(field_name='seq_annotations',
method='filter_annotations')
doc_annotations__isnull = BooleanFilter(field_name='doc_annotations',
method='filter_annotations')
seq2seq_annotations__isnull = BooleanFilter(
field_name='seq2seq_annotations', method='filter_annotations')
speech2text_annotations__isnull = BooleanFilter(
field_name='speech2text_annotations', method='filter_annotations')
def filter_annotations(self, queryset, field_name, value):
queryset = queryset.annotate(num_annotations=Count(
expression=field_name,
filter=Q(**{f"{field_name}__user": self.request.user})
| Q(project__collaborative_annotation=True)))
should_have_annotations = not value
if should_have_annotations:
queryset = queryset.filter(num_annotations__gte=1)
else:
queryset = queryset.filter(num_annotations__lte=0)
return queryset
class Meta:
model = Document
fields = ('project', 'text', 'created_at', 'updated_at',
'doc_annotations__label__id', 'seq_annotations__label__id',
'doc_annotations__isnull', 'seq_annotations__isnull',
'seq2seq_annotations__isnull',
'speech2text_annotations__isnull')
class UserFilter(FilterSet):
locked = BooleanFilter(name='veterinarian__locked')
verified = BooleanFilter(name='veterinarian__verified')
class Meta:
model = User
fields = [
'username', 'email', 'full_name', 'is_active', 'groups',
'veterinarian__verified', 'veterinarian__locked'
]
class RadioVersionDailyFilter(_DailyVersionStatsFilter):
"""Filter for RadioVersionDaily instances."""
version__radio_version = CharFilter()
version__is_official_release = BooleanFilter()
version__is_beta_release = BooleanFilter()
class Meta: # noqa: D106
model = RadioVersionDaily
fields = "__all__"
class VersionDailyFilter(_DailyVersionStatsFilter):
"""Filter for VersionDaily instances."""
version__build_fingerprint = CharFilter()
version__is_official_release = BooleanFilter()
version__is_beta_release = BooleanFilter()
class Meta: # noqa: D106
model = VersionDaily
fields = "__all__"
class DocumentFilter(FilterSet):
seq_annotations__isnull = BooleanFilter(field_name='seq_annotations', lookup_expr='isnull')
doc_annotations__isnull = BooleanFilter(field_name='doc_annotations', lookup_expr='isnull')
seq2seq_annotations__isnull = BooleanFilter(field_name='seq2seq_annotations', lookup_expr='isnull')
speech2text_annotations__isnull = BooleanFilter(field_name='speech2text_annotations', lookup_expr='isnull')
class Meta:
model = Document
fields = ('project', 'text', 'meta', 'created_at', 'updated_at',
'doc_annotations__label__id', 'seq_annotations__label__id',
'doc_annotations__isnull', 'seq_annotations__isnull', 'seq2seq_annotations__isnull', 'speech2text_annotations__isnull')
class UserBookOfferFilter(FilterSet):
"""
Кастомный фильтр для UserOffersViewSet:
выбор интервала даты создания,
выбор принятых,
выбор закрытых
"""
created_at = DateFromToRangeFilter()
is_accepted = BooleanFilter()
is_closed = BooleanFilter()
class Meta:
model = UserBookOffer
fields = ['created_at', 'is_accepted', 'is_closed']
class AdminUserFilter(FilterSet):
keywords = CharFilter(method="filter_keywords")
is_active = BooleanFilter(method="filter_is_active")
is_admin = BooleanFilter(method="filter_is_admin")
chef = BooleanFilter(method="filter_chef")
location = CharFilter(method="filter_location")
ids = CharFilter(method="filter_ids")
def filter_ids(self, queryset, name, value):
try:
return queryset.filter(pk__in=value.split(","))
except ValueError:
# Catch in case of a poorly formed UUID
return queryset.none()
def filter_keywords(self, queryset, name, value):
regex = r"^(" + "|".join(value.split(" ")) + ")$"
return queryset.filter(
Q(first_name__icontains=value)
| Q(last_name__icontains=value)
| Q(email__icontains=value)
| Q(editable_channels__name__iregex=regex)
| Q(editable_channels__id__iregex=regex)
)
def filter_is_active(self, queryset, name, value):
return queryset.filter(is_active=value)
def filter_is_admin(self, queryset, name, value):
return queryset.filter(is_admin=value)
def filter_chef(self, queryset, name, value):
chef_channel_query = (
Channel.objects.filter(editors__id=OuterRef("id"), deleted=False)
.exclude(ricecooker_version=None)
.values_list("id", flat=True)
.distinct()
)
return queryset.annotate(
chef_count=SQCount(chef_channel_query, field="id")
).filter(chef_count__gt=0)
def filter_location(self, queryset, name, value):
return queryset.filter(information__locations__contains=value)
class Meta:
model = User
fields = ("keywords", "is_active", "is_admin", "chef", "location")
class RecipeFilter(FilterSet):
category__name = InAllCharListFilter(field_name='category__name')
no_variant = BooleanFilter(field_name='variant_of', lookup_expr='isnull')
class Meta:
model = Recipe
fields = ['logical_delete', 'category__name', 'id']
class DocumentFilterSet(FilterSet):
is_tagged = BooleanFilter(label="Is tagged",
field_name="tags",
lookup_expr="isnull",
exclude=True)
tags__id__all = TagsFilter()
tags__id__none = TagsFilter(exclude=True)
is_in_inbox = InboxFilter()
class Meta:
model = Document
fields = {
"title": CHAR_KWARGS,
"content": CHAR_KWARGS,
"archive_serial_number": INT_KWARGS,
"created": DATE_KWARGS,
"added": DATE_KWARGS,
"modified": DATE_KWARGS,
"correspondent__id": ID_KWARGS,
"correspondent__name": CHAR_KWARGS,
"tags__id": ID_KWARGS,
"tags__name": CHAR_KWARGS,
"document_type__id": ID_KWARGS,
"document_type__name": CHAR_KWARGS,
}
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 GoalFilter(FilterSet):
eisenhower_score = NumberFilter(method='filter_eisenhower_score')
is_parent = BooleanFilter(method='filter_is_parent')
num_title_chars = NumberFilter()
class Meta:
model = Goal
fields = [
'parent_goal', 'verb', 'verb_phrase', 'target_date',
'end_state_description', 'urgency', 'importance',
'eisenhower_score', 'complete', 'is_parent', 'num_title_chars',
'created_date', 'updated_date', 'subgoals'
]
def filter_eisenhower_score(self, queryset, value, name):
if value:
queryset = queryset.annotate(
eisenhower_score=((F('urgency') * F('importance')) /
100)).filter(eisenhower_score=value)
return queryset
def filter_is_parent(self, queryset, value, name):
if value:
queryset = queryset.annotate(
is_parent=F('parent_goal') is not int).filter(is_parent=value)
return queryset
class UserFilter(FilterSet):
name = CharFilter(field_name='full_name', lookup_expr='icontains')
is_staff = BooleanFilter(field_name='is_staff')
class Meta:
model = User
fields = ['email', 'name', 'full_name', 'date_of_birth', 'is_active', 'is_staff']
class DailyStudyCreatedDayFilter(FilterSet):
begining = DateFilter(field_name='created_day', lookup_expr='gte')
end = DateFilter(field_name='created_day', lookup_expr='lte')
is_validated = BooleanFilter(method='is_validated_filter')
class Meta:
model = DailyStudy
fields = {
'begining', 'end', 'is_validated', 'user', 'user__classroom',
'user__classroom__area'
}
def is_validated_filter(self, queryset, name, value):
"""
student dailystudyleri gece otomatik oluşturuluyor ve is_validated false oluyor.
Ancak student dailystudy'i daha doldurmadı ve bütün studyler default oalrak 0 geldi.
dailystudy onay ekranında görünen daily studylerin student tarafından doldurulduğunu tespit etmek için
updated__isnull kontrolü ekledim.
Otomatik eklenen dailystudyler student tarafından update edildikten sonra onay ekranına düşecek..
"""
if not value:
return queryset.filter(updated__isnull=False, is_validated=False)
else:
return queryset
class DocumentFilterSet(FilterSet):
CHAR_KWARGS = {
"lookup_expr": (
"startswith",
"endswith",
"contains",
"istartswith",
"iendswith",
"icontains"
)
}
correspondent__name = CharFilter(
field_name="correspondent__name", **CHAR_KWARGS)
correspondent__slug = CharFilter(
field_name="correspondent__slug", **CHAR_KWARGS)
tags__name = CharFilter(
field_name="tags__name", **CHAR_KWARGS)
tags__slug = CharFilter(
field_name="tags__slug", **CHAR_KWARGS)
tags__empty = BooleanFilter(
field_name="tags", lookup_expr="isnull", distinct=True)
class Meta:
model = Document
fields = {
"title": [
"startswith", "endswith", "contains",
"istartswith", "iendswith", "icontains"
],
"content": ["contains", "icontains"],
}
class TaxonFilter(FilterSet):
"""Taxon filter."""
current = BooleanFilter(field_name="current")
class Meta:
"""Class opts."""
model = Taxon
fields = {
"name_id": ["exact", ],
"name": ["icontains", ],
"rank": ["icontains", "in", "gt", "gte", "lt", "lte"],
# "parent": ["exact", ], # performance bomb
"publication_status": ["isnull", ],
# current: provided through field
"author": ["icontains", ],
"canonical_name": ["icontains", ],
"taxonomic_name": ["icontains", ],
"paraphyletic_groups": ["exact", ],
# "vernacular_name": ["icontains", ],
"vernacular_names": ["icontains", ],
# "eoo" requires polygon filter,
}
class OrganizationFilter(FilterSet):
users = NumberInFilter(field_name='users', lookup_expr='in', label='Filter by user ID (or a list of user IDs)')
contacts = NumberInFilter(field_name='contacts', lookup_expr='in', label='Filter by contact ID (or a list of contact IDs)')
laboratory = BooleanFilter(label='Filter by whether organization is a laboratory or not')
class Meta:
model = Organization
fields = ['users', 'contacts', 'laboratory', ]
class ContactFilter(FilterSet):
org = NumberInFilter(field_name='organization', lookup_expr='in', label='Filter by organization ID (or a list of organization IDs)')
ownerorg = NumberInFilter(field_name='owner_organization', lookup_expr='in', label='Filter by owner organization ID (or a list of owner organization IDs)')
active = BooleanFilter(label='Filter by whether contact is active or not')
class Meta:
model = Contact
fields = ['org', 'ownerorg', 'active', ]
class EmailListFilterSet(FilterSet):
name = CharFilter(lookup_expr="icontains")
email = CharFilter(lookup_expr="icontains", field_name="email__email")
requireInternalAddress = BooleanFilter(field_name="require_internal_address")
class Meta:
model = EmailList
fields = ("name", "email", "requireInternalAddress")
class ChannelSetFilter(FilterSet):
edit = BooleanFilter(method="filter_edit")
def filter_edit(self, queryset, name, value):
return queryset.filter(edit=True)
class Meta:
model = ChannelSet
fields = ("edit", )
class FilePrescriptionFilter(FilterSet):
prescription_id = NumberFilter(field_name='prescription_id', label='소견서 객체의 pk')
writer_id = NumberFilter(label='작성자(의사) 계정의 id')
writer_name = CharFilter(label='작성자(의사)의 이름')
patient_id = NumberFilter(label='환자 계정의 id')
patient_name = CharFilter(label='환자의 이름')
status = ChoiceFilter(field_name='status', choices=HealthStatus.choices)
created_at = DateLookupChoiceFilter(
field_class=DateFilter.field_class,
field_name='created_at',
lookup_choices=[
('exact', 'Equals'),
('gte', 'Greater than'),
('lte', 'Less than')
], label='소견서 작성일(FilePrescription은 소견서 작성시 생성됨)'
)
date = LookupChoiceFilter(
field_class=DateFilter.field_class,
field_name='date',
lookup_choices=[
('exact', 'Equals'),
('gte', 'Greater than'),
('lte', 'Less than')
], label='파일 업로드 날짜')
active = BooleanFilter(field_name='active', label='파일 업로드가 활성화 되었는지 표시')
uploaded = BooleanFilter(field_name='uploaded', label='환자가 파일을 올렸는지 표시')
checked = BooleanFilter(field_name='checked', label='의사가 환자가 올린 파일을 확인했는지 표시')
ordering = OrderingFilter(
fields={
'created_at': 'created_at',
'date': 'date'
},
field_labels={
'created_at': '소견서 작성일',
'date': '파일 업로드 날짜'
}
)
class Meta:
model = FilePrescription
fields = ['writer_id', 'writer_name', 'patient_id', 'patient_name', 'prescription_id', 'status', 'created_at',
'date', 'active', 'uploaded', 'checked', 'ordering']
class StudentFilter(FilterSet):
only_active = BooleanFilter(method='filter_active', label=_('Include only active users'))
def filter_active(self, queryset: QuerySet, field_name, value: bool):
if value:
return queryset.filter(is_active=True)
return queryset
class Meta:
model = User
fields = ('only_active',)
class ChannelMetadataFilter(FilterSet):
available = BooleanFilter(method="filter_available", label="Available")
has_exercise = BooleanFilter(method="filter_has_exercise",
label="Has exercises")
class Meta:
model = models.ChannelMetadata
fields = ("available", "has_exercise")
def filter_has_exercise(self, queryset, name, value):
queryset = queryset.annotate(has_exercise=Exists(
models.ContentNode.objects.filter(
kind=content_kinds.EXERCISE,
available=True,
channel_id=OuterRef("id"),
)))
return queryset.filter(has_exercise=True)
def filter_available(self, queryset, name, value):
return queryset.filter(root__available=value)
class ChannelFilter(BaseChannelFilter):
edit = BooleanFilter(method="filter_edit")
view = BooleanFilter(method="filter_view")
bookmark = BooleanFilter(method="filter_bookmark")
def filter_edit(self, queryset, name, value):
return queryset.filter(edit=True)
def filter_view(self, queryset, name, value):
return queryset.filter(view=True)
def filter_bookmark(self, queryset, name, value):
return queryset.filter(bookmark=True)
class Meta:
model = Channel
fields = base_channel_filter_fields + (
"bookmark",
"edit",
"view",
)
class DocumentFilter(FilterSet):
seq_annotations__isnull = BooleanFilter(field_name='seq_annotations', method='filter_annotations')
doc_annotations__isnull = BooleanFilter(field_name='doc_annotations', method='filter_annotations')
seq2seq_annotations__isnull = BooleanFilter(field_name='seq2seq_annotations', method='filter_annotations')
def filter_annotations(self, queryset, field_name, value):
queryset = queryset.annotate(num_annotations=Count(field_name))
should_have_annotations = not value
if should_have_annotations:
queryset = queryset.filter(num_annotations__gte=1)
else:
queryset = queryset.filter(num_annotations__lte=0)
return queryset
class Meta:
model = Document
fields = ('project', 'text', 'meta', 'created_at', 'updated_at',
'doc_annotations__label__id', 'seq_annotations__label__id',
'doc_annotations__isnull', 'seq_annotations__isnull', 'seq2seq_annotations__isnull')
class BeerFilterSet(FilterSet):
o = BeerOrderingFilter(fields=[
"name",
"abv",
"ibu",
"style__name",
"style__alternate_names__name",
"manufacturer__name",
"most_recently_added",
], )
search = CharFilter(method="filter_search")
on_tap = BooleanFilter(method="filter_on_tap")
def filter_search(self, queryset, name, value):
base_cond = Q()
# what I want to search for:
# each word (split by whitespace) is included in at least
# one of the below six fields,
# so you can search for "straight monkey" to get monkeynaut
# or "belgi ipa ommeg" to get all Ommegang Belgian IPAs
for word in value.split():
base_cond &= (
Q(name__icontains=word, )
| Q(alternate_names__name__icontains=word, )
| Q(manufacturer__name__icontains=word, )
| Q(
# the field is case-insensitive, so no need for icontains
style__name=word, )
| Q(
# the field is case-insensitive, so no need for icontains
style__alternate_names__name=word, )
| Q(manufacturer__alternate_names__name__icontains=word, ))
queryset = queryset.filter(base_cond).distinct()
return queryset
def filter_on_tap(self, queryset, name, value):
return queryset.filter(taps__isnull=not value).distinct()
class Meta:
fields = {
"name": DEFAULT_STRING_FILTER_OPERATORS,
"abv": DEFAULT_NUMERIC_FILTER_OPERATORS,
"ibu": DEFAULT_NUMERIC_FILTER_OPERATORS,
"manufacturer__name": DEFAULT_NUMERIC_FILTER_OPERATORS,
"taps__venue__name": DEFAULT_STRING_FILTER_OPERATORS,
"style__name": DEFAULT_STRING_FILTER_OPERATORS,
"style__alternate_names__name": DEFAULT_STRING_FILTER_OPERATORS,
"taps__venue__slug": DEFAULT_STRING_FILTER_OPERATORS,
}
model = models.Beer
class ChannelMetadataFilter(FilterSet):
available = BooleanFilter(method="filter_available")
has_exercise = BooleanFilter(method="filter_has_exercise")
def filter_has_exercise(self, queryset, name, value):
channel_ids = []
for c in queryset:
num_exercises = c.root.get_descendants().filter(
kind=content_kinds.EXERCISE).count()
if num_exercises > 0:
channel_ids.append(c.id)
return queryset.filter(id__in=channel_ids)
def filter_available(self, queryset, name, value):
return queryset.filter(root__available=value)
class Meta:
model = models.ChannelMetadata
fields = [
'available',
'has_exercise',
]
class PickupDatesFilter(FilterSet):
store = NumberFilter(field_name='store')
group = NumberFilter(field_name='store__group__id')
date = ISODateTimeFromToRangeFilter(field_name='date')
feedback_possible = BooleanFilter(method='filter_feedback_possible')
class Meta:
model = PickupDate
fields = ['store', 'group', 'date', 'series', 'feedback_possible']
def filter_feedback_possible(self, qs, name, value):
if value is True:
return qs.only_feedback_possible(self.request.user)
return qs.exclude_feedback_possible(self.request.user)
class JobPostFilter(FilterSet):
""" Filters job posts by expired """
expired = BooleanFilter(method="filter_expired", label="Expired")
class Meta:
model: JobPost
fields = ["expired"]
def filter_expired(self, queryset, name, value):
if value:
return queryset.filter(
deadline__lt=yesterday()).order_by("-deadline")
return queryset.filter(deadline__gte=yesterday()).order_by("deadline")
