class OrganizationProductFilter(FilterSet):
"""
Фильтр категорий товаров, мин. и макс. цены для отдельной организации.
(почучает список категорий доступных в данной организации)
"""
def __init__(self, *args, **kwargs):
super().__init__()
prod_id = kwargs['queryset'][0].organization.pk
self.filters['category'] = filters.ModelMultipleChoiceFilter(
queryset=Category.objects.filter(
product__connector__organization__id=prod_id).distinct(),
field_name='product__category__name',
to_field_name='name',
label='Категория товаров/услуг')
min_price = filters.NumberFilter(field_name='price',
lookup_expr='gte',
label='Минимальная цена')
max_price = filters.NumberFilter(field_name='price',
lookup_expr='lte',
label='Максимальная цена')
class Meta:
model = Connector
fields = {
'min_price': 'gte',
'max_price': 'lte',
}
class RecipeFilterSet(LocalizationFilterSet):
input_id = filters.NumberFilter(method="filter_input")
output_id = filters.NumberFilter(method="filter_output")
is_event = filters.BooleanFilter(method="filter_event")
requires_backer = filters.BooleanFilter(method="filter_backer")
class Meta:
model = Recipe
fields = [
"machine",
]
def filter_input(self, queryset, name, value):
return queryset.filter(
Q(levels__inputs__item__game_id=value)
| Q(levels__inputs__group__members__game_id=value))
def filter_output(self, queryset, name, value):
return queryset.filter(output__game_id=value)
def filter_event(self, queryset, name, value):
if value:
queryset = queryset.filter(required_event__isnull=False)
elif value is False:
queryset = queryset.filter(required_event__isnull=True)
return queryset
def filter_backer(self, queryset, name, value):
if value:
queryset = queryset.filter(required_backer_tier__isnull=False)
elif value is False:
queryset = queryset.filter(required_backer_tier__isnull=True)
return queryset
class Bookfilters(FilterSet):
gte_price = filters.NumberFilter(field_name='price', lookup_expr='gte')
lte_price = filters.NumberFilter(field_name='price', lookup_expr='lte')
class Meta:
model = Book
fields = '__all__'
class PersonFilter(filterset.FilterSet):
primaryTitle = filters.CharFilter(lookup_expr=choices.FILTER_LIKE)
birthYear = filters.NumberFilter()
deathYear = filters.NumberFilter()
class Meta:
model = models.Person
fields = ['primaryTitle', 'birthYear', 'deathYear']
class RoomFilter(FilterSet):
room_type = filters.MultipleChoiceFilter(choices=Room.ROOM_TYPE_CHOICES)
deposit = filters.RangeFilter()
monthly_rent = filters.RangeFilter()
management_fee = filters.RangeFilter()
space_min = filters.NumberFilter(field_name='space',
method='filter_space_gte')
space_max = filters.NumberFilter(field_name='space',
method='filter_space_lte')
def filter_space_gte(self, queryset, name, value):
return queryset.filter(space__gte=int(value) * 3.305785)
def filter_space_lte(self, queryset, name, value):
return queryset.filter(space__lte=int(value) * 3.305785)
class Filtered(FilterSet):
negated_gramos__not = filters.NumberFilter(field_name='gramos',
exclude=True)
class Meta:
model = Insumos
fields = ('__all__')
class UserHistoryFilter(FilterSet):
case_id = filters.NumberFilter()
date = filters.DateTimeFromToRangeFilter()
class Meta:
model = UserHistory
fields = ['case_id', 'date']
class DecisionFilter(FilterSet):
lease = filters.NumberFilter()
class Meta:
model = Decision
fields = [
'lease', 'reference_number', 'decision_maker', 'decision_date',
'type'
]
class TitleFilter(filterset.FilterSet):
titleType = filters.CharFilter(lookup_expr=choices.FILTER_EQUALS,
field_name='titleType')
primaryTitle = filters.CharFilter(lookup_expr=choices.FILTER_LIKE)
originalTitle = filters.CharFilter(lookup_expr=choices.FILTER_LIKE)
isAdult = filters.BooleanFilter()
startYear = filters.NumberFilter()
endYear = filters.NumberFilter()
runtimeMinutes = filters.NumberFilter()
genres = filters.CharFilter(lookup_expr=choices.FILTER_LIKE,
field_name='genres')
averageRating = filters.NumberFilter()
class Meta:
model = models.Title
fields = [
'titleType', 'primaryTitle', 'originalTitle', 'isAdult',
'startYear', 'endYear', 'runtimeMinutes', 'genres', 'averageRating'
]
class CityFilter(FilterSet):
pk = filters.NumberFilter(help_text='业务id')
code = filters.CharFilter(help_text='代码')
name = filters.CharFilter(help_text='名称')
county = filters.ModelChoiceFilter(queryset=Countries.objects.all(),
required=True,
help_text='国家')
class Meta:
model = Cities
fields = []
class VolumeFilter(FilterSet):
jurisdictions = filters.MultipleChoiceFilter(
label='Jurisdiction',
field_name='reporter__jurisdictions__slug',
choices=jur_choices)
reporter = filters.MultipleChoiceFilter(field_name='reporter',
choices=reporter_choices)
volume_number = filters.NumberFilter(field_name='volume_number')
publication_year = filters.NumberFilter(field_name='publication_year')
class Meta:
model = models.VolumeMetadata
fields = [
'reporter',
'jurisdictions',
'volume_number',
'publication_year',
]
class CheckValueFilter(FilterSet):
pk = filters.NumberFilter(help_text='业务id')
code = filters.CharFilter(help_text='代码')
name = filters.CharFilter(help_text='名称')
type = filters.ModelChoiceFilter(queryset=DataDictType.objects.all(),
required=True,
help_text='类型')
class Meta:
model = DataDictsValue
fields = []
class DecisionFilter(FilterSet):
lease = filters.NumberFilter()
class Meta:
model = Decision
fields = [
"lease",
"reference_number",
"decision_maker",
"decision_date",
"type",
]
class DecisionFilter(FilterSet):
lease = filters.NumberFilter()
reference_number = filters.CharFilter(lookup_expr="contains")
class Meta:
model = Decision
fields = [
"lease",
"reference_number",
"decision_maker",
"decision_date",
"type",
]
class InvoiceFilter(FilterSet):
lease = filters.NumberFilter()
going_to_sap = filters.BooleanFilter(method="filter_going_to_sap",
label=_("Going to SAP"))
class Meta:
model = Invoice
fields = ["lease", "state", "type"]
def filter_going_to_sap(self, queryset, name, value):
if value:
return queryset.filter(due_date__gte=datetime.date.today(),
sent_to_sap_at__isnull=True)
return queryset
class SubjectFilter(FilterSet):
"""
Filter subjecten.
"""
buurt = filters.CharFilter(method="buurt_filter", label='buurt')
zakelijk_recht = filters.NumberFilter(method="recht_filter", label='recht')
bewoners = filters.BooleanFilter(method="bewoners_filter")
class Meta(object):
model = models.KadastraalSubject
fields = (
'naam',
'type',
'buurt',
'kvknummer',
'statutaire_naam',
'zakelijk_recht',
)
def buurt_filter(self, queryset, _filter_name, value):
"""
Buurt code 4 chars
"""
recht_type = 2 # eigenaar
if 'zakelijk_recht' in self.request.GET:
recht_type = self.request.GET['zakelijk_recht']
if len(value) != 4:
raise drf_serializers.ValidationError('Buurt vollcode is 4 chars')
# remove ordering.
# SUPER SLOW because of some weirdness.
qs = queryset.order_by()
return qs.filter(rechten__verblijfsobjecten__buurt__vollcode=value,
rechten__aard_zakelijk_recht__code=recht_type)
def recht_filter(self, queryset, _filter_name, value):
if self.request.GET['buurt']:
# will be recht filter will be done
# in buurt filter
return queryset
return queryset.filter(rechten__aard_zakelijk_recht__code=value)
class ProductFilter(FilterSet):
""" Фильтр категорий товаров, сети, мин. и макс. цены для общего списка товаров """
category = filters.ModelMultipleChoiceFilter(
queryset=Category.objects.all(),
field_name='connector__product__category__name',
to_field_name='name',
label='Категория товаров/услуг')
network = filters.ModelMultipleChoiceFilter(queryset=Network.objects.all(),
field_name='network__name',
to_field_name='name',
label='Сеть организаций')
min_price = filters.NumberFilter(field_name='price',
lookup_expr='gte',
label='Минимальная цена')
max_price = filters.NumberFilter(field_name='price',
lookup_expr='lte',
label='Максимальная цена')
class Meta:
model = Product
fields = {
'min_price': 'gte',
'max_price': 'lte',
}
class BouwDossierFilter(FilterSet):
nummeraanduiding = filters.CharFilter(
field_name='adressen__nummeraanduidingen',
method='array_contains_filter')
pand = filters.CharFilter(field_name='adressen__panden',
method='array_contains_filter')
verblijfsobject = filters.CharFilter(
field_name='adressen__verblijfsobjecten',
method='array_contains_filter')
openbareruimte = filters.CharFilter(
field_name='adressen__openbareruimte_id')
min_datering = filters.CharFilter(field_name='datering__year',
lookup_expr='gte')
max_datering = filters.CharFilter(field_name='datering__year',
lookup_expr='lte')
subdossier = filters.CharFilter(field_name='documenten__subdossier_titel',
lookup_expr='istartswith')
dossiernr = filters.NumberFilter()
dossier = filters.CharFilter(method='dossier_with_stadsdeel')
stadsdeel = filters.CharFilter()
dossier_type = filters.CharFilter()
class Meta:
model = models.BouwDossier
fields = (
'dossiernr',
'stadsdeel',
'nummeraanduiding',
'verblijfsobject',
'pand',
'openbareruimte',
'min_datering',
'max_datering',
'subdossier',
'olo_liaan_nummer',
)
def dossier_with_stadsdeel(self, queryset, _filter_name, value):
stadsdeel, dossiernr = tools.separate_dossier(value)
return queryset.filter(stadsdeel=stadsdeel, dossiernr=dossiernr)
def array_contains_filter(self, queryset, _filter_name, value):
if not isinstance(value, list):
value = [value]
lookup = '%s__%s' % (_filter_name, 'contains')
return queryset.filter(**{lookup: value}).distinct()
class RepositoryVersionFilter(BaseFilterSet):
# e.g.
# /?number=4
# /?number__range=4,6
# /?pulp_created__gte=2018-04-12T19:45
# /?pulp_created__range=2018-04-12T19:45,2018-04-13T20:00
# /?content=/pulp/api/v3/content/file/fb8ad2d0-03a8-4e36-a209-77763d4ed16c/
number = filters.NumberFilter()
pulp_created = IsoDateTimeFilter()
content = RepositoryVersionContentFilter()
content__in = RepositoryVersionContentFilter(field_name="content", lookup_expr="in")
class Meta:
model = RepositoryVersion
fields = {
"number": ["exact", "lt", "lte", "gt", "gte", "range"],
"pulp_created": DATETIME_FILTER_OPTIONS,
}
class UserFilterSet(FilterSet):
id = filters.NumberFilter()
username = filters.CharFilter(lookup_expr='icontains')
active = filters.BooleanFilter(field_name='is_active')
role = filters.ModelMultipleChoiceFilter(queryset=_get_group_queryset(),
to_field_name='name',
field_name='groups__name')
order = OrderingExtraKwargsFilter(
fields=(
('username', 'username'),
('is_active', 'active'),
),
extra_kwargs={
'username': {'apply': Lower} # Will apply the Lower function when ordering
}
)
class RepositoryVersionFilter(BaseFilterSet):
# e.g.
# /?number=4
# /?number__range=4,6
# /?pulp_created__gte=2018-04-12T19:45
# /?pulp_created__range=2018-04-12T19:45,2018-04-13T20:00
# /?content=/pulp/api/v3/content/file/fb8ad2d0-03a8-4e36-a209-77763d4ed16c/
number = filters.NumberFilter()
pulp_created = IsoDateTimeFilter()
content = RepositoryVersionContentFilter()
class Meta:
model = RepositoryVersion
fields = {
'number': ['exact', 'lt', 'lte', 'gt', 'gte', 'range'],
'pulp_created': DATETIME_FILTER_OPTIONS,
'content': ['exact', 'in']
}
class SidconFilter(FilterSet):
"""Filtering on sidcon fill level entries."""
container_id = filters.CharFilter(method='container_filter',
label='container id')
site_id = filters.CharFilter(method='site_filter', label='short site id')
days_back = filters.NumberFilter(method='delta_day_filter',
label='days back')
class Meta(object):
model = SidconFillLevel
fields = {
"scraped_at": FILTERS,
"filling": FILTERS,
"communication_date_time": FILTERS,
"container_id": ['exact'],
"days_back": ['exact'],
"valid": ['exact'],
"short_id": ['exact'],
"site_id": ['exact'],
}
def container_filter(self, qs, name, value):
return qs.filter(description=value)
def site_filter(self, qs, name, value):
return qs.filter(site_id=value)
def delta_day_filter(self, qs, name, value):
today = datetime.datetime.now()
delta = datetime.timedelta(days=int(value))
filter_day = today - delta
return qs.filter(communication_date_time__gt=filter_day)
class LogisticFilterSet(FilterSet):
order = filters.NumberFilter(help_text='订单')
freight = filters.NumberFilter(help_text='运单')
class FreightTMOrdFilterSet(FilterSet):
channel_code = filters.CharFilter(help_text='客户代码')
freight = filters.NumberFilter(help_text='运单')
class SignalFilterSet(FilterSet):
id = filters.NumberFilter()
address_text = filters.CharFilter(field_name='location__address_text', lookup_expr='icontains')
area_code = filters.ChoiceFilter(field_name='location__area_code', choices=area_choices)
area_type_code = filters.ChoiceFilter(field_name='location__area_type_code', choices=area_type_choices)
buurt_code = filters.MultipleChoiceFilter(field_name='location__buurt_code', choices=buurt_choices)
category_id = filters.MultipleChoiceFilter(field_name='category_assignment__category_id',
choices=category_choices)
category_slug = filters.ModelMultipleChoiceFilter(
queryset=_get_child_category_queryset(),
to_field_name='slug',
field_name='category_assignment__category__slug',
)
contact_details = filters.MultipleChoiceFilter(method='contact_details_filter', choices=contact_details_choices)
created_before = filters.IsoDateTimeFilter(field_name='created_at', lookup_expr='lte')
directing_department = filters.MultipleChoiceFilter(
method='directing_department_filter',
choices=department_choices
)
created_after = filters.IsoDateTimeFilter(field_name='created_at', lookup_expr='gte')
feedback = filters.ChoiceFilter(method='feedback_filter', choices=feedback_choices)
has_changed_children = filters.MultipleChoiceFilter(method='has_changed_children_filter', choices=boolean_choices)
kind = filters.MultipleChoiceFilter(method='kind_filter', choices=kind_choices) # SIG-2636
incident_date = filters.DateFilter(field_name='incident_date_start', lookup_expr='date')
incident_date_before = filters.DateFilter(field_name='incident_date_start', lookup_expr='date__gte')
incident_date_after = filters.DateFilter(field_name='incident_date_start', lookup_expr='date__lte')
maincategory_slug = filters.ModelMultipleChoiceFilter(
queryset=_get_parent_category_queryset(),
to_field_name='slug',
field_name='category_assignment__category__parent__slug',
)
note_keyword = filters.CharFilter(method='note_keyword_filter')
priority = filters.MultipleChoiceFilter(field_name='priority__priority', choices=Priority.PRIORITY_CHOICES)
source = filters.MultipleChoiceFilter(choices=source_choices)
stadsdeel = filters.MultipleChoiceFilter(field_name='location__stadsdeel', choices=stadsdelen_choices)
status = filters.MultipleChoiceFilter(field_name='status__state', choices=status_choices)
type = filters.MultipleChoiceFilter(field_name='type_assignment__name', choices=Type.CHOICES)
updated_before = filters.IsoDateTimeFilter(field_name='updated_at', lookup_expr='lte')
updated_after = filters.IsoDateTimeFilter(field_name='updated_at', lookup_expr='gte')
def _cleanup_form_data(self):
"""
Cleanup the form data
"""
self.form.cleaned_data.pop('category_slug', None)
self.form.cleaned_data.pop('maincategory_slug', None)
if not self.form.cleaned_data.get('area_code', None) or not self.form.cleaned_data.get('area_type_code', None):
self.form.cleaned_data.pop('area_code', None)
self.form.cleaned_data.pop('area_type_code', None)
def filter_queryset(self, queryset):
"""
Add custom category filtering to the filter_queryset
"""
if not self.form.cleaned_data['category_id']:
main_categories = self.form.cleaned_data['maincategory_slug']
sub_categories = self.form.cleaned_data['category_slug']
if main_categories or sub_categories:
queryset = queryset.filter(
Q(category_assignment__category__parent_id__in=[c.pk for c in main_categories]) |
Q(category_assignment__category_id__in=[c.pk for c in sub_categories])
)
self._cleanup_form_data()
queryset = super(SignalFilterSet, self).filter_queryset(queryset=queryset)
return queryset.distinct()
# Custom filter functions
def contact_details_filter(self, queryset, name, value):
"""
Filter `signals.Signal` instances according to presence of contact details.
"""
choices = value # we have a MultipleChoiceFilter ...
# Deal with all choices selected, or none selected:
if len(choices) == len(contact_details_choices()):
# No filters are present, or ... all filters are present. In that
# case we want all Signal instances with an email address, or a
# phone number, or none of those (according to) the UX design.
# This is the same as not filtering, hence in both cases just
# return the queryset.
return queryset
# Set-up our Q objects for the individual options.
has_no_email = (Q(reporter__email__isnull=True) | Q(reporter__email=''))
has_no_phone = (Q(reporter__phone__isnull=True) | Q(reporter__phone=''))
is_anonymous = has_no_email & has_no_phone
q_objects = {
'email': ~has_no_email,
'phone': ~has_no_phone,
'none': is_anonymous,
}
# The individual choices have to be combined using logical OR:
q_total = q_objects[choices.pop()]
while choices:
q_total |= q_objects[choices.pop()]
return queryset.filter(q_total)
def directing_department_filter(self, queryset, name, value):
"""
Filter Signals on directing department.
* A directing department can only be set on a Parent Signal
* When providing the option "null" select all parent Signals without one or more directing departments
* When providing on or more department codes as options select all parent Signals which match directing
departments
Example 1: "?directing_department=ASC" will select all parent Signals where ASC is the directing department
Example 2: "?directing_department=ASC&directing_department=null" will select all parent Signals without a
directing department OR ASC as the directing department
Example 3: "?directing_department=null" will select all parent Signals without a directing department
"""
choices = value # we have a MultipleChoiceFilter ...
if len(choices) == len(department_choices()):
# No filters are present, or ... all filters are present. In that case we want all Signal instances
return queryset
# Directing departments are only set on parent Signals
parent_q_filter = (Q(parent__isnull=True) & Q(children__isnull=False))
if 'null' in choices and len(choices) == 1:
# "?directing_department=null" will select all parent Signals without a directing department
return queryset.filter(
parent_q_filter &
(
Q(directing_departments_assignment__isnull=True) |
Q(directing_departments_assignment__departments__isnull=True)
)
)
elif 'null' in choices and len(choices) > 1:
# "?directing_department=ASC&directing_department=null" will select all parent Signals without a directing
# department OR ASC as the directing department
choices.pop(choices.index('null'))
return queryset.filter(
parent_q_filter & (
Q(directing_departments_assignment__isnull=True) |
Q(directing_departments_assignment__departments__isnull=True) |
Q(directing_departments_assignment__departments__code__in=choices)
)
)
elif len(choices):
# "?directing_department=ASC" will select all parent Signals where ASC is the directing department
return queryset.filter(
parent_q_filter &
Q(directing_departments_assignment__departments__code__in=choices)
)
return queryset
def feedback_filter(self, queryset, name, value):
# Only signals that have feedback
queryset = queryset.annotate(feedback_count=Count('feedback')).filter(feedback_count__gte=1)
if value in ['satisfied', 'not_satisfied']:
is_satisfied = True if value == 'satisfied' else False
queryset = queryset.annotate(
feedback_max_created_at=Max('feedback__created_at'),
feedback_max_submitted_at=Max('feedback__submitted_at')
).filter(
feedback__is_satisfied=is_satisfied,
feedback__submitted_at__isnull=False,
feedback__created_at=F('feedback_max_created_at'),
feedback__submitted_at=F('feedback_max_submitted_at')
)
elif value == 'not_received':
queryset = queryset.annotate(
feedback_max_created_at=Max('feedback__created_at')
).filter(
feedback__submitted_at__isnull=True,
feedback__created_at=F('feedback_max_created_at')
)
return queryset
def kind_filter(self, queryset, name, value):
choices = value # we have a MultipleChoiceFilter ...
if (len(choices) == len(kind_choices())
or {'signal', 'parent_signal', 'child_signal'} == set(choices)
or {'parent_signal', 'exclude_parent_signal'} == set(choices)):
return queryset
q_objects = {
'signal': (Q(parent__isnull=True) & Q(children__isnull=True)),
'parent_signal': (Q(parent__isnull=True) & Q(children__isnull=False)),
'exclude_parent_signal': ~(Q(parent__isnull=True) & Q(children__isnull=False)),
'child_signal': (Q(parent__isnull=False)),
}
q_filter = q_objects[choices.pop()]
while choices:
q_filter |= q_objects[choices.pop()]
return queryset.filter(q_filter) if q_filter else queryset
def note_keyword_filter(self, queryset, name, value):
return queryset.filter(notes__text__icontains=value)
def has_changed_children_filter(self, queryset, name, value):
# we have a MultipleChoiceFilter ...
choices = list(set(map(lambda x: True if x in [True, 'True', 'true', 1] else False, value)))
q_filter = Q(children__isnull=False)
if len(choices) == 2:
return queryset.filter(q_filter)
if True in choices:
q_filter &= Q(updated_at__lt=F('children__updated_at')) # noqa Selects all parent signals with changes in the child signals
if False in choices:
q_filter &= Q(updated_at__gt=F('children__updated_at')) # noqa Selects all parent signals with NO changes in the child signals
return queryset.filter(q_filter)
class InvoiceRowFilter(FilterSet):
invoice = filters.NumberFilter()
class Meta:
model = InvoiceRow
fields = ['invoice']
class InvoiceSetFilter(FilterSet):
lease = filters.NumberFilter()
class Meta:
model = InvoiceSet
fields = ['lease']
class CollectionCourtDecisionFilter(FilterSet):
lease = filters.NumberFilter()
class Meta:
model = CollectionCourtDecision
fields = ['lease']
class InvoiceFilter(FilterSet):
lease = filters.NumberFilter()
class Meta:
model = Invoice
fields = ['lease', 'state', 'type']
class CommentFilter(FilterSet):
lease = filters.NumberFilter()
class Meta:
model = Comment
fields = ['lease', 'user', 'topic']
