class FilmLibraryRecordFilterClass(filters.FilterSet):
keyword = filters.ModelChoiceFilter(label='Keyword',
queryset=Keyword.objects.all(),
method='filter_keyword')
country = filters.ModelChoiceFilter(label='Country',
queryset=Country.objects.all(),
method='filter_country')
date_from = filters.NumberFilter(label='Temporal Coverage From',
method='filter_date_from')
date_to = filters.NumberFilter(label='Temporal Coverage To',
method='filter_date_to')
def filter_country(self, queryset, name, value):
return queryset.filter(countries=value)
def filter_keyword(self, queryset, name, value):
return queryset.filter(keywords=value)
def filter_date_from(self, queryset, name, value):
return queryset.exclude(Q(temporal_coverage_end__lt=value))
def filter_date_to(self, queryset, name, value):
return queryset.exclude(Q(temporal_coverage_start__gt=value))
class Meta:
model = FilmLibraryRecord
fields = ['country', 'keyword']
class InstanceFilter(django_filter_filters.FilterSet):
"""
Instance FilterSet implemented using django-filter
"""
submitted_by__id = django_filter_filters.ModelChoiceFilter(
field_name='user',
queryset=User.objects.all(),
to_field_name='id',
)
submitted_by__username = django_filter_filters.ModelChoiceFilter(
field_name='user',
queryset=User.objects.all(),
to_field_name='username',
)
media_all_received = django_filter_filters.BooleanFilter()
class Meta:
model = Instance
date_field_lookups = ['exact', 'gt', 'lt', 'gte', 'lte', 'year',
'year__gt', 'year__lt', 'year__gte', 'year__lte',
'month', 'month__gt', 'month__lt', 'month__gte',
'month__lte', 'day', 'day__gt', 'day__lt',
'day__gte', 'day__lte']
generic_field_lookups = ['exact', 'gt', 'lt', 'gte', 'lte']
fields = {'date_created': date_field_lookups,
'date_modified': date_field_lookups,
'last_edited': date_field_lookups,
'media_all_received': ['exact'],
'status': ['exact'],
'survey_type__slug': ['exact'],
'user__id': ['exact'],
'user__username': ['exact'],
'uuid': ['exact'],
'version': generic_field_lookups}
class UserFilter(BaseFilterSet):
system_roles = filters.ModelChoiceFilter(
queryset=Role.objects.filter(scope='system'),
method='filter_system_roles')
org_roles = filters.ModelChoiceFilter(
queryset=Role.objects.filter(scope='org'), method='filter_org_roles')
class Meta:
model = User
fields = (
'id',
'username',
'email',
'name',
'source',
'org_roles',
'system_roles',
)
@staticmethod
def filter_system_roles(queryset, name, value):
queryset = queryset.prefetch_related('role_bindings')\
.filter(role_bindings__role_id=value.id)\
.distinct()
return queryset
@staticmethod
def filter_org_roles(queryset, name, value):
queryset = queryset.prefetch_related('role_bindings') \
.filter(role_bindings__role_id=value.id) \
.distinct()
return queryset
class KpiInputFilter(filters.FilterSet):
groupkpi = filters.ModelChoiceFilter(queryset=GroupKPI.objects.all())
kpi = filters.ModelChoiceFilter(queryset=KPI.objects.all())
class Meta:
model = KpiInput
fields = ["groupkpi", "kpi"]
class GroupKPIFilter(filters.FilterSet):
dep = filters.ModelChoiceFilter(queryset=Departments.objects.all())
kpi = filters.ModelChoiceFilter(queryset=KPI.objects.all())
class Meta:
model = GroupKPI
fields = ["dep", "kpi"]
class FollowingFilterSet(filters.FilterSet):
user_following = filters.ModelChoiceFilter(queryset=User.objects.all())
user_followed = filters.ModelChoiceFilter(queryset=User.objects.all())
class Meta:
model = Following
fields = ['user_following', 'user_followed', 'status']
class BeneficiaryFilter(filters.FilterSet):
city = filters.ModelChoiceFilter(queryset=get_filter_by_id_function(City, 'city'))
age = filters.NumberFilter(lookup_expr='gt')
program = filters.ModelChoiceFilter(queryset=get_filter_by_id_function(Program, 'program'))
class Meta:
model = Beneficary
fields = ['city', 'age', 'program']
class FoiRequestFilter(filters.FilterSet):
user = filters.ModelChoiceFilter(queryset=filter_by_user_queryset)
tags = filters.CharFilter(method='tag_filter')
categories = filters.CharFilter(method='categories_filter')
reference = filters.CharFilter(method='reference_filter')
follower = filters.ModelChoiceFilter(
queryset=filter_by_authenticated_user_queryset,
method='follower_filter')
costs = filters.RangeFilter()
campaign = filters.ModelChoiceFilter(
queryset=Campaign.objects.filter(public=True),
null_value='-',
null_label='No Campaign',
lookup_expr='isnull',
method='campaign_filter')
# FIXME: default ordering should be undetermined?
# ordering = filters.OrderingFilter(
# fields=(
# ('last_message', 'last_message'),
# ('first_message', 'first_message')
# ),
# field_labels={
# '-last_message': 'By last message (latest first)',
# '-first_message': 'By first message (latest first)',
# 'last_message': 'By last message (oldest first)',
# 'first_message': 'By first message (oldest first)',
# }
# )
class Meta:
model = FoiRequest
fields = ('user', 'is_foi', 'checked', 'jurisdiction', 'tags',
'resolution', 'status', 'reference', 'public_body', 'slug',
'costs', 'project', 'campaign')
def tag_filter(self, queryset, name, value):
return queryset.filter(**{
'tags__name': value,
})
def categories_filter(self, queryset, name, value):
return queryset.filter(**{
'public_body__categories__name': value,
})
def reference_filter(self, queryset, name, value):
return queryset.filter(**{
'reference__startswith': value,
})
def follower_filter(self, queryset, name, value):
return queryset.filter(followers__user=value)
def campaign_filter(self, queryset, name, value):
if value == '-':
return queryset.filter(campaign__isnull=True)
return queryset.filter(campaign=value)
class TallyFilter(filters.FilterSet):
"""Defines the filter fields for ListTallyView."""
artist = filters.ModelChoiceFilter(queryset=Artist.objects.all(),
to_field_name='slug')
event = filters.ModelChoiceFilter(queryset=Event.objects.all())
class Meta:
model = Tally
fields = ['artist', 'event']
class ReviewFilter(filters.FilterSet):
# фильтр по ID продукта, по автору и дате создания
product = filters.ModelChoiceFilter(queryset=Product.objects.all())
creator = filters.ModelChoiceFilter(queryset=User.objects.all())
created_at = filters.DateFromToRangeFilter()
class Meta:
model = Review
fields = ['product', 'creator', 'created_at']
class CategoryFilter(SearchFilterMixin, TreeFilterMixin, filters.FilterSet):
q = filters.CharFilter(method='search_filter')
parent = filters.ModelChoiceFilter(method='parent_filter',
queryset=Category.objects.all())
ancestor = filters.ModelChoiceFilter(method='ancestor_filter',
queryset=Category.objects.all())
class Meta:
model = Category
fields = (
'name', 'is_topic', 'depth',
)
class PaymentFilter(filters.FilterSet):
user = filters.ModelChoiceFilter(field_name='user',
queryset=User.objects.all())
bank_name = filters.ModelChoiceFilter(field_name='bank_name',
queryset=Bank.objects.all())
pay_purpose = filters.ChoiceFilter(field_name='pay_purpose',
choices=Pay.payment_types())
amount = filters.NumberFilter(field_name='amount')
class Meta:
model = Payment
fields = ['user', 'bank_name', 'pay_purpose', 'amount']
class TicketFilter(filters.FilterSet):
"""Defines the filter fields for ListTicketView."""
owner = filters.ModelChoiceFilter(queryset=User.objects.all(),
to_field_name='slug')
ticket_type = filters.ModelChoiceFilter(queryset=TicketType.objects.all(),
to_field_name='slug')
vote = filters.ModelChoiceFilter(queryset=Tally.objects.all(),
to_field_name='slug')
class Meta:
model = Ticket
fields = ['ticket_type', 'vote']
class ClassificationFilter(SearchFilterMixin, TreeFilterMixin,
filters.FilterSet):
q = filters.CharFilter(method='search_filter')
parent = filters.ModelChoiceFilter(method='parent_filter',
queryset=Classification.objects.all())
ancestor = filters.ModelChoiceFilter(method='ancestor_filter',
queryset=Classification.objects.all())
class Meta:
model = Classification
fields = (
'name', 'depth',
)
class VerseFilter(django_filters.FilterSet):
book = filters.ModelChoiceFilter(queryset=Book.objects.all())
language = filters.ModelChoiceFilter(queryset=Language.objects.all())
code_iso = filters.ModelMultipleChoiceFilter(
queryset=Language.objects.all(),
field_name='language__code_iso',
to_field_name='code_iso')
class Meta:
model = Verse
fields = ('id', 'book', 'chapter', 'language', 'verse', 'data')
class CharacterFilter(filters.FilterSet):
book = filters.ModelChoiceFilter(
queryset=models.Book.objects.all(),
field_name="created_by_run__book",
label="Book ID",
widget=forms.TextInput,
)
page_sequence = filters.NumberFilter(
field_name="line__page__sequence", label="Page sequence"
)
page_side = filters.ChoiceFilter(
choices=models.Page.SPREAD_SIDE, field_name="line__page__side"
)
line_sequence = filters.NumberFilter(
field_name="line__sequence", label="Line sequence"
)
sequence = filters.NumberFilter()
created_by_run = filters.ModelChoiceFilter(
queryset=models.CharacterRun.objects.all(), widget=forms.TextInput
)
character_class = filters.ModelChoiceFilter(
queryset=models.CharacterClass.objects.all(), widget=forms.TextInput
)
human_character_class = filters.ModelChoiceFilter(
queryset=models.CharacterClass.objects.all(), widget=forms.TextInput
)
agreement = filters.ChoiceFilter(
choices=(
("all", "all"),
("unknown", "unknown"),
("agreement", "agreement"),
("disagreement", "disagreement"),
),
method="class_agreement",
label="Machine/human class agreement",
)
def class_agreement(self, queryset, name, value):
if value == "unknown":
return queryset.filter(human_character_class__isnull=True)
elif value == "agreement":
return queryset.filter(character_class__exact=F("human_character_class"))
elif value == "disagreement":
return queryset.exclude(character_class=F("human_character_class")).exclude(
human_character_class__isnull=True
)
else:
return queryset
class HarvestFilter(filters.FilterSet):
seasons = []
for y in Harvest.objects.all():
if y.start_date is not None:
t_seasons = (y.start_date.strftime("%Y"),
y.start_date.strftime("%Y"))
seasons.append(t_seasons)
seasons = list(set(seasons))
seasons = sorted(seasons, key=lambda tup: tup[1])
start_date = filters.ChoiceFilter(
choices=seasons,
label=_("Season"),
lookup_expr='year',
help_text="",
)
status = filters.ChoiceFilter(
choices=FILTER_HARVEST_CHOICES,
help_text="",
)
pick_leader = filters.ModelChoiceFilter(
queryset=AuthUser.objects.filter(is_staff=True),
required=False,
help_text="",
)
trees = filters.ModelChoiceFilter(queryset=TreeType.objects.all(),
label=_("Tree"),
help_text="",
required=False)
property__neighborhood = filters.ModelChoiceFilter(
queryset=Neighborhood.objects.all(),
label=_("Neighborhood"),
help_text="",
required=False)
class Meta:
model = Harvest
fields = {
'status': ['exact'],
'pick_leader': ['exact'],
'trees': ['exact'],
'property__neighborhood': ['exact'],
'start_date': ['exact'],
}
class InformationPackageFilter(filters.FilterSet):
archivist_organization = filters.ModelMultipleChoiceFilter(
label=_("Archivist Organization"),
queryset=Agent.objects.filter(role__iexact="archivist", type__iexact="organization"),
)
responsible = filters.ModelMultipleChoiceFilter(
field_name="responsible__username",
to_field_name="username",
queryset=lambda request: users_in_organization(request.user),
)
state = MultipleCharFilter()
object_size = filters.RangeFilter()
start_date = filters.IsoDateTimeFromToRangeFilter()
end_date = filters.IsoDateTimeFromToRangeFilter()
create_date = filters.IsoDateTimeFromToRangeFilter()
entry_date = filters.IsoDateTimeFromToRangeFilter()
package_type = MultipleCharFilter()
package_type_name_exclude = filters.CharFilter(
label=_("Excluded Package Type"),
method='exclude_package_type_name'
)
migratable = filters.BooleanFilter(label='migratable', method='filter_migratable')
workarea = filters.ChoiceFilter(label=_("Workarea"), field_name='workareas__type', choices=Workarea.TYPE_CHOICES)
medium = filters.ModelChoiceFilter(
label='Storage Medium', queryset=StorageMedium.objects.all(),
field_name='storage__storage_medium',
distinct=True
)
policy = filters.ModelChoiceFilter(
label='Storage Policy', queryset=StoragePolicy.objects.all(),
field_name='submission_agreement__policy',
distinct=True
)
def exclude_package_type_name(self, queryset, name, value):
for package_type_id, package_type_name in InformationPackage.PACKAGE_TYPE_CHOICES:
if package_type_name.lower() == value.lower():
return queryset.exclude(package_type=package_type_id)
return queryset.none()
def filter_migratable(self, queryset, name, value):
return queryset.migratable()
class Meta:
model = InformationPackage
fields = ['archivist_organization', 'state', 'responsible', 'active', 'label',
'create_date', 'entry_date', 'object_size', 'start_date', 'end_date', 'policy',
'archived', 'cached', 'package_type', 'package_type_name_exclude', 'workarea']
class ContributionFilter(filters.FilterSet):
team = filters.ModelChoiceFilter(field_name='team_member__team',
queryset=Team.objects.all())
class Meta:
model = Contribution
fields = ['submission', 'team']
class CityListFilter(filters.FilterSet):
country = filters.ModelChoiceFilter(queryset=Country.objects.all(),
to_field_name='slug')
class Meta:
model = City
fields = ('country', )
class RecordFilter(FilterSet):
date = filters.DateFromToRangeFilter()
writer = filters.ModelChoiceFilter(queryset=Writer.objects.all())
class Meta:
model = Record
fields = ['writer', 'date']
class PlaceTagFilter(filters.FilterSet):
"""List of PlaceTags that used for 'place' objects in user's city.
On a request basis the filter do:
- if the user is authenticated it returns queryset filtered by the
user's city.
- if the user is UNauthenticated it requires 'city' query param
If an authenticated user passes 'city' query param that is different
from the user's city it returns zero results. It's expected behavior.
"""
city = filters.ModelChoiceFilter(
field_name="places__city",
queryset=City.objects.all(),
)
@property
def qs(self):
parent = super().qs
user = getattr(self.request, "user", None)
if user.is_authenticated:
city = user.profile.city
return parent.filter(places__city=city).distinct()
city_id = self.request.query_params.get("city", None)
if not city_id:
raise CityNotSelected
return parent
class UserFilter(filters.FilterSet):
search = filters.CharFilter(method='filter_search')
course = filters.ModelChoiceFilter(field_name='courses_in',
queryset=Course.objects.all())
class Meta:
model = User
fields = ['search', 'course']
def filter_search(self, queryset, field_name, value):
max_length = 999999
return queryset.filter(
Q(username__icontains=value)
| Q(student_profile__student_id__icontains=value)).annotate(
username_length=Case(
When(username__icontains=value,
then=Length(Replace('username', Value(value)))),
default=Value(max_length),
), ).annotate(student_id_length=Case(
When(student_profile__student_id__icontains=value,
then=Length(
Replace('student_profile__student_id',
Value(value)))),
default=Value(max_length),
), ).order_by(Least('username_length', 'student_id_length'))
class GeoRegionFilter(filters.FilterSet):
id = filters.CharFilter(method='id_filter')
q = filters.CharFilter(method='search_filter')
kind = filters.CharFilter(method='kind_filter')
level = filters.NumberFilter(method='level_filter')
ancestor = filters.ModelChoiceFilter(method='ancestor_filter',
queryset=GeoRegion.objects.all())
class Meta:
model = GeoRegion
fields = ('name', 'level', 'kind', 'slug')
def search_filter(self, queryset, name, value):
return queryset.filter(name__icontains=value)
def kind_filter(self, queryset, name, value):
return queryset.filter(kind=value)
def level_filter(self, queryset, name, value):
return queryset.filter(level=value)
def id_filter(self, queryset, name, value):
ids = value.split(',')
return queryset.filter(pk__in=ids)
def ancestor_filter(self, queryset, name, value):
descendants = value.get_descendants()
return queryset.filter(id__in=descendants)
class PostFilter(filter.FilterSet):
tags = filter.ModelMultipleChoiceFilter(queryset=Tag.objects.all(),
field_name='tags__title',
to_field_name='title')
category = filter.ModelChoiceFilter(queryset=Category.objects.all(),
field_name='category',
to_field_name='title')
author = filter.ModelChoiceFilter(queryset=Author.objects.all(),
field_name='author',
to_field_name='username')
class Meta:
model = Post
fields = ['tags', 'category', 'author']
class MessageFilter(filters.FilterSet):
"""Defines the filter fields for ListMessageView."""
created_date = filters.DateFilter(field_name='created_date',
lookup_expr='exact')
created_date__gt = filters.DateFilter(field_name='created_date',
lookup_expr='gt')
created_date__lt = filters.DateFilter(field_name='created_date',
lookup_expr='lt')
created_date__range = filters.DateFilter(field_name='created_date',
lookup_expr='range')
created_time = filters.TimeFilter(field_name='created_time',
lookup_expr='exact')
created_time__gt = filters.TimeFilter(field_name='created_time',
lookup_expr='gt')
created_time__lt = filters.TimeFilter(field_name='created_time',
lookup_expr='lt')
created_time__range = filters.TimeFilter(field_name='created_time',
lookup_expr='range')
sender = filters.ModelChoiceFilter(queryset=get_user_model().objects.all())
subject = filters.CharFilter(field_name='subject', lookup_expr='icontains')
text = filters.CharFilter(field_name='text', lookup_expr='icontains')
class Meta:
model = Message
fields = ['created_date', 'created_time', 'sender', 'subject', 'text']
class SpreadFilter(filters.FilterSet):
book = filters.ModelChoiceFilter(
queryset=models.Book.objects.all(),
help_text="Spreads from this book ID",
widget=forms.TextInput,
)
sequence = filters.NumberFilter(help_text="Spread sequence index")
class BibleReadFilter(django_filters.FilterSet):
book = filters.ModelChoiceFilter(queryset=Book.objects.all())
class Meta:
model = BibleRead
fields = ('id', 'book', 'start_date')
class DocumentFilter(filters.FilterSet):
topic_model = filters.ModelChoiceFilter(
queryset=text_models.TopicModel.objects.all(),
field_name="topic_models",
widget=forms.TextInput,
)
document_format = filters.ModelChoiceFilter(
queryset=metadata_models.DocumentFormat.objects.all(),
field_name="record__document_format",
)
document_subject = filters.ModelChoiceFilter(
queryset=metadata_models.DocumentSubject.objects.all(),
field_name="record__document_subject",
)
label = filters.CharFilter(lookup_expr="icontains")
topics = filters.ModelChoiceFilter(queryset=text_models.Topic.objects.all())
class ProjectFilter(django_filters.FilterSet):
centres = django_filters.ModelChoiceFilter(
name="centres__city", queryset=City.objects.all())
class Meta:
model = Project
fields = ['project_area', 'centres']