class MakingOrderFilter(filters.FilterSet):
name = filters.CharFilter(field_name='name', lookup_expr='icontains')
standard = filters.CharFilter(field_name='standard', lookup_expr='icontains')
drawing_number = filters.CharFilter(field_name='drawing_number', lookup_expr='icontains')
no_supplier = filters.BooleanFilter(field_name='supplier', lookup_expr='isnull')
no_bom = filters.BooleanFilter(field_name='bill_of_material', lookup_expr='isnull')
class Meta:
model = MakingOrder
fields = [
'id', 'number', 'company', 'manufacturer', 'bill_of_material', 'bill_of_material__job_order', 'bill_of_material__type',
'name', 'standard', 'is_printed', 'supplier', 'no_supplier', 'unit_price', 'no_bom',
'bill_of_material__type__is_processed_parts'
]
order_by = filters.OrderingFilter(
choices=(
('created_at', 'created_at'),
('unit_price', 'unit_price'),
('number', 'number'),
('name', 'name'),
('supplier__name', 'supplier__name'),
('manufacturer__name', 'manufacturer__name'),
('standard', 'standard'),
('drawing_number', 'drawing_number'),
('desired_delivery_date', 'desired_delivery_date'),
('-desired_delivery_date', '-desired_delivery_date'),
('is_printed', 'is_printed')
),
)
class BillOfMaterialFilter(filters.FilterSet):
name = filters.CharFilter(field_name='name', lookup_expr='icontains')
standard = filters.CharFilter(field_name='standard', lookup_expr='icontains')
drawing_number = filters.CharFilter(field_name='drawing_number', lookup_expr='icontains')
parts_data = filters.CharFilter(field_name='partsData', method='parts_data_filter')
is_not_failure = filters.BooleanFilter(field_name='failure', lookup_expr='isnull')
@staticmethod
def parts_data_filter(queryset, name, value):
return queryset.all().filter(
Q(standard__icontains=value) | Q(drawing_number__icontains=value)
)
class Meta:
model = BillOfMaterial
fields = ['id', 'company', 'job_order', 'type', 'name', 'manufacturer', "standard", "is_printed", "parts_data",
'type__is_processed_parts', 'failure', 'is_not_failure', 'drawing_number' ]
order_by = filters.OrderingFilter(
choices=(
('created_at', 'created_at'),
('-created_at', '-created_at'),
('name', 'name'),
('-name', '-name'),
('manufacturer__name', 'manufacturer__name'),
('-manufacturer__name', '-manufacturer__name'),
('standard', 'standard'),
('-standard', '-standard'),
('drawing_number', 'drawing_number'),
('-drawing_number', '-drawing_number'),
),
)
class MonsterFilter(filters.FilterSet):
name = filters.CharFilter(method='filter_name')
element = filters.MultipleChoiceFilter(choices=Monster.ELEMENT_CHOICES)
archetype = filters.MultipleChoiceFilter(choices=Monster.TYPE_CHOICES)
leader_skill_attribute = filters.MultipleChoiceFilter(field_name='leader_skill__attribute', choices=LeaderSkill.ATTRIBUTE_CHOICES)
leader_skill_area = filters.MultipleChoiceFilter(field_name='leader_skill__area', choices=LeaderSkill.AREA_CHOICES)
order_by = filters.OrderingFilter(fields=[
'name', 'element', 'base_stars', 'archetype', 'com2us_id', 'family_id',
'raw_hp', 'raw_attack', 'raw_defense',
'base_hp', 'base_attack', 'base_defense',
'max_lvl_hp', 'max_lvl_attack', 'max_lvl_defense',
'speed', 'crit_rate', 'crit_damage', 'resistance', 'accuracy',
])
class Meta:
model = Monster
fields = {
'id': ['in'],
'com2us_id': ['exact'],
'family_id': ['exact'],
'base_stars': ['lte', 'gte'],
'obtainable': ['exact'],
'is_awakened': ['exact'],
'fusion_food': ['exact'],
'homunculus': ['exact'],
}
def filter_name(self, queryset, name, value):
if value:
return queryset.filter(name__istartswith=value)
else:
return queryset
class EventFilter(filters.FilterSet):
start_after = filters.DateFilter(field_name="start", lookup_expr="gte")
start_before = filters.DateFilter(field_name="start", lookup_expr="lte")
end_after = filters.DateFilter(field_name="end", lookup_expr="gte")
end_before = filters.DateFilter(field_name="end", lookup_expr="lte")
tags = filters.ModelMultipleChoiceFilter(
field_name="tags__name",
to_field_name="name",
queryset=Tag.objects.all(),
conjoined=True,
)
order_by = filters.OrderingFilter(fields=(
"slug",
"start",
"end",
), )
class Meta:
model = Event
fields = (
"completed",
"tags",
"administrator",
"host",
"start",
"start_before",
"start_after",
"end",
"end_before",
"end_after",
"country",
)
class ProductFilter(filters.FilterSet):
price = filters.RangeFilter(lookup_expr='range')
instock = filters.BooleanFilter(field_name='instock')
restock_date = filters.DateRangeFilter(field_name='restock_date')
restock_date__range = filters.DateFromToRangeFilter(
field_name='restock_date')
release_date = filters.DateRangeFilter(field_name='original_release_date')
release_date__range = filters.DateFromToRangeFilter(
field_name='original_release_date')
o = filters.OrderingFilter(fields=(
('price', 'price'),
('restock_date', 'restock_date'),
('original_release_date', 'original_release_date'),
('watchers', 'watchers'),
),
field_labels={
'restock_date': 'Restock Date',
'original_release_date': 'Release Date',
'watchers': 'Popularity',
})
class Meta:
model = Product
fields = [
'brand',
'instock',
]
class CoursePageFilter(filters.FilterSet):
lang_code = filters.MultipleChoiceFilter(name='lang_code', \
lookup_expr='exact', choices=settings.LANGUAGES, \
widget=forms.CheckboxSelectMultiple, initial='en', \
label=_('Language'))
keywords = filters.ModelMultipleChoiceFilter(
name='multilang_keywords',
queryset=MultilangKeyword.objects.all(),
widget=forms.CheckboxSelectMultiple,
label=_('Keywords'))
level = filters.MultipleChoiceFilter(name='level', \
lookup_expr='exact', choices=LEVELS, \
widget=forms.CheckboxSelectMultiple, \
label=_('Level'))
delivery_method = filters.MultipleChoiceFilter(name='delivery_format', \
lookup_expr='exact', choices=CoursePage.DELIVERY_FORMAT, \
widget=forms.CheckboxSelectMultiple, \
label=_('Delivery Method'))
o = filters.OrderingFilter(choices=(('title', _('Title')), ),
fields={
'title': 'title',
},
initial='title',
help_text='')
class Meta:
model = CoursePage
fields = {}
class CarFilter(filters.FilterSet):
make = filters.CharFilter(field_name="make", lookup_expr='iexact')
model = filters.CharFilter(field_name="model", lookup_expr='iexact')
ordering = filters.OrderingFilter(fields=(('make', 'make'),
('model', 'model'), ('rating',
'rating')))
class ClaimFilter(filters.FilterSet):
min_created = filters.DateTimeFilter(name='created',
lookup_expr='gte',
label='Дата создания от')
max_created = filters.DateTimeFilter(name='created',
lookup_expr='lte',
label='Дата создания до')
min_sent = filters.DateFilter(name='sent',
lookup_expr='gte',
label='Дата просмотра от')
max_sent = filters.DateFilter(name='sent',
lookup_expr='lte',
label='Дата просмотра до')
order = filters.OrderingFilter(fields=(
('questionnaire', 'questionnaire'),
('created', 'created'),
('sent', 'sent'),
),
field_labels={
'questionnaire': 'По анкете',
'created': 'По дате создания ',
'sent': 'По дате просмотра'
})
class Meta:
model = Claim
fields = (
'min_created',
'max_created',
'min_sent',
'max_sent',
)
class AlertItemFilter(filters.FilterSet):
type_of = filters.NumberFilter(field_name="type_of", )
state = filters.NumberFilter(field_name="state", )
production_slug = filters.CharFilter(field_name="production__slug", )
production_crop_slug = filters.CharFilter(field_name="production_crop__slug", )
device_slug = filters.CharFilter(field_name="device__slug", )
instrument_slug = filters.CharFilter(field_name="instrument__slug", )
o = filters.OrderingFilter(
# tuple-mapping retains order
fields=(
('created_at', 'created_at'),
('last_modified_at', 'last_modified_at'),
),
# # labels do not need to retain order
# field_labels={
# 'username': '******',
# }
)
class Meta:
model = AlertItem
fields = [
'type_of',
'state',
'production_slug',
'production_crop_slug',
'device_slug',
'instrument_slug',
]
class EventFilter(filters.FilterSet):
start_after = filters.DateFilter(field_name='start', lookup_expr='gte')
start_before = filters.DateFilter(field_name='start', lookup_expr='lte')
end_after = filters.DateFilter(field_name='end', lookup_expr='gte')
end_before = filters.DateFilter(field_name='end', lookup_expr='lte')
TAG_CHOICES = Tag.objects.all().values_list('name', 'name')
tag = filters.MultipleChoiceFilter(
choices=TAG_CHOICES,
field_name='tags',
method=filter_tag_by_name,
)
order_by = filters.OrderingFilter(fields=(
'slug',
'start',
'end',
), )
class Meta:
model = Event
fields = (
'completed',
'tag',
'start',
'start_before',
'start_after',
'end',
'end_before',
'end_after',
)
class PepFilterSet(filters.FilterSet):
fullname = filters.CharFilter(lookup_expr='icontains')
fullname_transcriptions_eng = filters.CharFilter(lookup_expr='icontains')
updated_at = filters.DateFromToRangeFilter()
name_search = filters.CharFilter(label='пошук по імені',
method='filter_name_search')
o = filters.OrderingFilter(fields=(
('fullname', 'fullname'),
('is_pep', 'is_pep'),
('pep_type', 'pep_type'),
('last_job_title', 'last_job_title'),
('last_employer', 'last_employer'),
), )
def filter_name_search(self, queryset, name, value):
return queryset.filter(
Q(fullname__icontains=value)
| Q(fullname_transcriptions_eng__icontains=value))
class Meta:
model = Pep
fields = {
'is_pep': ['exact'],
'is_dead': ['exact'],
}
class UserPartnerFilter(filters.FilterSet):
name = filters.CharFilter(field_name='name', lookup_expr='icontains')
abbr = filters.CharFilter(lookup_expr='icontains')
partnerNumber = filters.CharFilter(field_name='partner_number',
lookup_expr='contains')
incremental_field = filters.CharFilter(field_name='incrementalFilter',
method='incremental_filter')
@staticmethod
def incremental_filter(queryset, name, value):
return queryset.all().filter(
Q(abbr__icontains=value) | Q(partner_number__icontains=value)
| Q(name__icontains=value))
class Meta:
model = UserPartner
fields = [
'id', 'company', 'name', 'partnerNumber', 'is_customer',
'is_delivery_destination', 'is_supplier', 'is_manufacturer', 'abbr'
]
order_by = filters.OrderingFilter(fields=(
('created_at', 'created_at'),
('name', 'name'),
('partner_number', 'partner_number'),
), )
class TagFilter(filters.FilterSet):
author = filters.CharFilter(field_name="commits__author_name",
lookup_expr="icontains",
distinct=True)
branch = filters.CharFilter(field_name="branch__name",
lookup_expr="icontains")
order = filters.OrderingFilter(
fields={
("branch", "branch"),
("name", "name"),
("dependency1_version", "dependency1_version"),
("dependency2_version", "dependency2_version"),
("dependency3_version", "dependency3_version"),
("release_time", "release_time"),
})
# issue_id = IDSearchFilter(quer)
class Meta:
model = Tag
fields = "__all__"
filter_overrides = {
models.CharField: {
'filter_class': filters.CharFilter,
'extra': lambda f: {
'lookup_expr': 'icontains',
},
},
}
class MarketTradesFilter(filters.FilterSet):
creation_date_time = filters.DateTimeFromToRangeFilter()
collateral_token = filters.CharFilter(method='filter_collateral_token')
ordering = filters.OrderingFilter(fields=(('creation_date_time',
'creation_date_order'), ))
class Meta:
model = Order
fields = (
'creation_date_time',
'collateral_token',
)
def __init__(self, data=None, *args, **kwargs):
# if filterset is bound, use initial values as defaults
if data is not None and not 'creation_date_time_after' in data and not 'creation_date_time_before' in data:
data = data.copy()
data['creation_date_time_after'] = (
timezone.now() -
timedelta(days=14)).strftime('%Y-%m-%d %H:%M:%S')
data['creation_date_time_before'] = timezone.now()
super().__init__(data, *args, **kwargs)
def filter_collateral_token(self, queryset, name, value):
value = normalize_address_or_raise(value)
return queryset.filter(market__event__collateral_token__iexact=value)
class OrderFilter(filters.FilterSet):
order_by = filters.OrderingFilter(
fields=['id', 'starts_at', 'created_at', 'updated_at'])
keyword = filters.CharFilter(method='filter_keyword')
def filter_keyword(self, queryset, name, value):
if not value:
return queryset
q1 = Q(order_number__icontains=value)
q2 = Q(full_name__icontains=value)
q3 = Q(mobile=value)
queryset = queryset.filter(q1 | q2 | q3)
return queryset
class Meta:
strict = STRICTNESS.RETURN_NO_RESULTS
model = Order
fields = {
'id': ['exact', 'in'],
'category': ['exact', 'in'],
'status': ['exact', 'in'],
'order_number': ['exact', 'icontains'],
'starts_at': ['gte', 'lte'],
'ends_at': ['gte', 'lte'],
}
class UltimateOracleFilter(filters.FilterSet):
creator = filters.AllValuesMultipleFilter()
creation_date_time = filters.DateTimeFromToRangeFilter()
is_outcome_set = filters.BooleanFilter()
forwarded_oracle_creator = filters.AllValuesMultipleFilter(
name='forwarded_oracle__creator')
forwarded_oracle_creation_date_time = filters.DateTimeFromToRangeFilter(
name='forwarded_oracle__creation_date_time')
forwarded_oracle_is_outcome_set = filters.BooleanFilter(
name='forwarded_oracle__is_outcome_set')
forwarded_oracle_factory = filters.AllValuesMultipleFilter(
name='forwarded_oracle__factory')
ordering = filters.OrderingFilter(
fields=(('creation_date_time', 'creation_date_order'),
('forwarded_oracle__creation_date_time',
'forwarded_oracle_creation_date_order')))
class Meta:
model = UltimateOracle
fields = ('creator', 'creation_date_time', 'is_outcome_set',
'forwarded_oracle_creator',
'forwarded_oracle_creation_date_time',
'forwarded_oracle_is_outcome_set',
'forwarded_oracle_factory', 'ordering')
class AssetFilter(filters.FilterSet):
path = filters.CharFilter(lookup_expr='istartswith')
order = filters.OrderingFilter(fields=['created', 'modified', 'path'])
class Meta:
model = Asset
fields = ['path']
class EventFilter(filters.FilterSet):
start_after = filters.DateFilter(field_name='start', lookup_expr='gte')
start_before = filters.DateFilter(field_name='start', lookup_expr='lte')
end_after = filters.DateFilter(field_name='end', lookup_expr='gte')
end_before = filters.DateFilter(field_name='end', lookup_expr='lte')
tags = filters.ModelMultipleChoiceFilter(
field_name='tags__name',
to_field_name='name',
queryset=Tag.objects.all(),
conjoined=True,
)
order_by = filters.OrderingFilter(fields=(
'slug',
'start',
'end',
), )
class Meta:
model = Event
fields = (
'completed',
'tags',
'administrator',
'host',
'start',
'start_before',
'start_after',
'end',
'end_before',
'end_after',
'country',
)
class BranchFilterSet(filters.FilterSet):
search = filters.CharFilter(method='filter_by_search')
location = NumberInFilter(method='filter_by_location')
o = filters.OrderingFilter(
fields=(
('name', 'name'),
('created', 'created'),
('modified', 'modified'),
),
)
class Meta:
model = Branch
fields = ['search']
def filter_by_search(self,
queryset: BranchQueryset,
name: str,
value: str) -> models.QuerySet:
return queryset.search(value)
def filter_by_location(self,
queryset: BranchQueryset,
name: str,
value: Sequence[Union[Decimal, int]]) -> models.QuerySet:
if len(value) > 3 or len(value) < 2:
return queryset.none()
return queryset.order_by_distance(*value)
class MarketFilter(filters.FilterSet):
creator = AddressInFilter(lookup_expr='in')
creation_date_time = filters.DateTimeFromToRangeFilter()
market_maker = filters.AllValuesMultipleFilter()
event_oracle_factory = filters.AllValuesMultipleFilter(
name='event__oracle__factory')
event_oracle_creator = filters.AllValuesMultipleFilter(
name='event__oracle__creator')
event_oracle_creation_date_time = filters.DateTimeFromToRangeFilter(
name='event__oracle__creation_date_time')
# TODO refactor, maybe duplicate resolution_date from event_description to market
resolution_date_time = filters.DateTimeFromToRangeFilter(
name=
'event__oracle__centralizedoracle__event_description__resolution_date')
event_oracle_is_outcome_set = filters.BooleanFilter(
name='event__oracle__is_outcome_set')
ordering = filters.OrderingFilter(fields=(
('creation_date_time', 'creation_date_order'),
('event__oracle__creation_date_time',
'event_oracle_creation_date_order'),
('resolution_date_time', 'resolution_date_order'),
))
class Meta:
model = Market
fields = ('creator', 'creation_date_time', 'market_maker',
'event_oracle_factory', 'event_oracle_creator',
'event_oracle_creation_date_time',
'event_oracle_is_outcome_set', 'resolution_date_time')
class MessageFilter(filters.FilterSet):
sort = filters.OrderingFilter(fields=('createTime', ))
content = filters.CharFilter(field_name='content', lookup_expr='icontains')
class Meta:
model = Message
fields = ['id', 'session_id']
class CompanySanctionFilterSet(BaseSanctionFilter):
name = filters.CharFilter(
lookup_expr='icontains',
help_text=
'Filter by name of company. Type: case insensitive string contains',
)
name_original = filters.CharFilter(
lookup_expr='icontains',
help_text=
'Filter by name original of company. Type: case insensitive string contains',
)
address = filters.CharFilter(
lookup_expr='icontains',
help_text=
'Filter by address of company. Type: case insensitive string contains',
)
registration_date = filters.DateFromToRangeFilter(
help_text=
'You can use key "registration_date_before" to select objects before the specified date and '
'"registration_date_after" key to select objects after the specified date. '
'Date must be in YYYY-MM-DD format.', )
registration_number = filters.CharFilter(
lookup_expr='icontains',
help_text=
'Filter by registration number of company. Type: case insensitive string contains',
)
taxpayer_number = filters.CharFilter(
lookup_expr='icontains',
help_text=
'Filter by taxpayer number of company. Type: case insensitive string contains',
)
additional_info = filters.CharFilter(
lookup_expr='icontains',
help_text=
'Filter by additional info of company. Type: case insensitive string contains',
)
country_of_registration = filters.CharFilter(
method='filter_two_country_of_registration_fields',
distinct=True,
help_text=
'Filter by country_of_registration of company in English and Ukrainian.'
'Type: case insensitive string contains',
)
o = filters.OrderingFilter(
fields=(
('name', 'name'),
('start_date', 'start_date'),
('end_date', 'end_date'),
),
help_text='Sort by fields: name, start_date, end_date.')
def filter_two_country_of_registration_fields(self, queryset, name, value):
return queryset.filter(
Q(country_of_registration__name__icontains=value)
| Q(country_of_registration__name_uk__icontains=value))
class Meta:
model = CompanySanction
fields = ()
class RankingFilter(FilterSet):
o = filters.OrderingFilter(
fields=['energy_consumption', "electricity_access"],
widget=widgets.LinkWidget)
class Meta:
model = Ranking
fields = ['country', 'year', "o"]
class NewsFilter(filters.FilterSet):
type = filters.CharFilter(field_name='type', lookup_expr='icontains')
content = filters.CharFilter(field_name='content', lookup_expr='icontains')
sort = filters.OrderingFilter(fields=('createTime', ))
class Meta:
model = News
fields = ['id', 'checked']
class DateRangeFilter(filters.FilterSet):
date_range = filters.DateFromToRangeFilter(field_name="date", label="日付範囲")
order_by = filters.OrderingFilter(
fields=(('date', 'date'), ),
# labels do not need to retain order
field_labels={
'date': "日付",
})
def filterset_class_generator(model):
fields = [(field.name, field.name) for field in model._meta.fields]
ordering = filters.OrderingFilter(fields=fields)
meta = type('Meta', (), {'model': model, 'fields': '__all__'})
return type(
f'{model.__name__}FilterSet',
(filters.FilterSet,),
{'ordering': ordering, 'Meta': meta},
)
class MetricsFilters(filters.FilterSet):
date_from = filters.DateFilter(field_name='date', lookup_expr='gte')
date_to = filters.DateFilter(field_name='date', lookup_expr='lte')
sort = filters.OrderingFilter(
# Enable all fields in models to be used in sorting
fields=tuple(
(field.name, field.name) for field in Metrics._meta.fields))
group_by = filters.CharFilter(method='groupby_filter')
show = filters.CharFilter(method='show_filter')
def show_filter(self, queryset, name, value):
"""
Pass queryset forward.
show filter is used to simply keeps query_params in self.data
"""
return queryset
def groupby_filter(self, queryset, name, value):
groupby_fields = value.split(',')
groupby_fields = [
x for x in groupby_fields if x in VALID_GROUPBY_FIELDS
]
show_params = self.data.get('show', None)
show_fields = [] # fields to sum
if show_params is not None:
show_fields = [
x for x in show_params.split(',') if x in VALID_SHOW_FIELDS
]
if len(show_fields) == 0:
show_fields = VALID_SHOW_FIELDS
# valid field for sort should be the union of groupby and show
valid_sort_fields = list(set(show_fields) | set(groupby_fields))
sort_params = self.data.get('sort', None)
sort_fields = []
if sort_params is not None:
sort_fields = [
x for x in sort_params.split(',')
if x.lstrip('-') in valid_sort_fields
]
if len(sort_fields) == 0:
sort_fields = show_fields[:1]
qs = queryset
if len(groupby_fields) != 0:
qs = qs.values(*groupby_fields).order_by(*groupby_fields)\
.annotate(**{key:Sum(key) for key in show_fields})
# re-sort the queryset because after group by the original sort will be invalid
qs = qs.order_by(*sort_fields)
return qs
class Meta:
model = Metrics
fields = ('channel', 'country', 'os', 'date_from', 'date_to', 'sort')
class ListFilter(filters.FilterSet):
is_archive = filters.BooleanFilter(field_name='is_archive')
order_by = filters.OrderingFilter(fields=[('order', 'order')])
class Meta:
model = List
fields = [
'is_archive',
'order_by',
]
class CourtFilter(filters.FilterSet):
# TODO:更多筛选信息
type = filters.CharFilter(field_name='type', lookup_expr='icontains')
priceGt = filters.NumberFilter(field_name='price', lookup_expr='gt')
priceLt = filters.NumberFilter(field_name='price', lookup_expr='lt')
sort = filters.OrderingFilter(fields=('price', ))
class Meta:
model = Court
fields = ['id', 'stadium_id', 'openState', 'floor', 'location']
class ProductFilter(filters.FilterSet):
order_by = filters.OrderingFilter(fields=['id', 'username', 'is_active'])
class Meta:
model = Product
fields = {
'id': ['exact', 'in'],
'name': ['exact', 'icontains'],
'price': ['lte', 'gte'],
}
