class EArticleFilter(EFilterBase):
advanced_search = True
ordering_by_title = filters.OrderingFilter(choices=(
('title', _('Title')),
('-title', _('Title (descending)')),
),
label=_('Sort by title'))
ordering_by_views = filters.OrderingFilter(
choices=(('-views', _('Views')), ('views', _('Views (descending)'))),
label=_('Sort by views'))
ordering_by_pub_date = filters.OrderingFilter(
choices=(
('pub_date', _('Publication date')),
('-pub_date', _('Publication date (descending)')),
),
label=_('Sort by publication date'))
@classmethod
def create(cls, target_model):
class ArticleFilter(EArticleFilter):
class Meta(EArticleFilter.Meta):
model = target_model
return ArticleFilter
class FilterSet(django_filters.FilterSet):
_order_by = filters.OrderingFilter(fields=filter_field_names)
_search = SearchFilter()
class Meta:
model = build_model
fields = filter_fields
class NamespaceFilter(filterset.FilterSet):
keywords = filters.CharFilter(method='keywords_filter')
sort = filters.OrderingFilter(fields=(
('name', 'name'),
('company', 'company'),
('id', 'id'),
), )
class Meta:
model = models.Namespace
fields = (
'name',
'company',
)
def keywords_filter(self, queryset, name, value):
keywords = self.request.query_params.getlist('keywords')
for keyword in keywords:
queryset = queryset.filter(
Q(name__icontains=keyword) | Q(company__icontains=keyword))
return queryset
class HistoryFilter(filterset.FilterSet):
sort = filters.OrderingFilter(
fields=(
('pulp_created', 'created'),
('number', 'number'),
),
)
class AnswerFilter(django_filters.FilterSet):
order = filters.OrderingFilter(fields=(('created_date_time', 'date time'),
('id', 'answer id')))
datetime_range = filters.DateTimeFromToRangeFilter(name='created_date_time', widget=RangeWidget)
# creator = filters.ModelMultipleChoiceFilter(name='creator', to_field_name='id', queryset=)
question_content = filters.CharFilter(name='question__content_description', lookup_expr='contains')
class Meta:
model = models.Answer
fields = []
class ManifestFilter(filterset.FilterSet):
sort = filters.OrderingFilter(fields=(('pulp_created', 'created'), ), )
class Meta:
model = container_models.Manifest
# Tag filters are supported, but are done in get_queryset. See the comment
# there
fields = {
'digest': ['exact', 'icontains', 'contains', 'startswith'],
}
class TransactionFilterSet(filterset.FilterSet):
account = filters.ModelChoiceFilter(queryset=account_queryset)
category = filters.ModelChoiceFilter(queryset=category_queryset)
tags = filters.CharFilter(method="filter_by_tags")
created_at = filters.CharFilter(method="filter_by_date_range")
updated_at = filters.CharFilter(method="filter_by_date_range")
ordering = filters.OrderingFilter(fields=ORDERING_FIELDS,
field_labels=ORDERING_LABELS,
label=_("Ordering"))
min_amount = filters.NumberFilter(field_name="amount",
lookup_expr="gte",
label=_("Minimum amount"))
max_amount = filters.NumberFilter(field_name="amount",
lookup_expr="lte",
label=_("Maximum amount"))
description = filters.CharFilter(lookup_expr="icontains",
label=_("Descripton"))
class Meta:
model = Transaction
fields = ("type", )
form = TransactionFilterForm
def filter_by_tags(self, queryset, field_name, tags):
if self.form.is_valid():
tag_values = [tag["value"] for tag in tags]
queryset = queryset.filter(**{
"author": self.request.user,
f"{field_name}__name__in": tag_values
})
return queryset
def filter_by_date_range(self, queryset, name, value):
if self.form.is_valid():
start_date, end_date = value.split(" - ")
date_field = forms.DateField()
start_datetime = datetime.combine(
date=date_field.clean(start_date),
time=time.min,
tzinfo=pytz.UTC)
end_datetime = datetime.combine(date=date_field.clean(end_date),
time=time.max,
tzinfo=pytz.UTC)
queryset = queryset.filter(
**{
"author": self.request.user,
f"{name}__gte": start_datetime,
f"{name}__lte": end_datetime,
})
return queryset
class GroupFilter(filterset.FilterSet):
sort = filters.OrderingFilter(
fields=(
('name', 'name'),
)
)
class Meta:
model = Group
fields = {
'name': ['exact', 'contains', 'startswith']
}
class ClassFilter(django_filters.FilterSet):
order = filters.OrderingFilter(fields=(('created_date_time', 'date time'),
('id', 'class id'),
('name', 'name')))
datetime_range = filters.DateTimeFromToRangeFilter(name='created_date_time', widget=RangeWidget)
class_description = filters.CharFilter(name='description', lookup_expr='contains')
creator = filters.ModelMultipleChoiceFilter(name='creator', to_field_name='id', queryset=User.objects.all())
tags = filters.MultipleChoiceFilter(name='tags')
class Meta:
model = models.Class
fields = []
class QuestionFilter(django_filters.FilterSet):
# created_date_time = filters.DateFilter(field_name='created_date_time', label='date')
order = filters.OrderingFilter(fields=(('created_date_time', 'date time'),
('id', 'question id')))
datetime_range = filters.DateFromToRangeFilter(name='created_date_time', widget=RangeWidget)
tags = filters.AllValuesMultipleFilter(name='tags')
creator = filters.ModelMultipleChoiceFilter(name='creator', to_field_name='id', queryset=User.objects.all())
content = filters.CharFilter(name='content_description', lookup_expr='contains')
class Meta:
model = models.Question
fields = []
class ManifestFilter(filterset.FilterSet):
# tag = filters.CharFilter(method='tag_filter')
sort = filters.OrderingFilter(
fields=(
('pulp_created', 'created'),
),
)
class Meta:
model = container_models.Manifest
fields = {
'digest': ['exact', 'icontains', 'contains', 'startswith'],
}
class UserFilter(filterset.FilterSet):
sort = filters.OrderingFilter(
fields=(
('username', 'username'),
('email', 'email'),
('first_name', 'first_name'),
('date_joined', 'date_joined')
)
)
class Meta:
model = auth_models.User
fields = ('username', 'email', 'first_name', 'date_joined')
class RepositoryFilter(filterset.FilterSet):
sort = filters.OrderingFilter(fields=(
('repository__pulp_created', 'created'),
('name', 'name'),
('description', 'description'),
('repository__pulp_last_updated', 'updated'),
), )
class Meta:
model = models.ContainerDistribution
fields = {
'name': ['exact', 'icontains', 'contains', 'startswith'],
'description': ['exact', 'icontains', 'contains', 'startswith'],
}
class BeerFilter(rest_filters.FilterSet):
min_price = filters.NumberFilter(field_name="price", lookup_expr='gte')
max_price = filters.NumberFilter(field_name="price", lookup_expr='lte')
min_mark = filters.NumberFilter(field_name="mark", lookup_expr='gte')
max_mark = filters.NumberFilter(field_name="mark", lookup_expr='lte')
min_rating = filters.NumberFilter(field_name="rating", lookup_expr='gte')
max_rating = filters.NumberFilter(field_name="rating", lookup_expr='lte')
name = filters.CharFilter(field_name='name', lookup_expr='icontains')
order = filters.OrderingFilter(fields=(
('price', 'price'),
('mark', 'mark'),
('rating', 'rating'),
('updated_at', 'updated_at'),
))
class ESectionFilter(EFilterBase):
advanced_search = True
ordering_by_title = filters.OrderingFilter(choices=(
('title', _('Title')),
('-title', _('Title (descending)')),
),
label=_('Sort by title'))
@classmethod
def create(cls, target_model):
class SectionFilter(ESectionFilter):
class Meta(ESectionFilter.Meta):
model = target_model
return SectionFilter
class ContactMomentFilter(FilterSet):
ordering = filters.OrderingFilter(
fields=(
"url",
"bronorganisatie",
"klant",
"registratiedatum",
"kanaal",
"voorkeurskanaal",
"tekst",
"onderwerp_links",
"initiatiefnemer",
"medewerker",
"medewerker_identificatie",
),
help_text=_("Het veld waarop de resultaten geordend worden."),
)
class Meta:
model = ContactMoment
fields = {
"vorig_contactmoment": ["exact"],
"volgend_contactmoment": ["exact"],
"bronorganisatie": ["exact"],
"registratiedatum": ["exact", "gt", "gte", "lt", "lte"],
"kanaal": ["exact"],
"voorkeurskanaal": ["exact"],
"voorkeurstaal": ["exact"],
"initiatiefnemer": ["exact"],
"medewerker": ["exact"],
"ordering": ["exact"],
}
@classmethod
def filter_for_field(cls, f, name, lookup_expr):
# Needed because `volgend_contactmoment` is a reverse OneToOne rel
if f.name == "volgend_contactmoment":
filter = URLModelChoiceFilter()
filter.field_name = "volgend_contactmoment"
filter.extra["help_text"] = _(
"URL-referentie naar het volgende CONTACTMOMENT.")
filter.queryset = ContactMoment.objects.all()
else:
filter = super().filter_for_field(f, name, lookup_expr)
return filter
class ProductFilterSet(FilterSet):
city = filters.AllValuesMultipleFilter('seller__city')
min_price = filters.NumberFilter(field_name="unit_price",
lookup_expr='gte')
max_price = filters.NumberFilter(field_name="unit_price",
lookup_expr='lte')
category = filters.AllValuesMultipleFilter(field_name="category__slug",
method='filter_category')
def filter_category(self, queryset, name, categories):
return queryset.filter(category__slug__in=categories)
sort = filters.OrderingFilter(fields=['created', 'quantity', 'unit_price'])
class Meta:
model = Product
fields = ['category', 'city', 'min_price', 'max_price']
class UserFilter(filterset.FilterSet):
sort = filters.OrderingFilter(fields=(('username', 'username'),
('email', 'email'), ('first_name',
'first_name'),
('last_name', 'last_name'),
('date_joined', 'date_joined')))
class Meta:
model = auth_models.User
fields = {
'username': ['exact', 'contains', 'startswith'],
'email': ['exact', 'contains', 'startswith'],
'first_name': ['exact', 'contains', 'startswith'],
'last_name': ['exact', 'contains', 'startswith'],
'date_joined': ['exact'],
'groups__name': ['exact'],
'groups': ['exact']
}
class AppStatFilter(django_filters.FilterSet):
date_from = filters.DateFilter(field_name='date', lookup_expr='gte')
date_to = filters.DateFilter(field_name='date', lookup_expr='lte')
os = filters.CharFilter(method="filter_os")
channel = filters.CharFilter(lookup_expr='iexact')
country = filters.CharFilter(lookup_expr='iexact')
group_by = filters.MultipleChoiceFilter(choices=GROUP_BY_CHOICES,
method='group_the_query')
o = filters.OrderingFilter(fields=('date', 'channel', 'country', 'os',
'impressions', 'clicks', 'installs',
'spend', 'revenue', 'cpi'), )
@staticmethod
def filter_os(qs, field_name, value):
if value.lower() == 'android':
value = AppStat.ANDROID
elif value.lower() == 'ios':
value = AppStat.IOS
else:
value = None
return qs.filter(os=value)
def group_the_query(self, qs, field_name, group_by_fields):
can_display_fields = list(
set(self.data) & set(['date', 'os', 'channel', 'country']))
group_by_fields = group_by_fields + can_display_fields
return qs.values(*group_by_fields).annotate(
impressions=models.Sum('impressions'),
clicks=models.Sum('clicks'),
installs=models.Sum('installs'),
spend=models.Sum('spend'),
revenue=models.Sum('revenue'),
cpi=models.ExpressionWrapper(
models.F('spend') / models.F('installs'),
output_field=models.FloatField())).order_by(*group_by_fields)
class Meta:
model = AppStat
fields = '__all__'
class RepositoryFilter(filterset.FilterSet):
my_permissions = filters.CharFilter(method='has_permissions')
sort = filters.OrderingFilter(
fields=(
('repository__pulp_created', 'created'),
('name', 'name'),
('description', 'description'),
('repository__pulp_last_updated', 'updated'),
),
)
class Meta:
model = models.ContainerDistribution
fields = {
'name': ['exact', 'icontains', 'contains', 'startswith'],
'description': ['exact', 'icontains', 'contains', 'startswith'],
}
def has_permissions(self, queryset, name, value):
perms = self.request.query_params.getlist(name)
namespaces = get_objects_for_user(
self.request.user, perms, klass=container_models.ContainerNamespace)
return self.queryset.filter(namespace__in=namespaces)
class OnedayClassFilter(FilterSet):
ADDR = [(addr, addr)
for addr in ('서울특별시', '부산광역시', '대구광역시', '인천광역시', '광주광역시', '대전광역시',
'울산광역시', '세종특별자치시', '경기도', '강원도', '충청북도', '충청남도',
'전라북도', '전라남도', '경상북도', '경상남도', '제주특별자치도')]
ADDR1 = [(addr, addr)
for addr in ('종로구', '중구', '용산구', '성동구', '광진구', '동대문구', '중랑구',
'성북구', '강북구', '도봉구', '노원구', '은평구', '서대문구', '마포구',
'양천구', '강서구', '구로구', '금천구', '영등포구', '동작구', '관악구',
'서초구', '강남구', '송파구', '강동구')]
ADDR2 = [
(addr, addr)
for addr in ('수원시', '고양시', '성남시', '부천시', '안양시', '광명시', '평택시', '안산시',
'과천시', '오산시', '시흥시', '군포시', '의왕시', '하남시', '용인시', '이천시',
'안성시', '김포시', '화성시', '광주시', '의정부시', '동두천시', '구리시', '남양주시',
'파주시', '양주시', '포천시', '여주시', '연천군', '가평군', '양평군')
]
type = MultipleChoiceFilter(choices=OnedayClass.TYPE_CHOICES,
widget=forms.CheckboxSelectMultiple)
gender = MultipleChoiceFilter(choices=OnedayClass.GENDER_CHOICES,
widget=forms.CheckboxSelectMultiple)
day = MultipleChoiceFilter(choices=OnedayClass.DAY_CHOICES,
widget=forms.CheckboxSelectMultiple)
theme = MultipleChoiceFilter(choices=OnedayClass.THEME_CHOICES,
widget=forms.CheckboxSelectMultiple)
price__lt = NumberFilter(field_name='price', lookup_expr='lte')
place = ChoiceFilter(choices=ADDR,
field_name='place',
lookup_expr='icontains')
place1 = ChoiceFilter(choices=ADDR1,
field_name='place',
lookup_expr='icontains')
place2 = ChoiceFilter(choices=ADDR2,
field_name='place',
lookup_expr='icontains')
o = filters.OrderingFilter(
fields=['price', 'date'],
field_labels={
'-price': '높은가격순',
'price': '낮은가격순',
'date': '마감임박순',
'-date': '최신순',
},
widget=forms.RadioSelect,
)
class Meta:
model = OnedayClass
fields = [
'type',
'gender',
'day',
'theme',
'price',
'place',
'date',
]
def place_filter(self, queryset, place):
if place == "서울특별시":
return queryset.exclude('place2')
elif place == "경기도":
return queryset.exclude('place1')
else:
return queryset.exclude('place1', 'place2')
class ZaakFilter(FilterSet):
maximale_vertrouwelijkheidaanduiding = MaximaleVertrouwelijkheidaanduidingFilter(
field_name="vertrouwelijkheidaanduiding",
help_text=(
"Zaken met een vertrouwelijkheidaanduiding die beperkter is dan de "
"aangegeven aanduiding worden uit de resultaten gefiltered."
),
)
rol__betrokkene_identificatie__natuurlijk_persoon__inp_bsn = filters.CharFilter(
field_name="rol__natuurlijkpersoon__inp_bsn",
help_text=get_help_text("datamodel.NatuurlijkPersoon", "inp_bsn"),
max_length=get_field_attribute(
"datamodel.NatuurlijkPersoon", "inp_bsn", "max_length"
),
)
rol__betrokkene_identificatie__natuurlijk_persoon__anp_identificatie = (
filters.CharFilter(
field_name="rol__natuurlijkpersoon__anp_identificatie",
help_text=get_help_text("datamodel.NatuurlijkPersoon", "anp_identificatie"),
max_length=get_field_attribute(
"datamodel.NatuurlijkPersoon", "anp_identificatie", "max_length"
),
)
)
rol__betrokkene_identificatie__natuurlijk_persoon__inp_a_nummer = (
filters.CharFilter(
field_name="rol__natuurlijkpersoon__inp_a_nummer",
help_text=get_help_text("datamodel.NatuurlijkPersoon", "inp_a_nummer"),
max_length=get_field_attribute(
"datamodel.NatuurlijkPersoon", "inp_a_nummer", "max_length"
),
)
)
rol__betrokkene_identificatie__niet_natuurlijk_persoon__inn_nnp_id = (
filters.CharFilter(
field_name="rol__nietnatuurlijkpersoon__inn_nnp_id",
help_text=get_help_text("datamodel.NietNatuurlijkPersoon", "inn_nnp_id"),
)
)
rol__betrokkene_identificatie__niet_natuurlijk_persoon__ann_identificatie = (
filters.CharFilter(
field_name="rol__nietnatuurlijkpersoon__ann_identificatie",
help_text=get_help_text(
"datamodel.NietNatuurlijkPersoon", "ann_identificatie"
),
max_length=get_field_attribute(
"datamodel.NietNatuurlijkPersoon", "ann_identificatie", "max_length"
),
)
)
rol__betrokkene_identificatie__vestiging__vestigings_nummer = filters.CharFilter(
field_name="rol__vestiging__vestigings_nummer",
help_text=get_help_text("datamodel.Vestiging", "vestigings_nummer"),
max_length=get_field_attribute(
"datamodel.Vestiging", "vestigings_nummer", "max_length"
),
)
rol__betrokkene_identificatie__medewerker__identificatie = filters.CharFilter(
field_name="rol__medewerker__identificatie",
help_text=get_help_text("datamodel.Medewerker", "identificatie"),
max_length=get_field_attribute(
"datamodel.Medewerker", "identificatie", "max_length"
),
)
rol__betrokkene_identificatie__organisatorische_eenheid__identificatie = (
filters.CharFilter(
field_name="rol__organisatorischeeenheid__identificatie",
help_text=get_help_text(
"datamodel.OrganisatorischeEenheid", "identificatie"
),
)
)
ordering = filters.OrderingFilter(
fields=(
"startdatum",
"einddatum",
"publicatiedatum",
"archiefactiedatum",
),
help_text="Het veld waarop de resultaten geordend worden.",
)
expand = ExpandFilter(
serializer_class=ZaakSerializer,
help_text="Haal details van inline resources direct op.",
)
class Meta:
model = Zaak
fields = {
"identificatie": ["exact"],
"bronorganisatie": ["exact"],
"zaaktype": ["exact"],
"archiefnominatie": ["exact", "in"],
"archiefactiedatum": ["exact", "lt", "gt"],
"archiefstatus": ["exact", "in"],
"startdatum": ["exact", "gt", "gte", "lt", "lte"],
# filters for werkvoorraad
"rol__betrokkene_type": ["exact"],
"rol__betrokkene": ["exact"],
"rol__omschrijving_generiek": ["exact"],
}
class QFilter(django_filters.FilterSet):
search = MultiFieldSearchFilter(
name=['qtext', 'answer', 'comment'],
lookup_expr='icontains',
label='Искать',
widget=forms.TextInput(
attrs={
'class': 'form-control',
'placeholder': 'поиск по вопросу, ответу или комментарию'
}))
author = filters.CharFilter(
lookup_expr='icontains',
label='Автор',
widget=forms.TextInput(attrs={
'class': 'form-control',
'placeholder': 'поиск по автору'
}))
q_has_img = filters.ChoiceFilter(
label='Картинка',
widget=forms.Select(
attrs={'class': 'btn btn-default btn-sm dropdown-toggle'}),
choices=((True, 'есть'), (False, 'нет')))
q_has_video = filters.ChoiceFilter(
label='Видео',
widget=forms.Select(
attrs={'class': 'btn btn-default btn-sm dropdown-toggle'}),
choices=((True, 'есть'), (False, 'нет')))
q_has_audio = filters.ChoiceFilter(
label='Аудио',
widget=forms.Select(
attrs={'class': 'btn btn-default btn-sm dropdown-toggle'}),
choices=((True, 'есть'), (False, 'нет')))
q_has_media = filters.ChoiceFilter(
label='Есть медиа',
widget=forms.Select(
attrs={'class': 'btn btn-default btn-sm dropdown-toggle'}),
choices=((True, 'есть'), (False, 'нет')))
is_played = filters.ChoiceFilter(widget=forms.Select(
attrs={'class': 'btn btn-default btn-sm dropdown-toggle'}),
choices=((True, 'да'), (False, 'нет')))
is_bb = filters.ChoiceFilter(widget=forms.Select(
attrs={'class': 'btn btn-default btn-sm dropdown-toggle'}),
choices=((True, 'да'), (False, 'нет')))
wow = filters.ChoiceFilter(widget=forms.Select(
attrs={'class': 'btn btn-sm btn-default dropdown-toggle'}),
choices=(('WOW', 'WOW'), ('-', 'не указано'),
('FOO', 'FOO')))
qtype = filters.ChoiceFilter(
label='Тип вопроса',
widget=forms.Select(
attrs={'class': 'btn btn-sm btn-default dropdown-toggle'}),
choices=(('chgk', 'ЧГК'), ('br', 'Брэйн'), ('tele', 'Теледомик')))
is_blitz = filters.ChoiceFilter(widget=forms.Select(
attrs={'class': 'btn btn-default btn-sm dropdown-toggle'}),
choices=((True, 'да'), (False, 'нет')))
o = filters.OrderingFilter(
fields=(('created_date', 'created_date'), ),
field_labels={
'created_date': 'дата создания',
},
label='Сортировка',
)
class Meta:
model = Question
exclude = [
'qtext', 'answer', 'altanswer', 'comment', 'source',
'created_date', 'qlink1', 'qlink2', 'qlink3', 'alink1', 'alink2',
'alink3'
]
