class EventFilter(django_filters.FilterSet):
"""Filtering for Calendar Events"""
event_type = django_filters.ChoiceFilter(choices=CAL_EVENT_CHOICES)
transparent = django_filters.BooleanFilter(
widget=django_filters.widgets.BooleanWidget()
)
class Meta:
model = CalendarEvent
fields = {
"name": ["icontains"],
"attendees": ["exact"],
"attendee_event__status": ["exact"],
"owner": ["exact"],
"dt_start": ["gte"],
"dt_end": ["lte"],
"description": ["icontains"],
"location": ["icontains"],
"notes": ["icontains"],
}
class RedressalGrievanceFilter(django_filters.FilterSet):
sub_category = django_filters.ModelChoiceFilter(queryset=sub_cats)
subject = django_filters.CharFilter(lookup_expr='icontains', label='Subject')
status = django_filters.ChoiceFilter(choices=STATUS_VISIBLE_TO_COMMITTEE)
o = django_filters.OrderingFilter(
# tuple-mapping retains order
fields=(
('last_update', 'last_update'),
('sub_category', 'sub_category'),
),
# labels do not need to retain order
field_labels={
'last_update': 'Last Update',
'sub_category': 'Sub Category',
}
)
class Meta:
model = Grievance
fields = ['subject', 'sub_category', 'status']
class BuildingBlockTemplateFilter(ActiveFilterMixin, django_filters.FilterSet):
term = django_filters.CharFilter(method="filter_by_term")
type = django_filters.ChoiceFilter(choices=BuildingBlockType.choices,
field_name="building_block_type")
status = django_filters.MultipleChoiceFilter(
choices=BuildingBlockStatus.choices, field_name="status")
duration_start = django_filters.DurationFilter(field_name="duration",
lookup_expr="gte")
duration_end = django_filters.DurationFilter(field_name="duration",
lookup_expr="lte")
category = MultipleUUIDFilter()
theme = MultipleUUIDFilter()
created_by = MultipleUUIDFilter()
class Meta:
model = BuildingBlockTemplate
fields = []
def filter_by_term(self, queryset, name, value):
return queryset.filter(
Q(title__icontains=value) | Q(description__icontains=value))
class MediaTestimonialsFossFilter(django_filters.FilterSet):
foss = django_filters.ChoiceFilter(choices=FossCategory.objects.none())
def __init__(self, *args, **kwargs):
super(MediaTestimonialsFossFilter, self).__init__(*args, **kwargs)
choices = None
choices = list(
FossCategory.objects.filter(
id__in=MediaTestimonials.objects.filter().values(
'foss_id').distinct()).order_by('foss').values_list(
'id', 'foss'))
choices.insert(
0,
('', '---------'),
)
self.filters['foss'].extra.update({'choices': choices})
class Meta:
model = MediaTestimonials
fields = ['foss']
class AdsFilter(django_filters.FilterSet):
CHOICES = (
('ascending', 'Сначала старые'),
('descending', 'Сначала новые'),
('cheap', 'Сначала дешевые'),
('uncheap', 'Сначала дорогие'),
)
ordering = django_filters.ChoiceFilter(label='Ordering',
choices=CHOICES,
method='filter_by_order')
class Meta:
model = Ad
fields = ('brand', 'year')
def filter_by_order(self, queryset, name, value):
expression = 'created_at' if value == 'ascending' else '-created_at'
expression2 = 'price' if value == 'cheap' else '-price'
return queryset.order_by(expression, expression2)
class FARfilter(django_filters.FilterSet):
CHOICES = [
('ascending','Ascending'),
('descending','Descending'),
]
ordering = django_filters.ChoiceFilter(label='Ordering', choices= CHOICES , method='filter_by_order')
class Meta:
model = FAR_DB
fields = {
'equ_type' : ['icontains'],
'serial_num' : ['icontains'],
'BU' : ['icontains'],
'temp_location' : ['icontains'],
# 'description' : ['icontains'],
'BL' : ['icontains'],
}
def filter_by_order(self,queryset, name, value):
expression = 'description' if value == 'ascending' else '-description'
return queryset.order_by(expression)
class DomainFilter(django_filters.FilterSet):
"""Filter used to search the `Domain` model."""
name = django_filters.CharFilter(lookup_expr='icontains')
all_cat = django_filters.CharFilter(lookup_expr='icontains')
health_status = django_filters.ModelMultipleChoiceFilter(
queryset=HealthStatus.objects.all(),
widget=forms.CheckboxSelectMultiple)
domain_status = django_filters.ModelMultipleChoiceFilter(
queryset=DomainStatus.objects.all(),
widget=forms.CheckboxSelectMultiple)
STATUS_CHOICES = (
(0, 'Active'),
(1, 'Expired'),
)
expiration_status = django_filters.ChoiceFilter(field_name='expired',
choices=STATUS_CHOICES)
class Meta:
model = Domain
fields = ['name', 'all_cat', 'health_status', 'domain_status']
class orderFilters(django_filters.FilterSet):
CHOICES = (
('ascending', 'Menor precio'),
('descending', 'Mayor precio'),
)
ordering = django_filters.ChoiceFilter(label='Ordering',
choices=CHOICES,
method='filter_by_order')
class Meta:
model = Product
fields = {
'name': ['icontains'],
}
exclude = ['desc', 'created_at', 'updated_at', 'img', 'digital']
def filter_by_order(self, queryset, name, price):
var = 'price' if price == 'ascending' else '-price'
return queryset.order_by(var)
class Employeefilter(django_filters.FilterSet):
CHOICES = [
('ascending', 'Ascending'),
('descending', 'Descending'),
]
ordering = django_filters.ChoiceFilter(label='Ordering',
choices=CHOICES,
method='filter_by_order')
class Meta:
model = EmployeeDB
fields = {
'OSID': ['icontains'],
'first_name': ['icontains'],
'BL': ['icontains'],
# 'grade' : ['icontains'],
}
def filter_by_order(self, queryset, name, value):
expression = 'first_name' if value == 'ascending' else '-description'
return queryset.order_by(expression)
class CrowdsourceFilterSet(django_filters.FilterSet):
"""Filtering for crowdsources for admins"""
status = django_filters.ChoiceFilter(choices=(("draft", "Draft"), ("open",
"Open"),
("close", "Closed")))
is_staff = django_filters.BooleanFilter(
field_name="user__is_staff",
label="Staff Owned",
widget=forms.Select(choices=NULL_BOOLEAN_CHOICES),
)
user = django_filters.ModelChoiceFilter(
queryset=User.objects.all(),
widget=autocomplete.ModelSelect2(
url="user-autocomplete",
attrs={"data-placeholder": "Search users"}),
)
class Meta:
model = Crowdsource
fields = ["status", "user"]
class SnippetFilter(django_filters.FilterSet):
CHOICES = (('ascending', 'Ascending'), ('descending', 'Descending'))
ordering = django_filters.ChoiceFilter(label='Ordering',
choices=CHOICES,
method='filter_by_order')
class Meta:
model = Snippet
# the following attribute only works for exact full search
# fields = ('title', 'body')
# In order to capture results that just contain the search parameter, set fields to a dictionary and use 'icontains'
fields = {
'title': ['icontains'],
'body': ['icontains'],
}
def filter_by_order(self, queryset, name, value):
expression = 'created' if value == 'ascending' else '-created'
return queryset.order_by(expression)
class RelatorioMateriasPorAnoAutorTipoFilterSet(django_filters.FilterSet):
ano = django_filters.ChoiceFilter(required=True,
label='Ano da Matéria',
choices=RANGE_ANOS)
class Meta:
model = MateriaLegislativa
fields = ['ano']
def __init__(self, *args, **kwargs):
super(RelatorioMateriasPorAnoAutorTipoFilterSet,
self).__init__(*args, **kwargs)
row1 = to_row([('ano', 12)])
self.form.helper = FormHelper()
self.form.helper.form_method = 'GET'
self.form.helper.layout = Layout(
Fieldset(_('Pesquisar'), row1,
form_actions(save_label='Pesquisar')))
class TorrentSortingFilter(django_filters.FilterSet):
ORDER_CHOICE = (
('date_uploaded', 'Sort by Time'),
('total_size', 'Sort by Size'),
('seeders', 'Sort by Seeders'),
('leeches', 'Sort by Leeches'),
)
sorting = django_filters.ChoiceFilter(label='sorting',
choices=ORDER_CHOICE,
method='filter_by_order')
class Meta:
model = models.Torrent
fields = ('sorting', )
def filter_by_order(self, queryset, name, value):
expression = '-' + value
return queryset.order_by(expression)
class DayFilter(filters.FilterSet):
date__gte = filters.DateFilter(
label=_('After'),
field_name='date',
lookup_expr='gte',
widget=forms.DateInput(attrs={'placeholder': _('MM/DD/YYYY')}, ),
)
date__lte = filters.DateFilter(
label=_('Before'),
field_name='date',
lookup_expr='lte',
widget=forms.DateInput(attrs={'placeholder': _('MM/DD/YYYY')}, ),
)
day_type = filters.ChoiceFilter(
empty_label=_('All'),
choices=DayType.objects.values_list('id', 'name'),
)
class Meta:
model = Day
fields = []
class TasksFilterSet(django_filters.FilterSet):
search = MultiFieldFilter([
'name', 'short_description', 'why_this_matters', 'prerequisites',
'instructions', 'keyword_set__name'
],
label=_lazy(u'Search for tasks'))
difficulty = django_filters.ChoiceFilter(
choices=(('', _lazy(u'Any')), (Task.BEGINNER, _lazy(u'Beginner')),
(Task.INTERMEDIATE, _lazy(u'Intermediate')),
(Task.ADVANCED, _lazy(u'Advanced'))),
label=_lazy(u'Task Difficulty'),
required=False)
execution_time = django_filters.MultipleChoiceFilter(
choices=((15, 15), (30, 30), (45, 45), (60, 60)),
widget=HorizCheckboxSelect,
label=_lazy(u'Estimated minutes'))
team = django_filters.ModelMultipleChoiceFilter(
label=_lazy(u'Team'),
queryset=TaskTeam.objects.all(),
widget=forms.CheckboxSelectMultiple)
project = django_filters.ModelMultipleChoiceFilter(
label=_lazy(u'Project'),
queryset=TaskProject.objects.all(),
widget=forms.CheckboxSelectMultiple)
type = django_filters.ModelMultipleChoiceFilter(
label=_lazy(u'Type'),
queryset=TaskType.objects.all(),
widget=forms.CheckboxSelectMultiple)
keyword = django_filters.CharFilter(name='keyword_set__name')
class Meta:
model = Task
fields = ('search', 'difficulty', 'execution_time', 'team', 'project',
'type', 'keyword')
class IssueFilter(django_filters.FilterSet):
date = django_filters.ChoiceFilter(choices=CREATION_CHOICES,
method='filter_by_date')
date_gte = django_filters.DateFilter(
field_name='date',
lookup_expr='gte',
widget=forms.TextInput(attrs={'autocomplete': 'off'}))
date_lte = django_filters.DateFilter(
field_name='date',
lookup_expr='lte',
widget=forms.TextInput(attrs={'autocomplete': 'off'}))
assigned_to = django_filters.ModelChoiceFilter(
queryset=User.objects.filter(is_staff=True).order_by('username'),
widget=forms.Select(attrs={"class": "form-control"}))
class Meta:
model = Issue
fields = ['category', 'sub_category', 'status', 'assigned_to']
def filter_by_date(self, queryset, name, value):
if value == 'today':
return queryset.filter(date=date.today())
elif value == 'yesterday':
return queryset.filter(date=date.today() - timedelta(1))
elif value == 'last_7_days':
return queryset.filter(date__gte=date.today() - timedelta(7),
date__lte=date.today())
elif value == 'last_30_days':
return queryset.filter(date__gte=date.today() - timedelta(30),
date__lte=date.today())
elif value == 'this_month':
return queryset.filter(date__month=date.today().month,
date__year=date.today().year)
elif value == 'last_month':
month = date.today().month - 1 if date.today().month != 1 else 12
year = date.today(
).year if date.today().month != 1 else date.today().year - 1
return queryset.filter(date__month=month, date__year=year)
else:
return queryset
class NormaFilterSet(django_filters.FilterSet):
filter_overrides = {
models.DateField: {
'filter_class': django_filters.DateFromToRangeFilter,
'extra': lambda f: {
'label': '%s (%s)' % (f.verbose_name, _('Inicial - Final')),
'widget': RangeWidgetOverride
}
}
}
ano = django_filters.ChoiceFilter(required=False,
label='Ano',
choices=ANO_CHOICES)
ementa = django_filters.CharFilter(lookup_expr='icontains')
assuntos = django_filters.ModelChoiceFilter(
queryset=AssuntoNorma.objects.all())
class Meta:
model = NormaJuridica
fields = [
'tipo', 'numero', 'ano', 'data', 'data_publicacao', 'ementa',
'assuntos'
]
def __init__(self, *args, **kwargs):
super(NormaFilterSet, self).__init__(*args, **kwargs)
row1 = to_row([('tipo', 4), ('numero', 4), ('ano', 4)])
row2 = to_row([('data', 6), ('data_publicacao', 6)])
row3 = to_row([('ementa', 8), ('assuntos', 4)])
self.form.helper = FormHelper()
self.form.helper.form_method = 'GET'
self.form.helper.layout = Layout(
Fieldset(_('Pesquisa de Norma'), row1, row2, row3,
form_actions(label='Pesquisar')))
class PostFilter(FilterSet):
type = django_filters.ChoiceFilter(
field_name='type',
choices=Post.POSITIONS,
lookup_expr='icontains',
widget=forms.Select(attrs={'class': 'form-control'}),
)
author = django_filters.CharFilter(
field_name='author_id__user_id__username',
lookup_expr='icontains',
widget=forms.TextInput(attrs={'class': 'form-control'}),
)
title = django_filters.CharFilter(
field_name='title',
lookup_expr='icontains',
widget=forms.TextInput(attrs={
'class': 'form-control',
'placeholder': 'Название'
}),
)
date = django_filters.DateFilter(
field_name='date',
widget=forms.DateInput(attrs={
'type': 'date',
'class': 'form-control'
}),
lookup_expr='gt',
)
categories = django_filters.ModelChoiceFilter(
field_name='categories',
widget=forms.CheckboxSelectMultiple(
attrs={'class': 'form-check-input'}),
queryset=Category.objects.all(),
method='categories_filter')
class Meta:
model = Post
fields = ['type', 'author', 'title', 'date', 'categories']
class RelatorioMateriasTramitacaoilterSet(django_filters.FilterSet):
ano = django_filters.ChoiceFilter(required=True,
label='Ano da Matéria',
choices=RANGE_ANOS)
tramitacao__unidade_tramitacao_destino = django_filters.ModelChoiceFilter(
queryset=UnidadeTramitacao.objects.all(), label=_('Unidade Atual'))
tramitacao__status = django_filters.ModelChoiceFilter(
queryset=StatusTramitacao.objects.all(), label=_('Status Atual'))
@property
def qs(self):
parent = super(RelatorioMateriasTramitacaoilterSet, self).qs
return parent.distinct().order_by('-ano', 'tipo', '-numero')
class Meta:
model = MateriaLegislativa
fields = [
'ano', 'tipo', 'tramitacao__unidade_tramitacao_destino',
'tramitacao__status'
]
def __init__(self, *args, **kwargs):
super(RelatorioMateriasTramitacaoilterSet,
self).__init__(*args, **kwargs)
self.filters['tipo'].label = 'Tipo de Matéria'
row1 = to_row([('ano', 12)])
row2 = to_row([('tipo', 12)])
row3 = to_row([('tramitacao__unidade_tramitacao_destino', 12)])
row4 = to_row([('tramitacao__status', 12)])
self.form.helper = FormHelper()
self.form.helper.form_method = 'GET'
self.form.helper.layout = Layout(
Fieldset(_('Pesquisa de Matéria em Tramitação'), row1, row2, row3,
row4, form_actions(label='Pesquisar')))
class AuditSessionFilter(django_filters.FilterSet):
title = django_filters.CharFilter(lookup_expr='contains')
auditor = django_filters.CharFilter(method='user_', )
branch = django_filters.ModelChoiceFilter(queryset=Branch.objects.all())
status = django_filters.ChoiceFilter(choices=AUDITSESSION_STATUS_CHOICES)
start_date = django_filters.DateTimeFilter('audit_date', lookup_expr="gte", widget=DateTimePickerInput(
options={
"locale": "th",
}
))
end_date = django_filters.DateTimeFilter('audit_date', lookup_expr="lte", widget=DateTimePickerInput(
options={
"locale": "th",
}
))
class Meta:
model = AuditSession
fields = [
]
def __init__(self, *args, **kwargs):
super(AuditSessionFilter, self).__init__(*args, **kwargs)
self.filters['title'].label = 'ชื่อ'
self.filters['auditor'].label = 'ผู้ตรวจสอบ'
self.filters['branch'].label = 'สาขา'
self.filters['status'].label = 'สถานะการตรวจสอบ'
self.filters['start_date'].label = 'ตรวจสอบตั้งแต่วันที่'
self.filters['end_date'].label = 'ตรวจสอบถึงวันที่'
def user_(self, queryset, name, value):
return queryset.filter(
Q(added_by__username__icontains=value) |
Q(added_by__email__icontains=value) |
Q(added_by__first_name__icontains=value) |
Q(added_by__last_name__icontains=value)
).distinct()
class TaskFilter(django_filters.FilterSet):
start_date = django_filters.DateTimeFilter(field_name='task_date',
lookup_expr='gte',
label='',
widget=DateTimeInput(format="'%D.%m.%Y %H:%M'",
attrs={
'class': 'datetimefield form-control form-control-sm',
'placeholder': 'Дата с:'}
)
)
end_date = django_filters.DateTimeFilter(field_name='task_date',
lookup_expr='lte',
label='',
widget=DateTimeInput(format="'%D.%m.%Y %H:%M'",
attrs={
'class': 'datetimefield form-control form-control-sm',
'placeholder': 'Дата по:'
}
)
)
task_header = django_filters.CharFilter(field_name='task_header',
lookup_expr='icontains',
label='',
widget=TextInput(attrs={'class': 'form-control form-control-sm',
'placeholder': 'Поиск по заголовку события:'}
)
)
task_type = django_filters.ChoiceFilter(field_name='task_type',
choices=[('Звонок', 'Звонок'), ('Встреча', 'Встреча')],
widget=Select(attrs={'class': 'form-control form-control-sm',
}
)
)
class Meta:
model = Task
fields = ['task_header', 'task_type']
class CrowdsourceFilterSet(django_filters.FilterSet):
"""Filtering for crowdsources for admins"""
status = django_filters.ChoiceFilter(
choices=(
('draft', 'Draft'),
('open', 'Open'),
('close', 'Closed'),
)
)
is_staff = django_filters.BooleanFilter(
name='user__is_staff',
label='Staff Owned',
widget=forms.Select(choices=NULL_BOOLEAN_CHOICES),
)
user = django_filters.ModelChoiceFilter(
queryset=User.objects.all(),
widget=autocomplete_light.ChoiceWidget('UserAutocomplete')
)
class Meta:
model = Crowdsource
fields = ['status', 'user']
class ProjectListFilter(filters.FilterSet):
REPORTING_CHOICES = (
(0, 'Up to date'),
(1, 'Behind schedule'),
)
project_fund = Select2ModelMultipleChoiceFilter(
field_name="submission__page",
label=_('Funds'),
queryset=get_used_funds)
project_lead = Select2ModelMultipleChoiceFilter(field_name="lead",
label=_('Lead'),
queryset=get_project_leads)
project_status = Select2MultipleChoiceFilter(
field_name="status", label=_('Status'), choices=PROJECT_STATUS_CHOICES)
query = filters.CharFilter(field_name='title',
lookup_expr="icontains",
widget=forms.HiddenInput)
reporting = filters.ChoiceFilter(
choices=REPORTING_CHOICES,
method="filter_reporting",
widget=Select2Widget(
attrs={
'data-placeholder': 'Reporting',
'data-minimum-results-for-search': -1,
}),
)
class Meta:
fields = ['project_status', 'project_lead', 'project_fund']
model = Project
def filter_reporting(self, queryset, name, value):
if value == '1':
return queryset.filter(outstanding_reports__gt=0)
return queryset.filter(
Q(outstanding_reports__lt=1) | Q(outstanding_reports__isnull=True),
status__in=(IN_PROGRESS, CLOSING),
)
class SearchFilter(django_filters.FilterSet):
CHOICE_ONLY_VOUCHED = 'yes'
CHOICE_ONLY_UNVOUCHED = 'no'
CHOICE_ALL = 'all'
CHOICES = (
(CHOICE_ONLY_VOUCHED, _lazy('Vouched')),
(CHOICE_ONLY_UNVOUCHED, _lazy('Unvouched')),
(CHOICE_ALL, _lazy('All')),
)
vouched = django_filters.ChoiceFilter(
name='vouched', label=_lazy(u'Display only'), required=False,
choices=CHOICES, action=filter_vouched)
class Meta:
model = UserProfile
fields = ['vouched', 'skills', 'groups', 'timezone']
def __init__(self, *args, **kwargs):
super(SearchFilter, self).__init__(*args, **kwargs)
self.filters['timezone'].field.choices.insert(0, ('', _lazy(u'All timezones')))
class DealFilterWithoutData(django_filters.FilterSet):
STATUS_CHOICES = [('Z', _('Все контракты'))]
for STATUS in list(DealStatus.STATUS_CHOICES):
STATUS_CHOICES.append(STATUS)
STATUS_CHOICES = tuple(STATUS_CHOICES)
label = DealStatus._meta.get_field('status').verbose_name.title()
status = django_filters.ChoiceFilter(choices=STATUS_CHOICES,
method='filter_deal',
label=label)
def filter_deal(self, queryset, name, value):
if value == 'Z':
queryset = Deal.objects.all()
else:
queryset = queryset.filter(status__exact=value)
return queryset
class Meta:
model = Deal
fields = ['status', 'sales_person']
class PartnerFilter(django_filters.FilterSet):
tags = django_filters.ChoiceFilter(
label="Tags", choices=get_tag_choices(), method="tags_filter"
)
languages = django_filters.ModelChoiceFilter(queryset=Language.objects.all())
def __init__(self, *args, **kwargs):
# grab "language_code" from kwargs and then remove it so we can call super()
language_code = None
if "language_code" in kwargs:
language_code = kwargs.get("language_code")
kwargs.pop("language_code")
super(PartnerFilter, self).__init__(*args, **kwargs)
self.filters["tags"].extra.update({"choices": get_tag_choices(language_code)})
class Meta:
model = Partner
fields = ["languages"]
def tags_filter(self, queryset, name, value):
return queryset.filter(new_tags__tags__contains=value)
class PageHistoryReportFilterSet(WagtailFilterSet):
action = django_filters.ChoiceFilter(choices=page_log_action_registry.get_choices)
hide_commenting_actions = django_filters.BooleanFilter(
label=_('Hide commenting actions'),
method='filter_hide_commenting_actions',
widget=forms.CheckboxInput,
)
user = django_filters.ModelChoiceFilter(
field_name='user', queryset=lambda request: PageLogEntry.objects.all().get_users()
)
timestamp = django_filters.DateFromToRangeFilter(label=_('Date'), widget=DateRangePickerWidget)
def filter_hide_commenting_actions(self, queryset, name, value):
if value:
queryset = queryset.exclude(
action__startswith='wagtail.comments'
)
return queryset
class Meta:
model = PageLogEntry
fields = ['action', 'user', 'timestamp', 'hide_commenting_actions']
class ASRSnippetFilter(django_filters.FilterSet):
name = django_filters.CharFilter(lookup_expr='icontains')
locale = CharInFilter(field_name='locales__code', lookup_expr='in')
only_scheduled = django_filters.ChoiceFilter(method='filter_scheduled',
choices=(('true', 'Yes'),
('false', 'No'),
('all', 'All')))
def filter_scheduled(self, queryset, name, value):
if value == 'all':
return queryset
value = strtobool(value)
if value:
return queryset.exclude(publish_start=None, publish_end=None)
return queryset.filter(publish_start=None, publish_end=None)
class Meta:
model = models.ASRSnippet
fields = []
class CollectionItemFilter(django_filters.FilterSet):
price_paid = django_filters.RangeFilter()
sell_price = django_filters.RangeFilter()
market_value = django_filters.RangeFilter()
rating = django_filters.RangeFilter()
own = django_filters.ChoiceFilter(choices=OWN_CHOICES)
def __init__(self, *args, **kwargs):
collection = kwargs.pop('collection')
super().__init__(*args, **kwargs)
if not collection.price_paid_used:
self.filters.pop('price_paid')
if not collection.sell_price_used:
self.filters.pop('sell_price')
if not collection.market_value_used:
self.filters.pop('market_value')
if not collection.rating_used:
self.filters.pop('rating')
if not collection.signed_used:
self.filters.pop('signed')
if not collection.was_read_used:
self.filters.pop('was_read')
if not collection.for_sale_used:
self.filters.pop('for_sale')
if not collection.own_used:
self.filters.pop('own')
if not collection.digital_used:
self.filters.pop('is_digital')
class Meta:
model = CollectionItem
fields = ['own',
'was_read',
'signed',
'is_digital',
'for_sale',
'rating',
'price_paid',
'market_value',
'sell_price']
class CompetidorFilter(django_filters.FilterSet):
ORDENAR = (("ascending", "Ascendente"), ("descending", "Descendente"))
ordering = django_filters.ChoiceFilter(label="Ordernar",
choices=ORDENAR,
method="filter_by_order")
nome_competidor = django_filters.CharFilter(label="Nome do Competidor",
lookup_expr="icontains")
pais = django_filters.CharFilter(label="Pais")
estado = django_filters.CharFilter(label="Estado")
class Meta:
model = Competidor
fields = [
"nome_competidor",
"pais",
"estado",
]
def filter_by_order(self, queryset, name, value):
expression = "nome_competidor" if value == "ascending" else "-nome_competidor"
return queryset.order_by(expression)
