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'], }