class MoneyChangeLogFilter(django_filters.FilterSet):
start_time = django_filters.DateTimeFilter(field_name="created_time", lookup_expr="gte")
end_time = django_filters.DateTimeFilter(field_name="created_time", lookup_expr="lte")
class Meta:
model = models.MoneyChangeLog
fields = ("start_time", "end_time")
class ExportConfigFilter(django_filters.FilterSet):
"""Filter export configurations."""
name = django_filters.CharFilter(name="name", lookup_type="icontains")
config_type = django_filters.CharFilter(name="config_type",
lookup_type="icontains")
start = django_filters.DateTimeFilter(name="created_at", lookup_type="gte")
end = django_filters.DateTimeFilter(name="created_at", lookup_type="lte")
user = django_filters.CharFilter(name="user__username",
lookup_type="exact")
published = django_filters.BooleanFilter(name="published",
lookup_type="exact")
user_private = django_filters.MethodFilter(action='user_private_filter')
class Meta:
model = ExportConfig
fields = ('name', 'config_type', 'start', 'end', 'user', 'published',
'user_private')
order_by = ('-created_at', )
def user_private_filter(self, queryset, value):
"""
Filter export configurations by user and/or published status.
Return configurations for the specified user where configurations are either published or unpublished.
OR
Return configurations for all other users and where the configuration is published.
"""
return queryset.filter(
(Q(user__username=value) |
(~Q(user__username=value) & Q(published=True))))
class CreatedUpdatedFilterSet(django_filters.FilterSet):
created = django_filters.DateFilter()
created__gte = django_filters.DateFilter(field_name="created", lookup_expr="gte")
created__lte = django_filters.DateFilter(field_name="created", lookup_expr="lte")
last_updated = django_filters.DateTimeFilter()
last_updated__gte = django_filters.DateTimeFilter(field_name="last_updated", lookup_expr="gte")
last_updated__lte = django_filters.DateTimeFilter(field_name="last_updated", lookup_expr="lte")
class FunctionFilterSet(django_filters.FilterSet):
class Meta:
model = Function
fields = ('valid_at', 'version', 'classification_code',
'information_system')
valid_at = django_filters.DateFilter(method='filter_valid_at')
modified_at__lt = django_filters.DateTimeFilter(field_name='modified_at',
lookup_expr='lt')
modified_at__gt = django_filters.DateTimeFilter(field_name='modified_at',
lookup_expr='gt')
classification_code = django_filters.CharFilter(
field_name='classification__code')
information_system = django_filters.CharFilter(
field_name='phases__actions__records__attributes__InformationSystem',
lookup_expr='icontains')
def filter_valid_at(self, queryset, name, value):
# if neither date is set the function is considered not valid
queryset = queryset.exclude(
Q(valid_from__isnull=True) & Q(valid_to__isnull=True))
# null value means there is no bound in that direction
queryset = queryset.filter(
(Q(valid_from__isnull=True) | Q(valid_from__lte=value))
& (Q(valid_to__isnull=True) | Q(valid_to__gte=value)))
return queryset
class LogFilter(django_filters.FilterSet):
cron_name = django_filters.CharFilter(
field_name="cron_name",
lookup_expr="icontains",
label="任务名",
widget=forms.TextInput(attrs={'class': "form-control input-sm"}))
cron_server = django_filters.CharFilter(
field_name="cron_server",
lookup_expr="icontains",
label="IP",
widget=forms.TextInput(attrs={'class': "form-control input-sm"}))
create_time__lte = django_filters.DateTimeFilter(
field_name="create_time",
lookup_expr="lte",
label="Date小于",
widget=forms.DateTimeInput(attrs={
'class': "form-control input-sm",
'placeholder': 'YYYY-MM-DD hh:mm'
}))
create_time__gte = django_filters.DateTimeFilter(
field_name="create_time",
lookup_expr="gte",
label="Date大于",
widget=forms.DateTimeInput(attrs={
'class': "form-control input-sm",
'placeholder': 'YYYY-MM-DD hh:mm'
}))
class Meta:
model = TimedTask
fields = [
"cron_name", "cron_server", "create_time__gte", "create_time__lte"
]
class ProjectFilter(django_filters.FilterSet):
project_name = django_filters.CharFilter(
field_name="project_name",
lookup_expr="icontains",
label="项目名",
widget=forms.TextInput(attrs={'class': "form-control input-sm"}))
create_time__lte = django_filters.DateTimeFilter(
field_name="create_time",
lookup_expr="lte",
label="Date小于",
widget=forms.DateTimeInput(attrs={
'class': "form-control input-sm",
'placeholder': 'YYYY-MM-DD hh:mm'
}))
create_time__gte = django_filters.DateTimeFilter(
field_name="create_time",
lookup_expr="gte",
label="Date大于",
widget=forms.DateTimeInput(attrs={
'class': "form-control input-sm",
'placeholder': 'YYYY-MM-DD hh:mm'
}))
class Meta:
model = Project
fields = ["project_name", "create_time__gte", "create_time__lte"]
class ResourceFilter(FilterSet):
create_time_gte = django_filters.DateTimeFilter(name='create_time', lookup_expr='gte')
create_time_lte = django_filters.DateTimeFilter(name='create_time', lookup_expr='lte')
update_time_gte = django_filters.DateTimeFilter(name='update_time', lookup_expr='gte')
update_time_lte = django_filters.DateTimeFilter(name='update_time', lookup_expr='lte')
creator = django_filters.CharFilter(name='creator')
updater = django_filters.CharFilter(name='updater')
class EventFilter(filters.FilterSet):
start_time_gte = django_filters.DateTimeFilter(name="start_time", lookup_expr='gte')
start_time_lt = django_filters.DateTimeFilter(name="start_time", lookup_expr='lt')
class Meta:
model = Event
fields = ['employee', 'contact_ct', 'contact_id', 'company', 'start_time_gte', 'start_time_lt']
class AnalysisFilterSet(django_filters.FilterSet):
created_at__lt = django_filters.DateTimeFilter(
field_name='created_at',
lookup_expr='lt',
input_formats=['%Y-%m-%d%z'],
)
created_at__gt = django_filters.DateTimeFilter(
field_name='created_at',
lookup_expr='gt',
input_formats=['%Y-%m-%d%z'],
)
created_at__lte = django_filters.DateTimeFilter(
field_name='created_at',
lookup_expr='lte',
input_formats=['%Y-%m-%d%z'],
)
created_at__gte = django_filters.DateTimeFilter(
field_name='created_at',
lookup_expr='gte',
input_formats=['%Y-%m-%d%z'],
)
created_at = django_filters.DateTimeFilter(
field_name='created_at',
input_formats=['%Y-%m-%d%z'],
)
class Meta:
model = Analysis
fields = ()
class Filter(django_filters.FilterSet):
created_on__lt = django_filters.DateTimeFilter(
field_name='created_on',
lookup_expr='lt',
widget=forms.DateTimeInput)
created_on__gt = django_filters.DateTimeFilter(
field_name='created_on',
lookup_expr='gt',
widget=forms.DateTimeInput)
class Meta:
model = Licence
fields = (
'licence_type',
'is_active',
'created_by__username',
'created_by__first_name',
'created_by__last_name',
'licence_type__years_valid_for',
'licence_type__can_view',
'licence_type__can_download',
'licence_type__can_view_annotations',
'licence_type__can_annotate',
'licence_type__can_vote_annotations',
)
class RoomFilterBackend(FilterSet):
datetime_from = django_filters.DateTimeFilter(name='datetime_from')
datetime_to = django_filters.DateTimeFilter(name='datetime_to')
class Meta:
fields = ['datetime_from', 'datetime_to']
model = Room
def get_schema_fields(self, view):
return [
coreapi.Field(
name='datetime_from',
location='query',
required=False,
type='string',
description=
'Выбирает время начала выборки. Строка в формате ISO',
example='2021-01-20 00:00:00',
),
coreapi.Field(
name='datetime_to',
location='query',
required=False,
type='string',
description=
'Выбирает время начала выборки. Строка в формате ISO',
example='2021-01-20 00:00:00',
),
]
class OrderNumberFilter(django_filters.FilterSet):
keyword = django_filters.CharFilter(method='filter_keyword')
lottery_alias = django_filters.CharFilter(lookup_expr='iexact')
order_status = django_filters.NumberFilter()
is_followed_order = django_filters.NumberFilter()
start_time = django_filters.DateTimeFilter(name='order_time',
lookup_expr='gte')
stop_time = django_filters.DateTimeFilter(name='order_time',
lookup_expr='lte')
class Meta:
model = models.OrderNumber
fields = ('followed_order_id', 'lottery_alias', 'order_status',
'is_followed_order', 'start_time', 'stop_time')
def filter_keyword(self, queryset, name, value):
if value:
queryset = queryset.extra(
tables=['cdd_user'],
where=[
"cdd_user.id = cdd_lottery_order.user_id",
"(phone_number = '{value}'"
"OR cdd_user.id::TEXT = '{value}'"
"OR order_id = '{value}'"
"OR followed_order_id = '{value}')".format(value=value)
])
return queryset
class FeedbackFilter(django_filters.FilterSet):
issue = core_filters.URLFilter(view_name='support-issue-detail',
field_name='issue__uuid')
issue_uuid = django_filters.UUIDFilter(field_name='issue__uuid')
user = core_filters.URLFilter(view_name='user-detail',
field_name='issue__caller__uuid')
user_uuid = django_filters.UUIDFilter(field_name='issue__caller__uuid')
created_before = django_filters.DateTimeFilter(field_name="created",
lookup_expr="lte")
created_after = django_filters.DateTimeFilter(field_name="created",
lookup_expr="gte")
evaluation = core_filters.MappedMultipleChoiceFilter(
choices=[
(representation, representation)
for db_value, representation in models.Feedback.Evaluation.CHOICES
],
choice_mappings={
representation: db_value
for db_value, representation in models.Feedback.Evaluation.CHOICES
},
)
issue_key = django_filters.CharFilter(field_name='issue__key')
user_full_name = django_filters.CharFilter(method='filter_by_full_name',
label='User full name contains')
def filter_by_full_name(self, queryset, name, value):
return core_filters.filter_by_full_name(queryset, value,
'issue__caller')
class ChapterFilter(django_filters.FilterSet):
"""
FILTERS FOR editor.Chapter MODEL
"""
version = django_filters.NumberFilter(name='version', lookup_expr='exact')
book = django_filters.NumberFilter(name='book', lookup_expr='exact')
url_title = django_filters.CharFilter(name='url_title',
lookup_expr='icontains')
title = django_filters.CharFilter(name='title', lookup_expr='icontains')
status = django_filters.NumberFilter(name='status', lookup_expr='exact')
to_created = django_filters.DateTimeFilter(name='created',
lookup_expr='lte')
from_created = django_filters.DateTimeFilter(name='created',
lookup_expr='gte')
to_modified = django_filters.DateTimeFilter(name='modified',
lookup_expr='lte')
from_modified = django_filters.DateTimeFilter(name='modified',
lookup_expr='gte')
max_revision = django_filters.NumberFilter(name='revision',
lookup_expr='lte')
min_revision = django_filters.NumberFilter(name='revision',
lookup_expr='gte')
content = django_filters.CharFilter(name='content',
lookup_expr='icontains')
content_json = django_filters.CharFilter(name='content_json',
lookup_expr='icontains')
class Meta:
model = Chapter
fields = ('version', 'book', 'url_title', 'title', 'status',
'to_created', 'from_created', 'to_modified', 'from_modified',
'max_revision', 'min_revision', 'content', 'content_json')
class OrderFilter(django_filters.FilterSet):
id = django_filters.CharFilter(lookup_expr='contains')
user = django_filters.CharFilter(method='user_', )
status = django_filters.ChoiceFilter(choices=ORDER_STATUS_CHOICES)
start_date = django_filters.DateTimeFilter(
'created_at',
lookup_expr="gte",
widget=DateTimePickerInput(options={
"locale": "th",
}))
end_date = django_filters.DateTimeFilter(
'created_at',
lookup_expr="lte",
widget=DateTimePickerInput(options={
"locale": "th",
}))
class Meta:
model = Order
fields = []
def __init__(self, *args, **kwargs):
super(OrderFilter, self).__init__(*args, **kwargs)
self.filters['id'].label = 'รหัสรายการ'
self.filters['user'].label = 'ผู้ขอเบิก'
self.filters['status'].label = 'สถานะรายการ'
self.filters['start_date'].label = 'สร้างรายการตั้งแต่วันที่'
self.filters['end_date'].label = 'สร้างรายการถึงวันที่'
def user_(self, queryset, name, value):
return queryset.filter(
Q(user__username__icontains=value)
| Q(user__email__icontains=value)
| Q(user__first_name__icontains=value)
| Q(user__last_name__icontains=value)).distinct()
class CompetitionFilter(django_filters.FilterSet):
from_achievement_date = django_filters.DateTimeFilter(
field_name='distance_achievement_date', lookup_expr='gte')
to_achievement_date = django_filters.DateTimeFilter(
field_name='distance_achievement_date', lookup_expr='lte')
min_distance_in_feet = django_filters.NumberFilter(
field_name='distance_in_feet', lookup_expr='gte')
max_distance_in_feet = django_filters.NumberFilter(
field_name='distance_in_feet', lookup_expr='lte')
drone_name = django_filters.AllValuesFilter(field_name='drone__name')
pilot_name = django_filters.AllValuesFilter(field_name='pilot__name')
class Meta:
model = Competition
fields = (
'distance_in_feet',
'from_achievement_date',
'to_achievement_date',
'min_distance_in_feet',
'max_distance_in_feet',
'drone_name',
'pilot_name',
)
class AssetsFilter(django_filters.FilterSet):
ip = django_filters.CharFilter(
field_name="ip",
lookup_expr="icontains",
label="IP匹配",
widget=forms.TextInput(attrs={'class': "form-control input-sm"}))
create_time__lte = django_filters.DateTimeFilter(
field_name="create_time",
lookup_expr="lte",
label="Date小于",
widget=forms.DateTimeInput(
attrs={
'class': "form-control input-sm",
"id": "lt-date",
'placeholder': 'YYYY-MM-DD hh:mm'
}))
create_time__gte = django_filters.DateTimeFilter(
field_name="create_time",
lookup_expr="gte",
label="Date大于",
widget=forms.DateTimeInput(
attrs={
'class': "form-control input-sm",
"id": "gt-date",
'placeholder': 'YYYY-MM-DD hh:mm'
}))
class Meta:
model = Assets
fields = ["ip", "create_time__gte", "create_time__lte"]
class RecordFilter(django_filters.rest_framework.FilterSet):
project = django_filters.CharFilter(field_name='project__name',
lookup_expr='icontains')
version = django_filters.CharFilter(field_name='version',
lookup_expr='icontains')
notes = django_filters.CharFilter(field_name='notes',
lookup_expr='icontains')
status = django_filters.MultipleChoiceFilter(choices=RECORD_STATUS)
released_hosts = django_filters.CharFilter(field_name='released_hosts',
lookup_expr='icontains')
publisher = django_filters.ModelChoiceFilter(
queryset=UsersProfile.objects.all())
submitter = django_filters.ModelChoiceFilter(
queryset=UsersProfile.objects.all())
submit_time = django_filters.DateTimeFilter(field_name='submit_time',
lookup_expr='date')
record_time = django_filters.DateTimeFilter(field_name='record_time',
lookup_expr='date')
class Meta:
model = Record
fields = [
'project', 'version', 'notes', 'status', 'released_hosts',
'publisher', 'submitter', 'submit_time'
]
class PassageFilter(django_filters.FilterSet):
person = django_filters.CharFilter(field_name='person__name',
label=_('Person'),
lookup_expr='icontains')
company = django_filters.CharFilter(field_name='person__company',
label=_('Company'),
lookup_expr='icontains')
area = django_filters.CharFilter(field_name='person__area',
label=_('Area'),
lookup_expr='icontains')
department = django_filters.CharFilter(field_name='person__department',
label=_('Department'),
lookup_expr='icontains')
start_time_gt = django_filters.DateTimeFilter(
field_name='start_time',
label=_('Start time (date greater than)'),
lookup_expr='date__gte',
input_formats=["%d/%m/%Y", "%d-%m-%Y"])
start_time_lt = django_filters.DateTimeFilter(
field_name='start_time',
label=_('Start time (date lower than)'),
lookup_expr='date__lte',
input_formats=["%d/%m/%Y", "%d-%m-%Y"])
class Meta:
model = Passage
fields = (
'person',
'app',
)
class JobResultFilterSet(BaseFilterSet):
q = django_filters.CharFilter(method="search", label="Search")
obj_type = ContentTypeFilter()
created = django_filters.DateTimeFilter()
completed = django_filters.DateTimeFilter()
user_id = django_filters.ModelMultipleChoiceFilter(
queryset=User.objects.all(), label="User (ID)"
)
user = django_filters.ModelMultipleChoiceFilter(
field_name="user__username",
queryset=User.objects.all(),
to_field_name="username",
label="User name",
)
status = django_filters.MultipleChoiceFilter(
choices=JobResultStatus.choices, null_value=None
)
class Meta:
model = JobResult
fields = ["id", "created", "completed", "status", "user", "obj_type", "name"]
def search(self, queryset, name, value):
if not value.strip():
return queryset
return queryset.filter(
Q(name__icontains=value) | Q(user__username__icontains=value)
)
class JobResultFilterSet(BaseFilterSet, CustomFieldModelFilterSet):
q = SearchFilter(filter_predicates={
"job_model__name": "icontains",
"name": "icontains",
"user__username": "******",
}, )
job_model = django_filters.ModelMultipleChoiceFilter(
field_name="job_model__slug",
queryset=Job.objects.all(),
to_field_name="slug",
label="Job (slug)",
)
job_model_id = django_filters.ModelMultipleChoiceFilter(
queryset=Job.objects.all(),
label="Job (ID)",
)
obj_type = ContentTypeFilter()
created = django_filters.DateTimeFilter()
completed = django_filters.DateTimeFilter()
status = django_filters.MultipleChoiceFilter(
choices=JobResultStatusChoices, null_value=None)
class Meta:
model = JobResult
fields = [
"id", "created", "completed", "status", "user", "obj_type", "name"
]
class JobFilter(django_filters.FilterSet):
name = django_filters.CharFilter(name="name", lookup_type="icontains")
description = django_filters.CharFilter(name="description", lookup_type="icontains")
event = django_filters.CharFilter(name="event", lookup_type="icontains")
start = django_filters.DateTimeFilter(name="created_at", lookup_type="gte")
end = django_filters.DateTimeFilter(name="created_at", lookup_type="lte")
region = django_filters.CharFilter(name="region__name")
user = django_filters.CharFilter(name="user__username", lookup_type="exact")
feature = django_filters.CharFilter(name="tags__name", lookup_type="icontains")
published = django_filters.BooleanFilter(name="published", lookup_type="exact")
user_private = django_filters.MethodFilter(action='user_private_filter')
class Meta:
model = Job
fields = ('name', 'description', 'event', 'start', 'end', 'region',
'user', 'user_private', 'feature', 'published')
order_by = ('-created_at',)
def user_private_filter(self, queryset, value):
return queryset.filter(
# default filter for listing export jobs
# show current user published / unpublished
# or all other users published only
(Q(user__username=value) | (~Q(user__username=value) & Q(published=True)))
)
class ForecastStatsFilter(filters.FilterSet):
purchase_time_start = django_filters.DateTimeFilter(name="purchase_time", lookup_type='gte')
purchase_time_end = django_filters.DateTimeFilter(name="purchase_time", lookup_type='lte')
class Meta:
model = ForecastStats
fields = ['purchase_time_start', 'purchase_time_end']
class TempAmountFilter(django_filters.FilterSet):
created_time_start = django_filters.DateTimeFilter(name='created_time', lookup_expr='gte')
created_time_end = django_filters.DateTimeFilter(name='created_time', lookup_expr='lte')
class Meta:
model = TempAmount
fields = ['plate_number', 'created_time_start', 'created_time_end', 'creator']
class JobFilter(django_filters.FilterSet):
"""Filter export results according to a range of criteria."""
name = django_filters.CharFilter(name="name", lookup_type="icontains")
description = django_filters.CharFilter(name="description",
lookup_type="icontains")
event = django_filters.CharFilter(name="event", lookup_type="icontains")
start = django_filters.DateTimeFilter(name="created_at", lookup_type="gte")
end = django_filters.DateTimeFilter(name="created_at", lookup_type="lte")
user = django_filters.CharFilter(name="user__username",
lookup_type="exact")
feature = django_filters.CharFilter(name="tags__name",
lookup_type="icontains")
published = django_filters.BooleanFilter(name="published",
lookup_type="exact")
user_private = django_filters.MethodFilter(action='user_private_filter')
class Meta:
model = Job
fields = ('name', 'description', 'event', 'start', 'end', 'user',
'user_private', 'feature', 'published')
order_by = ('-created_at', )
def user_private_filter(self, queryset, value):
"""
Filter export results by user and/or published status.
Return exports for the specified user where exports are either published or unpublished.
OR
Return exports for all other users and where the export is published.
"""
return queryset.filter(
(Q(user__username=value) |
(~Q(user__username=value) & Q(published=True))))
class MeasurementFilter(django_filters.FilterSet):
strict = STRICTNESS.RAISE_VALIDATION_ERROR
meter_port = django_filters.NumberFilter(
name='meter_port')
min_value = django_filters.NumberFilter(
name='value', lookup_type='gte')
max_value = django_filters.NumberFilter(
name='value',
lookup_type='lte')
min_timestamp = django_filters.DateTimeFilter(
name='timestamp',
lookup_type='gte',
)
max_timestamp = django_filters.DateTimeFilter(
name='timestamp',
lookup_type='lte',
)
class Meta:
model = Measurement
order_by = ['timestamp', 'id']
fields = [
'meter_port',
'min_value',
'max_value',
'min_timestamp',
'max_timestamp',
]
class RoleLogFilter(django_filters.FilterSet):
role_user = django_filters.ModelChoiceFilter(
queryset=User.get_all(),
label="用户",
widget=forms.Select(
attrs={
'class': "form-control selectpicker",
"data-live-search": "true",
"data-size": "5",
"data-width": "100%"
}))
role_datetime__lte = django_filters.DateTimeFilter(
field_name="role_datetime",
lookup_expr="lte",
label="Date小于",
widget=forms.DateTimeInput(attrs={
'class': "form-control input-sm",
'placeholder': 'YYYY-MM-DD hh:mm'
}))
role_datetime__gte = django_filters.DateTimeFilter(
field_name="role_datetime",
lookup_expr="gte",
label="Date大于",
widget=forms.DateTimeInput(attrs={
'class': "form-control input-sm",
'placeholder': 'YYYY-MM-DD hh:mm'
}))
class Meta:
model = RunRoleLog
fields = ["role_user", "role_datetime__lte", "role_datetime__gte"]
class NotificationGqlFilterSet(django_filters.FilterSet):
timestamp = django_filters.DateTimeFilter(
field_name='timestamp',
input_formats=[django_filters.fields.IsoDateTimeField.ISO_8601],
)
timestamp_lte = django_filters.DateTimeFilter(
field_name='timestamp',
lookup_expr='lte',
input_formats=[django_filters.fields.IsoDateTimeField.ISO_8601],
)
timestamp_gte = django_filters.DateTimeFilter(
field_name='timestamp',
lookup_expr='gte',
input_formats=[django_filters.fields.IsoDateTimeField.ISO_8601],
)
is_pending = django_filters.BooleanFilter(label='Action Status',
method='is_pending_filter')
notification_type = SimpleInputFilter(NotificationTypeEnum)
status = SimpleInputFilter(NotificationStatusEnum)
class Meta:
model = Notification
fields = ()
def is_pending_filter(self, queryset, _, value):
if value is True:
return queryset.filter(data__status='pending', ).distinct()
elif value is False:
return queryset.filter(~Q(data__status='pending')
| Q(data__status__isnull=True)).distinct()
# If none
return queryset
class BaggageListFilter(django_filters.FilterSet):
search = django_filters.CharFilter(method='search_filter', label='Search')
room = django_filters.ChoiceFilter(label='Room',
choices=BAG_BUILDINGS,
empty_label='Any')
time_from = django_filters.DateTimeFilter(
method='search_time',
label='Time from',
widget=forms.DateTimeInput(attrs={'class': 'field-left'}),
initial=datetime.now() - timedelta(1))
time_to = django_filters.DateTimeFilter(
method='search_time',
label='Time to',
widget=forms.DateTimeInput(attrs={'class': 'field-right'}),
initial=datetime.now())
def search_filter(self, queryset, name, value):
queryfilter = queryset.annotate(
fullpos=Concat('room', 'row', 'col', output_field=CharField()))
return queryfilter.filter(
(Q(owner__email__icontains=value) | Q(owner__name__icontains=value)
| Q(status__icontains=value) | Q(type__icontains=value)
| Q(color__icontains=value) | Q(description__icontains=value)
| Q(fullpos__icontains=value)))
def search_time(self, queryset, name, value):
if name == 'time_from':
return queryset.filter(Q(time__gte=value))
return queryset.filter(Q(time__lte=value))
class Meta:
model = Bag
fields = ['search']
class CourseOrderFilter(CommonFilter):
pay_time_start = django_filters.DateTimeFilter(field_name='pay_time', lookup_expr='gte')
pay_time_end = django_filters.DateTimeFilter(field_name='pay_time', lookup_expr='lte')
class Meta:
model = models.CourseOrder
fields = ['pay_time_start', 'pay_time_end', 'course_name', 'pay_order__payment_type', 'status']
