class CategoryFilterSet(BaseFilterSet):
name = CharFilter(name="name", lookup_expr='icontains')
name__exact = CharFilter(name="name", lookup_expr='exact')
class Meta:
model = CategoryModel
fields = ['name', 'name__exact']
class PollFilter(FilterSet):
"""
This class is needed because Django does not allow to filter on properties.
Inspired by https://stackoverflow.com/a/44990300.
"""
is_published = CharFilter(method="filter_is_published")
is_active = CharFilter(method="filter_is_active")
user = CharFilter(field_name="user__id")
state = MultipleChoiceFilter(choices=Poll.STATES)
class Meta:
model = Poll
fields = ("is_published", "is_active", "state", "user")
def filter_is_published(self, queryset, name, value):
condition = Q(publication_date__lte=date.today()) & Q(state="ACCEPTED")
if value.lower() == "true" or len(value) == 0:
return queryset.filter(condition)
else:
return queryset.exclude(condition)
def filter_is_active(self, queryset, _, value):
condition = (
Q(publication_date__lte=date.today())
& Q(state="ACCEPTED")
& Q(publication_date__gt=date.today() - Poll.POLL_LIFETIME))
if value.lower() == "true" or len(value) == 0:
return queryset.filter(condition)
else:
return queryset.exclude(condition)
class LessonFilter(FilterSet):
discipline = CharFilter(field_name='discipline',
lookup_expr='discipline__title__icontains')
group = CharFilter(field_name='group', lookup_expr='code__icontains')
teacher = CharFilter(field_name='teacher', method='filter_teacher')
lecture_hall = CharFilter(field_name='lecture_hall',
lookup_expr='code__icontains')
def filter_teacher(self, queryset, name, value):
values = value.split(',')
q = Q()
for val in values:
q |= Q(teacher__first_name__icontains=val)
q |= Q(teacher__last_name__icontains=val)
q |= Q(teacher__middle_name__icontains=val)
return queryset.filter(q)
class Meta:
model = Lesson
fields = {
'discipline': ['exact'],
'group': ['exact'],
'teacher': ['exact', 'in'],
'lecture_hall': ['exact'],
}
class GroupActivityFilter(FilterSet):
status = NumberFilter(method='status_filter', label='status')
create_user_id = NumberFilter('user_id')
group_no = CharFilter('group_no')
parent_user = CharFilter(method='parent_user_filter', label='parent_user')
grant_status = CharFilter(method='grant_status_filter',
label='grant_status')
def grant_status_filter(self, queryset, name, value):
queryset = queryset.filter(grant_award=value)
return queryset
def parent_user_filter(self, queryset, name, value):
queryset = queryset.filter(
Q(group_member__parent_user__username__contains=value)
| Q(group_member__parent_user__real_name__contains=value))
return queryset
def status_filter(self, queryset, name, value):
queryset = queryset.filter(status=value)
return queryset
class Meta:
model = ActivityGroupInfo
fields = ['status', 'create_user_id', 'grant_status', 'parent_user']
class ProjectFilterSet(FilterSet):
key_any = CharFilter(
method='filter_any',
label="Key, Title, Keyword, PI, Lay summary or Organisation")
geographical_areas = CharFilter(method='filter_geographical_areas')
funding_instrument = CharFilter(method='filter_funding_instrument')
start_date = CharFilter(method='filter_start_date')
def filter_any(self, queryset, name, value):
fields = [
"key", "title", "keywords__name",
"principal_investigator__person__first_name",
"principal_investigator__person__surname", "laysummary__text",
"principal_investigator__organisation_names__name"
]
q_field = reduce(or_, (Q(**{f"{field}__icontains": word})
for word in value.split() for field in fields))
return queryset.filter(q_field).distinct()
def filter_geographical_areas(self, queryset, name, value):
return queryset.filter(geographical_areas__name=value)
def filter_funding_instrument(self, queryset, name, value):
return queryset.filter(funding_instrument__long_name=value)
def filter_start_date(self, queryset, name, value):
return queryset.filter(start_date__year__lte=value,
end_date__year__gte=value)
class Meta:
model = Project
fields = ('key_any', 'geographical_areas', 'funding_instrument',
'start_date')
class UserFilterSet(FilterSet):
email = CharFilter(name="email", method=wildcard_filter)
last_name = CharFilter(name="last_name", method=wildcard_filter)
class Meta:
model = get_user_model()
fields = ["email", "last_name"]
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 BankTransactionFilter(FilterSet):
account_number = CharFilter(method='filter_account_number')
fee = CharFilter(method='filter_fee')
class Meta:
model = BankTransaction
fields = [
'id',
'account_number',
'block__sender',
'block__balance_key',
'fee',
'recipient',
]
@staticmethod
def filter_account_number(queryset, _, value):
"""Filter queryset by account number"""
return queryset.filter(
Q(block__sender=value)
| Q(recipient=value)
)
@staticmethod
def filter_fee(queryset, _, value):
"""Filter queryset by fee"""
if value == 'NONE':
return queryset.filter(
fee__exact='',
)
return queryset.filter(
fee__exact=value,
)
class TaskFilter(BaseFilterSet):
lab = CharFilter('session__lab__name')
status = CharFilter(method='enum_field_filter')
class Meta:
model = Task
exclude = ['json']
class MembershipFilterSet(FilterSet):
userUsername = CharFilter(field_name="user__username", lookup_expr="icontains")
userFullname = CharFilter(field_name="userFullname", method="user__fullname")
abakusGroupName = CharFilter(
field_name="abakus_group__name", lookup_expr="icontains"
)
class Meta:
model = Membership
fields = (
"role",
"userUsername",
"abakusGroupName",
"userFullname",
)
def user__fullname(self, queryset, name, value):
if value:
return queryset.annotate(
user__fullname=Concat(
F("user__first_name"), Value(" "), F("user__last_name")
)
).filter(user__fullname__icontains=value)
return queryset
class UnitReportFilter(FilterSet):
status = NumberFilter(method='status_filter', label='status')
id = NumberFilter('id')
student_name = CharFilter(method='student_name_filter', label='student_name')
course_edition = NumberFilter(method='course_edition_filter', label='course_edition')
course_level = NumberFilter(method='course_level_filter', label='course_level')
course_unit = NumberFilter('unit_no')
user_name = CharFilter(method='user_name_filter', label='user_name')
tutor_name = CharFilter(method='tutor_name_filter', label='tutor_name')
send_parent = NumberFilter('status')
examine_user = CharFilter(method='examine_user_filter', label='examine_user')
def examine_user_filter(self, queryset, name, value):
cms_user = UserInfo.objects.filter(realname__icontains=value).first()
if not cms_user:
return queryset
queryset = queryset.filter(unit_report_audit__audit_user_id=cms_user.id)
return queryset
def status_filter(self, queryset, name, value):
if int(value) == VirtualclassUnitReport.EXAMINED:
queryset = queryset.filter(Q(status=VirtualclassUnitReport.EXAMINED)|Q(status=VirtualclassUnitReport.SAVED))
else:
queryset = queryset.filter(status=value)
return queryset
def tutor_name_filter(self, queryset, name, value):
queryset = queryset.filter(
Q(tutor_user__username__icontains=value) | Q(tutor_user__email__icontains=value) | Q(tutor_user__phone__icontains=value) | Q(
tutor_user__real_name__icontains=value))
return queryset
def user_name_filter(self, queryset, name, value):
queryset = queryset.filter(
Q(student_user__parent_user__adviser_user_id=value) | Q(student_user__parent_user__xg_user_id=value))
return queryset
def student_name_filter(self, queryset, name, value):
queryset = queryset.filter(
Q(student_user__real_name__icontains=value) |
Q(student_user__parent_user__username__icontains=value) |
Q(student_user__parent_user__email__icontains=value) |
Q(student_user__parent_user__phone__icontains=value))
return queryset
def course_edition_filter(self, queryset, name, value):
queryset = queryset.filter(virtual_class__lesson__course__course_edition_id=value)
return queryset
def course_level_filter(self, queryset, name, value):
queryset = queryset.filter(virtual_class__lesson__course__course_level=value)
return queryset
class Meta:
model = VirtualclassUnitReport
fields = ['id', 'status', 'student_name', 'course_edition', 'course_level',
'course_unit', 'user_name', 'tutor_name', 'send_parent', 'examine_user']
class ProductFilter(ActiveFilterMixin):
company = CharFilter(field_name='company__name')
category = CharFilter(field_name='category__name')
name = CharFilter(field_name='name', lookup_expr='icontains')
class Meta:
model = Product
fields = ['is_active', 'company', 'name', 'category']
class EmailListFilterSet(FilterSet):
name = CharFilter(lookup_expr="icontains")
email = CharFilter(field_name="email__email", lookup_expr="icontains")
class Meta:
model = EmailList
fields = ("name", "email")
class EmailListFilterSet(FilterSet):
name = CharFilter(lookup_expr='icontains')
email = CharFilter(field_name='email__email', lookup_expr='icontains')
class Meta:
model = EmailList
fields = ('name', 'email')
class TitleFilter(FilterSet):
genre = CharFilter(field_name='genre__slug')
category = CharFilter(field_name='category__slug')
name = CharFilter(field_name='name', lookup_expr='icontains')
class Meta:
model = Title
fields = ['year']
class MajorFilter(FilterSet):
department_name = CharFilter(field_name='department__name', label='부서 이름')
department_id = NumberFilter(field_name='department__id', label='부서 객체의 pk')
major_name = CharFilter(field_name='name', label='전공 이름')
major_id = NumberFilter(field_name='id', label='전공 객체의 pk')
class Meta:
model = Major
fields = ['department_name', 'department_id', 'major_name', 'major_id']
class UserFilter(FilterSet):
username = CharFilter(field_name='username', lookup_expr='exact', label='Filter by username, exact match')
email = CharFilter(field_name='email', lookup_expr='iexact', label='Filter by email, exact match')
role = NumberInFilter(field_name='role', lookup_expr='in', label='Filter by role ID (or a list of role IDs)')
organization = NumberInFilter(field_name='organization', lookup_expr='in', label='Filter by organization ID (or a list of organization IDs)')
class Meta:
model = User
fields = ['username', 'email', 'role', 'organization', ]
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 UserFilter(FilterSet, DateFilterMixin):
game_created = DateFilter(name='active_game__date_created', method='filter_date')
game_updated = DateFilter(name='active_game__date_updated', method='filter_date')
state = CharFilter(name='active_game__state')
team = CharFilter(name='team__name')
class Meta:
model = User
fields = ('state', 'is_finalist', 'team', 'handedness', 'signed_waiver')
class GenInfoFilter(FilterSet):
"""自定义过滤器-一般信息的过滤"""
name = CharFilter(field_name="name", lookup_expr='icontains')
nation = CharFilter(field_name="nation", lookup_expr='contains')
class Meta:
model = GeneralInfo
fields = ['name', 'nation']
class DepartmentFilter(FilterSet):
medical_center_name = CharFilter(field_name='medical_center__name', label='병원 이름')
medical_center_id = NumberFilter(field_name='medical_center__id', label='병원 객체의 pk')
department_name = CharFilter(field_name='name', label='부서 이름')
department_id = NumberFilter(field_name='id', label='부서 객체의 pk')
class Meta:
model = Department
fields = ['medical_center_name', 'medical_center_id', 'department_name', 'department_id']
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 ConsultationFilter(FilterSet):
category = CharFilter('category__code')
district = CharFilter('clinic__district__code')
language = CharFilter('doctor__language__code')
price_range = NumberRangeFilter(field_name='price', lookup_expr='range')
class Meta:
model = Consultation
fields = ['category', 'district', 'language', 'price_range']
class ProbeInsertionFilter(FilterSet):
subject = CharFilter('session__subject__nickname')
date = CharFilter('session__start_time__date')
experiment_number = CharFilter('session__number')
name = CharFilter('name')
session = UUIDFilter('session')
class Meta:
model = ProbeInsertion
exclude = ['json']
class IndividualPersonFilter(PersonFilter):
last_name = CharFilter(field_name="last_name", lookup_expr='icontains')
first_name = CharFilter(field_name="first_name", lookup_expr='icontains')
middle_name = CharFilter(field_name="middle_name", lookup_expr='icontains')
inn = NumberFilter(field_name="inn", lookup_expr='icontains')
class Meta(PersonFilter.Meta):
model = IndividualPerson
fields = ('last_name', 'first_name', 'middle_name',
'inn') + PersonFilter.Meta.fields
class TitleFilter(FilterSet):
"""Title get params filtration"""
category = CharFilter(field_name='category', lookup_expr='slug')
genre = CharFilter(field_name='genre', lookup_expr='slug')
name = CharFilter(field_name='name', lookup_expr='icontains')
year = NumberFilter()
class Meta:
model = Title
fields = ('genre', 'category', 'name', 'year')
class ArticleFilter(FilterSet):
user = NumberFilter(field_name='user')
title = CharFilter(field_name='title', lookup_expr='contains')
first_name = CharFilter(field_name='user__first_name',
lookup_expr='startswith')
last_name = CharFilter(field_name='user__last_name',
lookup_expr='startswith')
class Meta:
model = Article
fields = []
class BooksFilter(FilterSet):
"""
Custom filter for filtering on Book model.
"""
name = CharFilter(field_name='name')
publisher = CharFilter(field_name='publisher', lookup_expr='name')
release_date = NumberFilter(field_name='released_date', lookup_expr='year')
class Meta:
model = Book
fields = ['name']
class CommentFilter(FilterSet):
"""
A filter class for filtering comments
"""
topic = CharFilter(name="topic__slug")
user = CharFilter(name="user__id")
class Meta:
model = Comment
fields = ['topic', 'user']
class TrainingDirectionFilter(FilterSet):
code = CharFilter(field_name='code', lookup_expr='icontains')
name = CharFilter(field_name='name', lookup_expr='icontains')
class Meta:
model = TrainingDirection
fields = {
'code':['exact'],
'name': ['exact'],
'type': ['exact', 'in'],
}
