class ReportFilterClass(filters.FilterSet):
query = filters.CharFilter(label='Search')
agency = filters.CharFilter(label='Agency')
country = filters.CharFilter(label='Country')
activity = filters.CharFilter(label='Activity')
activity_type = filters.CharFilter(label='Activity Type')
flag = filters.CharFilter(label='flag')
active = filters.BooleanFilter(label='active')
year = filters.NumberFilter(label='year')
ordering = OrderingFilter(fields=(('score', 'score'), ('name',
'name_sort')))
class ProductFilter(SortedFilterSet):
sort_by = OrderingFilter(
label=pgettext_lazy("Product list sorting form", "Sort by"),
fields=SORT_BY_FIELDS.keys(),
field_labels=SORT_BY_FIELDS,
)
price = RangeFilter(label=pgettext_lazy("Currency amount", "Price"))
class Meta:
model = Product
fields = []
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._merged_attributes = self._get_merged_attributes()
self.filters.update(self._get_attributes_filters())
self.filters = OrderedDict(sorted(self.filters.items()))
def _get_merged_attributes(self):
q_product_attributes = self._get_product_attributes_lookup()
q_variant_attributes = self._get_variant_attributes_lookup()
attributes = (Attribute.objects.all().prefetch_related(
"translations",
"values__translations").filter(q_product_attributes
| q_variant_attributes).distinct())
merged_attributes = MergedAttributes(attributes)
return merged_attributes
def _get_product_attributes_lookup(self):
raise NotImplementedError()
def _get_variant_attributes_lookup(self):
raise NotImplementedError()
def _get_attributes_filters(self):
filters, attributes = {}, self._merged_attributes.get_attributes()
for attr_slug in attributes:
choices = self._merged_attributes.get_choices(attr_slug)
# Rendering attribute with empty values is unnecessary
if not choices:
continue
filters[attr_slug] = AttributeMultipleChoiceFilter(
merged_attributes=self._merged_attributes,
# By default the translated name of the first one in
# attributes with same slug is used
label=attributes[attr_slug][0].translated.name,
widget=CheckboxSelectMultiple,
choices=choices,
)
return filters
class StockLocationFilter(SortedFilterSet):
sort_by = OrderingFilter(label=pgettext_lazy(
'Stock location list filter label', 'Sort by'),
fields=STOCK_LOCATION_SORT_BY_FIELDS.keys(),
field_labels=STOCK_LOCATION_SORT_BY_FIELDS)
name = CharFilter(label=pgettext_lazy('Stock location list filter label',
'Name'),
lookup_expr='icontains')
class Meta:
model = StockLocation
fields = []
class ArticleFilter(FilterSet):
class Meta:
model = Article
fields = ['authors', 'title', 'standfirst', 'body', 'created_at', 'frontpage']
order_by = OrderingFilter(
fields=(
('created_at', 'created_at'),
('title', 'title'),
('frontpage', 'frontpage')
)
)
class ClosedFindingFilter(DojoFilter):
title = CharFilter(lookup_expr='icontains')
mitigated = DateRangeFilter(label="Mitigated Date")
cwe = MultipleChoiceFilter(choices=[])
severity = MultipleChoiceFilter(choices=[])
test__test_type = ModelMultipleChoiceFilter(
queryset=Test_Type.objects.all())
test__engagement__product = ModelMultipleChoiceFilter(
queryset=Product.objects.all(), label="Product")
test__engagement__product__prod_type = ModelMultipleChoiceFilter(
queryset=Product_Type.objects.all(), label="Product Type")
o = OrderingFilter(
# tuple-mapping retains order
fields=(
('numerical_severity', 'numerical_severity'),
('date', 'date'),
('mitigated', 'mitigated'),
('title', 'title'),
('test__engagement__product__name',
'test__engagement__product__name'),
),
field_labels={
'numerical_severity': 'Severity',
'date': 'Date',
'mitigated': 'Mitigated Date',
'title': 'Finding Name',
'test__engagement__product__name': 'Product Name',
})
class Meta:
model = Finding
exclude = [
'url', 'description', 'mitigation', 'impact', 'endpoint',
'references', 'test', 'is_template', 'active', 'verified',
'out_of_scope', 'false_p', 'duplicate', 'thread_id', 'date',
'notes', 'numerical_severity', 'reporter', 'endpoints',
'last_reviewed'
]
def __init__(self, *args, **kwargs):
super(ClosedFindingFilter, self).__init__(*args, **kwargs)
cwe = dict()
cwe = dict([finding.cwe, finding.cwe]
for finding in self.queryset.distinct()
if finding.cwe > 0 and finding.cwe not in cwe)
cwe = collections.OrderedDict(sorted(cwe.items()))
self.form.fields['cwe'].choices = cwe.items()
sevs = dict()
sevs = dict([finding.severity, finding.severity]
for finding in self.queryset.distinct()
if finding.severity not in sevs)
self.form.fields['severity'].choices = sevs.items()
class ProductFindingFilter(DojoFilter):
title = CharFilter(lookup_expr='icontains')
sourcefile = CharFilter(lookup_expr='icontains')
sourcefilepath = CharFilter(lookup_expr='icontains')
param = CharFilter(lookup_expr='icontains')
payload = CharFilter(lookup_expr='icontains')
date = DateRangeFilter()
cwe = MultipleChoiceFilter(choices=[])
severity = MultipleChoiceFilter(choices=[])
test__test_type = ModelMultipleChoiceFilter(
queryset=Test_Type.objects.all())
o = OrderingFilter(
# tuple-mapping retains order
fields=(
('numerical_severity', 'numerical_severity'),
('date', 'date'),
('test__engagement__risk_acceptance__created',
'test__engagement__risk_acceptance__created'),
('title', 'title'),
('test__engagement__product__name',
'test__engagement__product__name'),
),
field_labels={
'numerical_severity': 'Severity',
'date': 'Finding Date',
'test__engagement__risk_acceptance__created': 'Acceptance Date',
'title': 'Finding Name',
'test__engagement__product__name': 'Product Name',
}
)
class Meta:
model = Finding
exclude = ['url', 'description', 'mitigation', 'impact',
'endpoint', 'references', 'test', 'is_template',
'active', 'verified', 'out_of_scope', 'false_p',
'duplicate_list', 'duplicate_finding', 'thread_id', 'mitigated', 'notes',
'numerical_severity', 'reporter', 'endpoints',
'last_reviewed', 'jira_creation', 'jira_change']
def __init__(self, *args, **kwargs):
super(ProductFindingFilter, self).__init__(*args, **kwargs)
cwe = dict()
cwe = dict([finding.cwe, finding.cwe]
for finding in self.queryset.distinct()
if finding.cwe > 0 and finding.cwe not in cwe)
cwe = collections.OrderedDict(sorted(cwe.items()))
self.form.fields['cwe'].choices = list(cwe.items())
self.form.fields['severity'].choices = self.queryset.order_by(
'numerical_severity'
).values_list('severity', 'severity').distinct()
class OpenFindingFilter(DojoFilter):
title = CharFilter(lookup_expr='icontains')
date = DateRangeFilter()
last_reviewed = DateRangeFilter()
cwe = MultipleChoiceFilter(choices=[])
severity = MultipleChoiceFilter(choices=[])
test__test_type = ModelMultipleChoiceFilter(
queryset=Test_Type.objects.all())
test__engagement__product = ModelMultipleChoiceFilter(
queryset=Product.objects.all(), label="Product")
o = OrderingFilter(
# tuple-mapping retains order
fields=(
('numerical_severity', 'numerical_severity'),
('date', 'date'),
('last_reviewed', 'last_reviewed'),
('title', 'title'),
('test__engagement__product__name',
'test__engagement__product__name'),
), )
class Meta:
model = Finding
exclude = [
'url', 'description', 'mitigation', 'impact', 'endpoint',
'references', 'test', 'is_template', 'active', 'verified',
'out_of_scope', 'false_p', 'duplicate', 'thread_id', 'mitigated',
'notes', 'numerical_severity', 'reporter', 'last_reviewed'
]
def __init__(self, *args, **kwargs):
self.user = None
if 'user' in kwargs:
self.user = kwargs.pop('user')
super(OpenFindingFilter, self).__init__(*args, **kwargs)
cwe = dict()
cwe = dict([finding.cwe, finding.cwe]
for finding in self.queryset.distinct()
if finding.cwe > 0 and finding.cwe not in cwe)
cwe = collections.OrderedDict(sorted(cwe.items()))
self.form.fields['cwe'].choices = cwe.items()
sevs = dict()
sevs = dict([finding.severity, finding.severity]
for finding in self.queryset.distinct()
if finding.severity not in sevs)
self.form.fields['severity'].choices = sevs.items()
if self.user is not None and not self.user.is_staff:
self.form.fields[
'test__engagement__product'].queryset = Product.objects.filter(
authorized_users__in=[self.user])
self.form.fields['endpoints'].queryset = Endpoint.objects.filter(
product__authorized_users__in=[self.user]).distinct()
class MediaFilter(django_filters.FilterSet):
class Meta:
model = Media
fields = {
'id': ['exact'],
'create_time': ['exact', 'gte', 'lte'],
# ---------- Uploader ------------
'uploader_id': ['exact'],
'uploader__username': ['exact', 'icontains', 'istartswith'],
}
order_by = OrderingFilter(fields=('id', 'order', 'create_time'))
class CategoryFilter(SortedFilterSet):
name = CharFilter(
label=pgettext_lazy('Category list filter label', 'Name'),
lookup_expr='icontains')
sort_by = OrderingFilter(
label=pgettext_lazy('Category list sorting filter label', 'Sort by'),
fields=SORT_BY_FIELDS.keys(),
field_labels=SORT_BY_FIELDS)
class Meta:
model = Category
fields = []
class QuickLearningUnitYearFilter(FilterSet):
academic_year = filters.ModelChoiceFilter(
queryset=AcademicYear.objects.all(),
required=False,
label=_('Ac yr.'),
empty_label=pgettext_lazy("plural", "All"),
)
acronym = filters.CharFilter(
field_name="acronym",
lookup_expr="iregex",
max_length=40,
required=False,
label=_('Code'),
)
title = filters.CharFilter(
field_name="full_title",
lookup_expr="icontains",
max_length=40,
label=_('Title'),
)
ordering = OrderingFilter(fields=(
('academic_year__year', 'academic_year'),
('acronym', 'acronym'),
('full_title', 'title'),
),
widget=forms.HiddenInput)
class Meta:
model = LearningUnitYear
fields = [
"academic_year",
"acronym",
"title",
]
def __init__(self, *args, initial=None, **kwargs):
super().__init__(*args, **kwargs)
self.queryset = self.get_queryset()
if initial:
self.form.fields["academic_year"].initial = initial[
"academic_year"]
def get_queryset(self):
# Need this close so as to return empty query by default when form is unbound
if not self.data:
return LearningUnitYear.objects.none()
queryset = LearningUnitYear.objects_with_container.select_related(
'academic_year', )
queryset = LearningUnitYearQuerySet.annotate_full_title_class_method(
queryset)
return queryset
class UserFilter(SortedFilterSet):
name_or_email = CharFilter(label=pgettext_lazy(
'Customer name or email filter', 'Name or email'),
method='filter_by_customer')
location = CharFilter(label=pgettext_lazy('Customer list filter label',
'Location'),
method='filter_by_location')
is_active = ChoiceFilter(label=pgettext_lazy('Customer list filter label',
'Is active'),
choices=IS_ACTIVE_CHOICES,
empty_label=pgettext_lazy(
'Filter empty choice label', 'All'),
widget=forms.Select)
sort_by = OrderingFilter(label=pgettext_lazy('Customer list filter label',
'Sort by'),
fields=SORT_BY_FIELDS,
field_labels=SORT_BY_FIELDS_LABELS)
class Meta:
model = User
fields = []
def filter_by_customer(self, queryset, name, value):
return queryset.filter(
Q(email__icontains=value)
| Q(default_billing_address__first_name__icontains=value)
| Q(default_billing_address__last_name__icontains=value))
def filter_by_location(self, queryset, name, value):
q = Q(default_billing_address__city__icontains=value)
q |= Q(default_billing_address__country__icontains=value)
country_codes = self.get_mapped_country_codes_from_search(value)
for code in country_codes:
q |= Q(default_billing_address__country__icontains=code)
return queryset.filter(q)
def get_mapped_country_codes_from_search(self, value):
country_codes = []
for code, country in dict(countries).items():
if value.lower() in country.lower():
country_codes.append(code)
return country_codes
def get_summary_message(self):
counter = self.qs.count()
return npgettext(
'Number of matching records in the dashboard customers list',
'Found %(counter)d matching customer',
'Found %(counter)d matching customers',
number=counter) % {
'counter': counter
}
class Meta:
model = Article
fields = "__all__"
filter_fields = {
'titre': ['exact', 'icontains', 'istartswith'],
}
order_by = OrderingFilter(fields=(
('date_add', 'date_add'),
('nb_like', 'nb_like'),
))
interfaces = (relay.Node, )
connection_class = ExtendConnection
class ProductFilter(DistinctFilterSet):
sort_by = OrderingFilter(fields=PRODUCT_SORT_BY_FIELDS.keys(),
field_labels=PRODUCT_SORT_BY_FIELDS)
class Meta:
model = Product
fields = {
'name': ['exact', 'icontains'],
'product_type__name': ['exact'],
'price': ['exact', 'range', 'lte', 'gte'],
'is_published': ['exact'],
'is_featured': ['exact'],
}
class StaffFilter(UserFilter):
groups = ModelMultipleChoiceFilter(label=pgettext_lazy(
'Staff list filter label', 'Groups'),
name='groups',
queryset=Group.objects.all())
sort_by = OrderingFilter(label=pgettext_lazy('Staff list filter label',
'Sort by'),
fields=SORT_BY_FIELDS,
field_labels=SORT_BY_FIELDS_LABELS)
class Meta:
model = User
fields = []
class ProductFilter(FilterSet):
def __init__(self, *args, **kwargs):
self.category = kwargs.pop('category')
super(ProductFilter, self).__init__(*args, **kwargs)
self.product_attributes, self.variant_attributes = (
self._get_attributes())
self.filters.update(self._get_product_attributes_filters())
self.filters.update(self._get_product_variants_attributes_filters())
self.filters = OrderedDict(sorted(self.filters.items()))
sort_by = OrderingFilter(label='Sort by',
fields=[(field['value'], field['value'])
for field in SORT_BY_FIELDS])
class Meta:
model = Product
fields = ['price']
filter_overrides = {PriceField: {'filter_class': RangeFilter}}
def _get_attributes(self):
product_attributes = (
ProductAttribute.objects.all().prefetch_related('values').filter(
products_class__products__categories=self.category).distinct())
variant_attributes = (
ProductAttribute.objects.all().prefetch_related('values').filter(
product_variants_class__products__categories=self.category).
distinct())
return product_attributes, variant_attributes
def _get_product_attributes_filters(self):
filters = {}
for attribute in self.product_attributes:
filters[attribute.slug] = MultipleChoiceFilter(
name='attributes__%s' % attribute.pk,
label=attribute.name,
widget=CheckboxSelectMultiple,
choices=self._get_attribute_choices(attribute))
return filters
def _get_product_variants_attributes_filters(self):
filters = {}
for attribute in self.variant_attributes:
filters[attribute.slug] = MultipleChoiceFilter(
name='variants__attributes__%s' % attribute.pk,
label=attribute.name,
widget=CheckboxSelectMultiple,
choices=self._get_attribute_choices(attribute))
return filters
def _get_attribute_choices(self, attribute):
return [(choice.pk, choice.name) for choice in attribute.values.all()]
class VoucherFilter(SortedFilterSet):
name = CharFilter(label=pgettext_lazy('Voucher list name filter label',
'Name'),
lookup_expr='icontains')
type = ChoiceFilter(name='discount_value_type',
label=pgettext_lazy(
'Sale list is sale type filter label',
'Discount type'),
choices=DISCOUNT_TYPE_CHOICES,
empty_label=pgettext_lazy('Filter empty choice label',
'All'),
widget=forms.Select)
discount_value = RangeFilter(
label=pgettext_lazy('Sale list filter label', 'Discount_value'))
date = DateFromToRangeFilter(label=pgettext_lazy(
'Order list sorting filter label', 'Period of validity'),
name='created',
widget=DateRangeWidget,
method='filter_by_date_range')
limit = RangeFilter(label=pgettext_lazy('Voucher list sorting filter',
'Limit'),
name='limit')
sort_by = OrderingFilter(label=pgettext_lazy(
'Voucher list sorting filter label', 'Sort by'),
fields=SORT_BY_FIELDS_LABELS_VOUCHER.keys(),
field_labels=SORT_BY_FIELDS_LABELS_VOUCHER)
class Meta:
model = Voucher
fields = []
def filter_by_date_range(self, queryset, name, value):
q = Q()
if value.start:
q = Q(start_date__gte=value.start)
if value.stop:
if value.start:
q |= Q(end_date__lte=value.stop)
else:
q = Q(end_date__lte=value.stop)
return queryset.filter(q)
def get_summary_message(self):
counter = self.qs.count()
return npgettext(
'Number of matching records in the dashboard vouchers list',
'Found %(counter)d matching voucher',
'Found %(counter)d matching vouchers',
number=counter) % {
'counter': counter
}
class IngredientFilter(FilterSet):
order_by = OrderingFilter(fields=(
('name', 'name'),
('notes', 'notes'),
('category__name', 'category__name'),
))
class Meta:
model = Ingredient
fields = (
'name',
'notes',
'category__name',
)
class DepartmentsTemplateTableFilter(SearchFieldFilterSet):
"""
Filter for Departments filtering and template table column sorting.
"""
searching_fields = ['id', 'name', 'organization__name']
ordering = OrderingFilter(fields=(('id', 'id'), ('organization__name',
'organization__name'),
('name', 'name')))
class Meta:
model = Department
form = DepartmentsTableFilterFlexForm
fields = ['organization']
class CitiesTemplateTableFilter(SearchFieldFilterSet):
"""
Filter for Cities filtering and template table column sorting.
"""
searching_fields = ['id', 'name', 'country__name']
ordering = OrderingFilter(fields=(('id', 'id'), ('country__name',
'country__name'),
('name', 'name')))
class Meta:
model = City
form = CitiesTableFilterFlexForm
fields = ['country']
class UserFilter(FilterSet):
class Meta:
model = User
fields = {
'created_on': ['exact', 'lte', 'gte'],
'modified_on': ['exact', 'lte', 'gte'],
"id": ['exact'],
'email': ['exact', 'icontains'],
'first_name': ['exact', 'icontains'],
'last_name': ['exact', 'icontains'],
}
order_by = OrderingFilter(fields=('created_on', 'modified_on', 'email',
'first_name', 'last_name'))
class TestTypeFilter(DojoFilter):
name = CharFilter(lookup_expr='icontains')
o = OrderingFilter(
# tuple-mapping retains order
fields=(
('name', 'name'),
),
)
class Meta:
model = Test_Type
exclude = []
include = ('name',)
class DevelopmentEnvironmentFilter(DojoFilter):
name = CharFilter(lookup_expr='icontains')
o = OrderingFilter(
# tuple-mapping retains order
fields=(
('name', 'name'),
),
)
class Meta:
model = Development_Environment
exclude = []
include = ('name',)
class AssetGroupFilter(FilterSet):
sorted_by = OrderingFilter(choices=(
('name', _('Name')),
('-name', _('Name (desc)')),
('criticity', _('Criticity')),
('-criticity', _('Criticity (desc)')),
))
class Meta:
model = AssetGroup
fields = {
'name': ['icontains'],
'description': ['icontains'],
}
class StockFilter(FilterSet):
currency = CharFilter(field_name='currency__code', lookup_expr='icontains')
owner = CharFilter(field_name='owner__username', lookup_expr='icontains')
amount = CharFilter(lookup_expr='icontains')
order_by = OrderingFilter(fields=(
('currency__code', 'currency'),
('owner__username', 'owner'),
('ammount', 'ammount'),
))
@property
def qs(self):
# The query context can be found in self.request.
return super().qs
class OrderFilter(SortedFilterSet):
id = NumberFilter(label=pgettext_lazy('Order list filter label', 'ID'))
name_or_email = CharFilter(label=pgettext_lazy('Order list filter label',
'Customer name or email'),
method='filter_by_order_customer')
created = DateFromToRangeFilter(label=pgettext_lazy(
'Order list filter label', 'Placed on'),
field_name='created',
widget=DateRangeWidget)
status = ChoiceFilter(label=pgettext_lazy('Order list filter label',
'Order status'),
choices=OrderStatus.CHOICES,
empty_label=pgettext_lazy(
'Filter empty choice label', 'All'),
widget=forms.Select)
payment_status = ChoiceFilter(
label=pgettext_lazy('Order list filter label', 'Payment status'),
field_name='payments__status',
choices=ChargeStatus.CHOICES,
empty_label=pgettext_lazy('Filter empty choice label', 'All'),
widget=forms.Select)
total_net = RangeFilter(label=pgettext_lazy('Order list filter label',
'Total'),
widget=MoneyRangeWidget)
sort_by = OrderingFilter(label=pgettext_lazy('Order list filter label',
'Sort by'),
fields=SORT_BY_FIELDS,
field_labels=SORT_BY_FIELDS_LABELS)
class Meta:
model = Order
fields = []
def filter_by_order_customer(self, queryset, name, value):
return queryset.filter(
Q(user__email__icontains=value)
| Q(user__first_name__icontains=value)
| Q(user__last_name__icontains=value)
| Q(user__default_billing_address__first_name__icontains=value)
| Q(user__default_billing_address__last_name__icontains=value))
def get_summary_message(self):
counter = self.qs.count()
return npgettext(
'Number of matching records in the dashboard orders list',
'Found %(counter)d matching order',
'Found %(counter)d matching orders',
number=counter) % {
'counter': counter
}
class ProductListFilter(SortedFilterSet):
sort_by = OrderingFilter(label=pgettext_lazy('Product list sorting form',
'Sort by'),
fields=SORT_BY_FIELDS.keys(),
field_labels=SORT_BY_FIELDS)
price = RangeFilter(label=pgettext_lazy('Currency amount', 'Price'))
class Meta:
model = Product
fields = []
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.product_attributes, self.variant_attributes = (
self._get_attributes())
self.filters.update(self._get_product_attributes_filters())
self.filters.update(self._get_product_variants_attributes_filters())
self.filters = OrderedDict(sorted(self.filters.items()))
def _get_attributes(self):
product_attributes = (Attribute.objects.all().prefetch_related(
'translations', 'values__translations').distinct())
variant_attributes = (Attribute.objects.all().prefetch_related(
'translations', 'values__translations').distinct())
return product_attributes, variant_attributes
def _get_product_attributes_filters(self):
filters = {}
for attribute in self.product_attributes:
filters[attribute.slug] = MultipleChoiceFilter(
field_name='attributes__%s' % attribute.pk,
label=attribute.translated.name,
widget=CheckboxSelectMultiple,
choices=self._get_attribute_choices(attribute))
return filters
def _get_product_variants_attributes_filters(self):
filters = {}
for attribute in self.variant_attributes:
filters[attribute.slug] = MultipleChoiceFilter(
field_name='variants__attributes__%s' % attribute.pk,
label=attribute.translated.name,
widget=CheckboxSelectMultiple,
choices=self._get_attribute_choices(attribute))
return filters
def _get_attribute_choices(self, attribute):
return [(choice.pk, choice.translated.name)
for choice in attribute.values.all()]
class ProductFilterSet(FilterSet):
genre = CharFilter(name='genre__slug')
artist = CharFilter(name='artist__slug')
medium_type = CharFilter(name='medium_type__name')
min_price = NumberFilter(name='price', lookup_expr='gte')
max_price = NumberFilter(name='price', lookup_expr='lte')
label = CharFilter(name='label__slug')
ordering = OrderingFilter(fields=(('price', 'price'), ('-price',
'-price')))
tags = TagsFilter(name='tags__name')
class Meta:
model = Product
fields = ('genre', 'artist', 'medium_type', 'min_price', 'max_price',
'label', 'ordering', 'tags')
class PublicBilbyJobFilter(FilterSet):
class Meta:
model = BilbyJob
fields = '__all__'
order_by = OrderingFilter(
fields=(
('last_updated', 'last_updated'),
('name', 'name'),
)
)
@property
def qs(self):
return BilbyJob.public_bilby_job_filter(super(PublicBilbyJobFilter, self).qs, self)
class GroupFilter(SortedFilterSet):
name = CharFilter(label=pgettext_lazy('Group list filter label', 'Name'),
lookup_expr='icontains')
permissions = ModelMultipleChoiceFilter(label=pgettext_lazy(
'Group list filter label', 'Permissions'),
name='permissions',
queryset=get_permissions())
sort_by = OrderingFilter(label=pgettext_lazy('Group list filter label',
'Sort by'),
fields=SORT_BY_FIELDS.keys(),
field_labels=SORT_BY_FIELDS)
class Meta:
model = Group
fields = []
class TimetableFilter(FilterSet):
order_by = OrderingFilter(
fields=[('id', 'id'), ('name', 'name'), (
'cycle_length',
'cycle_length'), ('ref_cycle_length', 'ref_cycle_length'),
('ref_cycle_date',
'ref_cycle_date'), ('inactive_weekdays', 'inactive_weekdays'),
('is_active', 'is_active'), (
'date_created',
'date_created'), ('date_modified', 'date_modified')])
class Meta:
fields = {'name': ['icontains']}
model = Timetable
