class SubmissionFilter(filters.FilterSet):
"""Class to be able to filter Submission on the API view."""
submission_date = filters.IsoDateTimeFromToRangeFilter(
field_name="submission_date",
)
author_mail = filters.CharFilter(
field_name="author__mail", label="Mail de l'auteur"
)
exercises = filters.ModelMultipleChoiceFilter(
field_name="exercise__id",
to_field_name="id",
queryset=Exercise.objects.all(),
)
specific_errors_by_id = filters.ModelMultipleChoiceFilter(
field_name="errors__error__id",
to_field_name="id",
queryset=Error.objects.all(),
)
specific_errors_by_code = filters.ModelMultipleChoiceFilter(
field_name="errors__error__code",
to_field_name="code",
queryset=Error.objects.all(),
)
errors_counter_range = filters.RangeFilter(field_name="errors__counter")
class Meta(object):
"""The Meta class that defines the fields available."""
model = Submission
fields = (
"submission_date",
"author_mail",
"exercises",
"not_executed",
"final",
"errors",
"specific_errors_by_id",
"specific_errors_by_code",
"errors_counter_range",
)
class PeriodFilter(filters.FilterSet):
game_slug = filters.CharFilter(name='game_slug-filter',
method='filter_runuser_and_worlds_in_game')
run_active = filters.BooleanFilter(
name='run_active-filter',
method='filter_runuser_and_worlds_in_run_active')
run = filters.NumberFilter(name='run-filter',
method='filter_runuser_and_worlds_in_run')
def filter_runuser_and_worlds_in_game(self, queryset, name, value):
"""
We need to retrieve Periods in Scenarios which are attached to worlds
or runusers in the given game slug
"""
return queryset.filter(
Q(scenario__world__run__game__slug=value)
| Q(scenario__runuser__run__game__slug=value))
def filter_runuser_and_worlds_in_run_active(self, queryset, name, value):
"""
We need to retrieve Periods in Scenarios which are attached to worlds
or runusers in runs with active value
"""
return queryset.filter(
Q(scenario__world__run__active=value)
| Q(scenario__runuser__run__active=value))
def filter_runuser_and_worlds_in_run(self, queryset, name, value):
"""
We need to retrieve Periods in Scenarios which are attached to worlds or runusers
in the given run
"""
return queryset.filter(
Q(scenario__world__run=value) | Q(scenario__runuser__run=value))
class Meta:
model = models.Period
fields = [
'scenario', 'order', 'game_slug', 'run_active', 'run',
'scenario__world__run', 'scenario__runuser__run'
]
class TaskFilter(filters.FilterSet):
project = filters.CharFilter(field_name="project__name",
lookup_expr="icontains")
name = filters.CharFilter(field_name="name", lookup_expr="icontains")
owner = filters.CharFilter(field_name="owner__username",
lookup_expr="icontains")
mode = filters.CharFilter(field_name="mode", lookup_expr="icontains")
status = filters.CharFilter(field_name="status", lookup_expr="icontains")
assignee = filters.CharFilter(field_name="assignee__username",
lookup_expr="icontains")
class Meta:
model = Task
fields = ("id", "project_id", "project", "name", "owner", "mode",
"status", "assignee")
class Collection2Filter(filters.FilterSet):
# example of an OR filter.
# this filters a range of fields for the given value of 'fieldsearch='.
# example: http://localhost:8000/my_astrobase/observations/?fieldsearch=aurora
fieldsearch = filters.CharFilter(field_name='fieldsearch',
method='search_my_fields')
def search_my_fields(self, queryset, name, value):
return queryset.filter(
Q(name__icontains=value) | Q(description__icontains=value))
class Meta:
model = Collection2
fields = {
'description': ['exact', 'icontains'],
'name': ['exact', 'icontains'],
'collection_type': ['icontains', 'exact'],
# 'fieldsearch': ['exact', 'icontains', 'in']
}
class CategoryFilter(filters.FilterSet):
active = filters.BooleanFilter(field_name='available')
id = filters.CharFilter(method='filter_ids')
class Meta:
model = Product
fields = {
'name': ['exact', 'contains', 'icontains'],
'english_name': ['exact', 'contains', 'icontains'],
'slug': ['exact', 'contains', 'icontains'],
}
def filter_ids(self, queryset, name, value):
items = [item.strip("'\" ") for item in value.strip('[]').split(',')]
excludes = [i[1:] for i in items if i.startswith("-")]
if len(excludes) > 0:
return queryset.filter(~Q(id__in=excludes))
elif len(items) > 0:
return queryset.filter(id__in=items)
else:
return queryset
class PostFilter(filters.FilterSet):
"""Postモデル用フィルタクラス"""
keyword = filters.CharFilter(
method='title_or_text_or_author_or_prefecture_or_location_filter', )
categorys = filters.ModelMultipleChoiceFilter(
field_name='category__name',
to_field_name='name',
queryset=Category.objects.all(),
)
class Meta:
model = Post
fields = ['keyword', 'categorys', 'prefecture']
def title_or_text_or_author_or_prefecture_or_location_filter(
self, queryset, name, value):
return queryset.filter(
Q(title__icontains=value) | Q(text__icontains=value)
| Q(author__username__icontains=value)
| Q(prefecture__icontains=value) | Q(location__icontains=value))
class InternalRunFilterSet(django_filters.FilterSet):
"""FilterSet for limiting Runs for the internal API."""
username = django_filters.CharFilter(
field_name="instance__cloud_account__user__username"
)
cloud_account = django_filters.NumberFilter(field_name="instance__cloud_account")
class Meta:
model = models.Run
fields = {
"instance": ["exact"],
"instance_type": ["exact"],
"machineimage": ["exact"],
"memory": ["exact"],
"vcpu": ["exact"],
"start_time": ["lt", "exact", "gt"],
"end_time": ["lt", "exact", "gt"],
"created_at": ["lt", "exact", "gt"],
"updated_at": ["lt", "exact", "gt"],
}
class AppealHistoryFilter(filters.FilterSet):
atype = filters.NumberFilter(field_name='atype', lookup_expr='exact')
dtype = filters.NumberFilter(field_name='dtype', lookup_expr='exact')
country = filters.NumberFilter(field_name='country', lookup_expr='exact')
region = filters.NumberFilter(field_name='region', lookup_expr='exact')
code = filters.CharFilter(field_name='code', lookup_expr='exact')
status = filters.NumberFilter(field_name='status', lookup_expr='exact')
# Do not use, misleading: id = filters.NumberFilter(field_name='id', lookup_expr='exact')
appeal_id = filters.NumberFilter(
field_name='appeal_id',
lookup_expr='exact',
help_text='Use this (or code) for appeal identification.')
class Meta:
model = AppealHistory
fields = {
'start_date': ('exact', 'gt', 'gte', 'lt', 'lte'),
'end_date': ('exact', 'gt', 'gte', 'lt', 'lte'),
'valid_from': ('exact', 'gt', 'gte', 'lt', 'lte'),
'valid_to': ('exact', 'gt', 'gte', 'lt', 'lte'),
}
class ZaakTypeInformatieObjectTypeFilter(FilterSet):
status = filters.CharFilter(
field_name="zaaktype__concept",
method="status_filter_m2m",
help_text=STATUS_HELP_TEXT,
)
class Meta:
model = ZaakTypeInformatieObjectType
fields = ("zaaktype", "informatieobjecttype", "richting", "status")
def status_filter_m2m(self, queryset, name, value):
if value == "concept":
return queryset.filter(
models.Q(zaaktype__concept=True)
| models.Q(informatieobjecttype__concept=True))
elif value == "definitief":
return queryset.filter(zaaktype__concept=False,
informatieobjecttype__concept=False)
elif value == "alles":
return queryset
class ComplectationFilter(filters.FilterSet):
name = filters.CharFilter(lookup_expr='contains')
color = filters.ChoiceFilter(lookup_expr='exact')
min_engine_size = filters.NumberFilter(field_name='engine_size', lookup_expr='gte')
max_engine_size = filters.NumberFilter(field_name='engine_size', lookup_expr='lte')
min_power = filters.NumberFilter(field_name='power', lookup_expr='gte')
max_power = filters.NumberFilter(field_name='power', lookup_expr='lte')
min_torque = filters.NumberFilter(field_name='torque', lookup_expr='gte')
max_torque = filters.NumberFilter(field_name='torque', lookup_expr='lte')
min_year = filters.NumberFilter(field_name='year', lookup_expr='gte')
max_year = filters.NumberFilter(field_name='year', lookup_expr='lte')
gearbox = filters.ChoiceFilter(lookup_expr='exact')
class Meta:
model = Complectation
fields = ('name', 'color', 'engine_size', 'power', 'torque', 'drive_train', 'gearbox', 'year',)
class ProfilesFilterSet(filters.FilterSet):
"""FilterSet for profile API views."""
search = filters.CharFilter(method='search_by_username')
class Meta: # noqa: Z306, D106
model = Profile
fields = ()
def search_by_username(self, queryset, name, expr):
"""First starting with expr, then containing expr."""
queryset = queryset.annotate(
expr_position=StrIndex('user__username', Value(expr)),
).filter(
expr_position__gt=0,
).order_by(
'expr_position',
'user__username',
)
return queryset
class ProductFilter(filters.FilterSet):
# Product.objects.filter(name__contains=name)
name = filters.CharFilter(lookup_expr='contains')
# Product.objects.filter(price=price)
price = filters.NumberFilter(lookup_expr='exact')
# Product.objects.filter(price__gte=min_price)
min_price = filters.NumberFilter(field_name='price', lookup_expr='gte')
# Product.objects.filter(price__lte=max_price)
max_price = filters.NumberFilter(field_name='price', lookup_expr='lte')
class Meta:
model = Product
fields = (
'name',
'price',
'min_price',
'max_price',
)
class InitiativeFilterSet(filters.FilterSet):
type = CharInFilter(field_name='type', lookup_expr='in')
zone = CharInFilter(field_name='zone', lookup_expr='in')
area = CharInFilter(field_name='area', lookup_expr='in')
no_zone = filters.BooleanFilter(field_name='zone', lookup_expr='isnull')
statuses = filters.CharFilter(method='filter_statuses')
def filter_statuses(self, queryset, name, value):
last_status_initiatives = StatusInitiative.objects.filter(
publication_status=Published.PUBLISHED).order_by(
'initiative', '-created').distinct('initiative')
last_filtered_status_initiatives = StatusInitiative.objects.filter(
id__in=last_status_initiatives, status__id__in=value.split(','))
return queryset.filter(
initiative_statuses__in=last_filtered_status_initiatives)
class Meta:
model = Initiative
fields = ['zone', 'area', 'type', 'no_zone', 'statuses']
class ProductFilter(filters.FilterSet):
category = filters.CharFilter(field_name="category__name")
_type = filters.CharFilter(field_name="_type__name")
color = filters.CharFilter(field_name="color__name")
material = filters.CharFilter(field_name="material__name")
brand = filters.CharFilter(field_name="brand__name")
size = filters.CharFilter(field_name="size__name")
min_price = filters.NumberFilter(field_name="price", lookup_expr='gte')
max_price = filters.NumberFilter(field_name="price", lookup_expr='lte')
class Meta:
model = Product
fields = [
'category', '_type', 'min_price', 'max_price', 'size', 'color',
'material', 'brand'
]
class WtbEntityFilterSet(rest_framework.FilterSet):
brands = rest_framework.ModelMultipleChoiceFilter(
queryset=create_wtb_brand_filter(),
name='brand',
label='Brands'
)
categories = rest_framework.ModelMultipleChoiceFilter(
queryset=create_category_filter(),
name='category',
label='Categories'
)
keys = rest_framework.CharFilter(
name='key',
label='Key'
)
is_associated = rest_framework.BooleanFilter(
name='is_associated', method='_is_associated', label='Is associated?')
@property
def qs(self):
qs = super(WtbEntityFilterSet, self).qs.select_related(
'brand',
'category',
'product'
)
brands_with_permission = create_wtb_brand_filter()(self.request)
categories_with_permission = create_category_filter()(self.request)
return qs.filter(
Q(brand__in=brands_with_permission) &
Q(category__in=categories_with_permission))
def _is_associated(self, queryset, name, value):
return queryset.filter(product__isnull=not value)
class Meta:
model = WtbEntity
fields = ['is_active', 'is_visible', 'product']
class MonitorAlertFilter(filters.FilterSet):
title = filters.CharFilter(field_name="title",
lookup_expr='icontains',
label="告警标题")
source = filters.CharFilter(field_name="source",
lookup_expr='exact',
label="告警来源")
# trigger_name = filters.CharFilter(field_name="trigger_name", lookup_expr='icontains', label="告警触发器的名称")
level = filters.CharFilter(field_name="level",
lookup_expr='exact',
label="告警级别")
status = filters.CharFilter(field_name="status",
lookup_expr='exact',
label="告警状态")
# start_time_begin = filters.CharFilter(field_name="start_time", lookup_expr='ge', label="告警时间起始")
# start_time_end = filters.CharFilter(field_name="start_time", lookup_expr='le', label="告警时间终止")
start_time_begin = filters.CharFilter(field_name="start_time",
label="告警时间起始",
method='begin_unixtime_to_datetime')
start_time_end = filters.CharFilter(field_name="start_time",
label="告警时间终止",
method='end_unixtime_to_datetime')
server = filters.CharFilter(field_name="server__manager_ip",
lookup_expr='icontains',
label="服务器")
class Meta:
model = MonitorAlertModel
fields = [
"title", "source", "level", "status", "server", "start_time_begin",
"start_time_end"
]
def begin_unixtime_to_datetime(self, queryset, name, value):
value = time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(int(value) / 1000))
return queryset.filter(start_time__gt=value)
def end_unixtime_to_datetime(self, queryset, name, value):
value = time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(int(value) / 1000))
return queryset.filter(start_time__lt=value)
class WorkareaEntryFilter(filters.FilterSet):
type = filters.CharFilter(method='filter_type')
class Meta:
model = Workarea
fields = (
'type',
'user',
'read_only',
)
def filter_type(self, queryset, name, value):
workarea_type_reverse = dict(
(v.lower(), k) for k, v in Workarea.TYPE_CHOICES)
try:
workarea_type = workarea_type_reverse[value]
except KeyError:
raise exceptions.ParseError(
'Workarea of type "%s" does not exist' % value)
return queryset.filter(**{name: workarea_type})
class ProductFilter(filters.FilterSet):
# products/?name=pencil
name = filters.CharFilter(field_name='pro_name')
# products/?is_soldout=true
is_soldout = filters.BooleanFilter(method='filter_is_soldout')
# products/?than_hundred=true
than_hundred = filters.BooleanFilter(method='filter_than_hundred')
class Meta:
model = Product
fields = ['name', 'is_soldout', 'than_hundred'] # 이 fields 는 어떤 역할인지 궁금합니다.
# 재고량(inventory)이 0인 객체 찾기 (목적 : 품절 확인)
def filter_is_soldout(self, queryset, name, value):
filtered_queryset = queryset.filter(inventory__lte=0)
return filtered_queryset
# 재고량(inventory)이 100개 이상인 객체 찾기 (목적 : 발주 조절)
# ProductViewSet 의 @action 기능과 겹친다.
def filter_than_hundred(self, queryset, name, value):
filtered_queryset = queryset.filter(inventory__gte=100)
return filtered_queryset
class ChannelFilterSet(filters.FilterSet):
channel = filters.CharFilter(field_name="_", method="filter_channel")
def filter_channel(self, queryset, name, value):
if not value:
return queryset
channel = (
audio_models.Channel.objects.filter(uuid=value)
.select_related("library")
.first()
)
if not channel:
return queryset.none()
uploads = models.Upload.objects.filter(library=channel.library)
actor = utils.get_actor_from_request(self.request)
uploads = uploads.playable_by(actor)
ids = uploads.values_list(self.Meta.channel_filter_field, flat=True)
return queryset.filter(pk__in=ids).distinct()
class CrossAccountRequestFilter(filters.FilterSet):
"""Filter for cross account request."""
def account_filter(self, queryset, field, values):
"""Filter to lookup requests by target_account."""
accounts = values.split(",")
return queryset.filter(target_account__in=accounts)
def approved_filter(self, queryset, field, value):
"""Filter to lookup requests by status of approved."""
if value:
return queryset.filter(status="approved").filter(
start_date__lt=timezone.now(), end_date__gt=timezone.now())
return queryset
account = filters.CharFilter(field_name="target_account",
method="account_filter")
approved_only = filters.BooleanFilter(field_name="end_date",
method="approved_filter")
class Meta:
model = CrossAccountRequest
fields = ["account", "approved_only"]
class GoodsListFilter(filters.FilterSet):
# 该类中写你需要过滤的字段
# field_name='name' 过滤name字段，要求是包含，也就是模糊搜索
keyword = filters.CharFilter(field_name='name',
lookup_expr='icontains',
label='商品名称包含')
# field_name='shop_price' 是作用于商品售价
pricemin = filters.NumberFilter(field_name='shop_price',
lookup_expr='gte',
label='商品售价大于等于')
pricemax = filters.NumberFilter(field_name='shop_price',
lookup_expr='lte',
label='商品售价小于等于')
# 目前这个商品列表只接收以下的过滤条件：
# keyword pricemin pricemax ordering search
# 但是前端在请求某一个一级类目下的列表页的时候，又额外的传递了一个过滤条件top_category
# 新增一个top_category(一级类目的ID)的过滤条件
# 上面三个过滤条件都是依托于Goods模型中现有的一些字段进行的过滤，但是这个top_category是一级类目的ID，Goods这个模型中没有这个字段，所以不能指定field_name
top_category = filters.NumberFilter(method='custom_top_category_filter',
label='一级类目ID')
is_hot = filters.BooleanFilter(field_name='is_hot', label='是否是热门商品')
def custom_top_category_filter(self, *args, **kwargs):
"""
自定义过滤字段
:param args: 1. queryset(所有商品的集合) 2.str: top_category 3. int: 1(表示前端传递的一级类目的ID)
:param kwargs:
:return:
"""
queryset = args[0].filter(category__parent_category_id=args[2])
return queryset
class Meta:
# 指定过滤的模型：你需要对哪一个表的数据进行过滤
model = Goods
# 指定过滤字段
# ?keyword=牛奶
fields = ('keyword', 'pricemin', 'pricemax', 'top_category', 'is_hot')
class OrderFilter(filters.FilterSet):
"""Фильтры для заказов."""
status = filters.ChoiceFilter(choices=OrderStatusChoices.choices)
price_from = filters.NumberFilter(field_name='total_price',
lookup_expr="gte")
price_to = filters.NumberFilter(field_name='total_price',
lookup_expr="lte")
products = filters.CharFilter()
created_at = filters.DateFromToRangeFilter()
updated_at = filters.DateFromToRangeFilter()
class Meta:
model = Order
fields = (
'status',
'price_from',
'price_to',
'products',
'created_at',
'updated_at',
)
class GoodsFilter(filters.FilterSet):
# 最小价格100 ---> 大于或者等于
pricemin = filters.NumberFilter(field_name="shop_price", lookup_expr="gte")
# 最大价格200 --- > 小于或者等于
pricemax = filters.NumberFilter(field_name="shop_price", lookup_expr="lte")
# 检索name字段对应的内容： 我是中国人-->人，我，中国人
name = filters.CharFilter(field_name="name", lookup_expr="icontains")
# 自定义top_category过滤字段,名字不能改
top_category = filters.NumberFilter(method="filter_top_category")
# 调用方法，返回什么就得到什么数据
# 第一个GoodsFilter实例对象，第二参数：所有商品数据集合，第三个参数top_category，第四个参数商品类别的id
def filter_top_category(self, queryset, name, value):
# print("self==",self)
# print("queryset==", queryset)
# print("queryset size==",len(queryset))
# #top_category
# print("name==",name)
# #1,24,40 商品类别的id号
# print("value==",value)
# 如果没有传入top_category，返回没有过滤的数据
if name:
# 根据传入的商品列表的id，查找该商类别对应的商品，并且返回列表
# category_id和category__id等价
# category__parent_category__id 和category__parent_category_id 等价
queryset = queryset.filter(
Q(category_id=value) | Q(category__parent_category_id=value))
return queryset
return queryset
# 内部类
class Meta:
# 指定对Goods进行过滤
model = Goods
fields = ("pricemin", "pricemax", "name", "is_hot", "is_new")
class ListingFilter(filters.FilterSet):
q = filters.CharFilter(method='custom_method_lookup')
min_price = filters.NumberFilter(field_name="price", lookup_expr='gte')
max_price = filters.NumberFilter(field_name="price", lookup_expr='lte')
min_square_feet = filters.NumberFilter(field_name="square_feet",
lookup_expr='gte')
max_square_feet = filters.NumberFilter(field_name="square_feet",
lookup_expr='lte')
class Meta:
model = Listing
fields = [
'q', 'sale_type', 'bed_room', 'bath_room', 'min_price',
'max_price', 'min_square_feet', 'max_square_feet'
]
@staticmethod
def custom_method_lookup(queryset, name, value):
return queryset.filter(
Q(title__icontains=value) | Q(address__icontains=value)
| Q(city__icontains=value) | Q(state__icontains=value))
class BillsFilter(filters.FilterSet):
"""
账目过滤器
"""
bill_type = filters.NumberFilter(name='bill_type')
min_amount = filters.NumberFilter(name='amount', lookup_expr='gte')
max_amount = filters.NumberFilter(name='amount', lookup_expr='lte')
start_date = filters.DateFilter(name='record_date', lookup_expr='gte')
end_date = filters.DateFilter(name='record_date', lookup_expr='lte')
remarks = filters.CharFilter(name='remarks', lookup_expr='icontains')
class Meta:
model = Bills
fields = (
'category',
'bill_type',
'min_amount',
'max_amount',
'start_date',
'end_date',
'remarks',
)
class SpaceFilter(rest_framework.FilterSet):
contains_more_than_n_categories = rest_framework.CharFilter(
label=('Содержится видов животных больше чем n:'),
method="filter_by_categories_count")
categories__animals__name = filters.CharFilter(
label=('Фильтр по имени животного:'))
categories__animals__description = filters.CharFilter(
label=('Фильтр по описанию животного:'))
categories__animals__gender = filters.CharFilter(
label=('Фильтр по полу животного:'))
categories__animals__age = filters.CharFilter(
label=('Фильтр по возрасту животного:'))
categories__animals__created_at = filters.CharFilter(
label=('Фильтр по дате появления животного:'))
categories__animals__color = filters.CharFilter(
label=('Фильтр по цвету животного:'))
class Meta:
model = Space
fields = [
"name",
"placementperiods",
"description",
"illumination",
"type",
"square",
"categories__animals__name",
"categories__animals__description",
"categories__animals__gender",
"categories__animals__age",
"categories__animals__created_at",
"categories__animals__color",
]
def filter_by_categories_count(self, queryset, name, value):
queryset = Space.objects.annotate(
num_categories=Count('categories')).filter(
num_categories__gt=value)
return queryset
class ProductFilter(filters.FilterSet):
min_price = filters.NumberFilter(field_name="price", lookup_expr="gte")
max_price = filters.NumberFilter(field_name="price", lookup_expr="lte")
max_box_quantity = filters.NumberFilter(field_name="box_quantity",
lookup_expr="lte")
min_box_quantity = filters.NumberFilter(field_name="box_quantity",
lookup_expr="gte")
category = filters.CharFilter(field_name="category__slug",
method="filter_category")
def filter_category(self, queryset, name, value):
# category = get_object_or_404(Category, slug=value)
# if category.child:
# products = Product.objects.none()
# for cat in category.child.all():
# products |= Product.objects.filter(category__slug=cat.slug)
# return products
return Product.objects.filter(category__slug=value)
class Meta:
model = Product
fields = ["price", "category", "box_quantity"]
class CourseRunFilter(FilterSetMixin, filters.FilterSet):
active = filters.BooleanFilter(method='filter_active')
marketable = filters.BooleanFilter(method='filter_marketable')
keys = CharListFilter(field_name='key', lookup_expr='in')
license = filters.CharFilter(field_name='license', lookup_expr='iexact')
@property
def qs(self):
# This endpoint supports query via Haystack. If that form of filtering is active,
# do not attempt to treat the queryset as a normal Django queryset.
if not isinstance(self.queryset, QuerySet):
return self.queryset
return super().qs
class Meta:
model = CourseRun
fields = (
'keys',
'hidden',
'license',
)
class TitleFilter(filters.FilterSet):
category = CharFilterInFilter(
field_name='category__slug',
lookup_expr='in',
)
genre = CharFilterInFilter(
field_name='genre__slug',
lookup_expr='in',
)
name = filters.CharFilter(
field_name='name',
lookup_expr='contains',
)
class Meta:
model = Title
fields = (
'genre',
'category',
'year',
'name',
)
class _BaseFilterSet(GenericFilterSet, filters.FilterSet):
LOCATION_FIELDS = [
(o[localtion_field_name], o[localtion_field_name])
for o in model.objects.values(localtion_field_name).distinct()
]
FIELDS = [(f.name, f.name) for f in model._meta.fields]
time_start = filters.DateTimeFilter(
name=time_field_name,
lookup_expr='gte',
label='time_start',
help_text=u"資料開始時間，ISO格式， 針對 %s 欄位，預設值取 MAX(%s)。" %
(time_field_name, time_field_name))
time_end = filters.DateTimeFilter(
name=time_field_name,
lookup_expr='lte',
label='time_end',
help_text=u"資料結束時間，ISO格式，針對 %s 欄位，預設值取 MAX(%s)。" %
(time_field_name, time_field_name))
map_ids = filters.MultipleChoiceFilter(
choices=LOCATION_FIELDS,
name=localtion_field_name,
label='map_ids',
help_text=u"mapping 識別，針對 %s 欄位，預設取全部。" % localtion_field_name)
fields = filters.MultipleChoiceFilter(choices=FIELDS,
label='fields',
required=False,
help_text=u"選取的欄位: %s" %
','.join(f[0] for f in FIELDS))
ordering = filters.OrderingFilter(
fields=[time_field_name, localtion_field_name],
label='ordering',
help_text=u"選擇排序欄位和方法：%s" % ' | '.join(
(time_field_name, localtion_field_name, '-' + time_field_name,
'-' + localtion_field_name)))
token = filters.CharFilter(label='token', help_text=u"有效的JWToken")
class Meta:
model = None
fields = filter_fields
