class ObjectChangeFilterSet(BaseFilterSet):
q = django_filters.CharFilter(
method='search',
label='Search',
)
time = django_filters.DateTimeFromToRangeFilter()
changed_object_type = ContentTypeFilter()
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',
)
class Meta:
model = ObjectChange
fields = [
'id',
'user',
'user_name',
'request_id',
'action',
'changed_object_type_id',
'changed_object_id',
'object_repr',
]
def search(self, queryset, name, value):
if not value.strip():
return queryset
return queryset.filter(
Q(user_name__icontains=value) | Q(object_repr__icontains=value))
class RateFilter(django_filters.FilterSet):
ordering = django_filters.OrderingFilter(
label='Ordering',
choices=(
('created', 'Date (ascending)'),
('-created', 'Date (descending)'),
('sale', 'Currency sale (ascending)'),
('-sale', 'Currency sale (descending)'),
('buy', 'Currency buy (ascending)'),
('-buy', 'Currency buy (descending)'),
),
)
created = django_filters.DateTimeFromToRangeFilter(
label='Date range',
field_name='created',
lookup_expr='date',
widget=DateRangeWidget(attrs={
'class': 'form-control datetimepicker-input',
'type': 'date',
}))
class Meta:
model = Rate
fields = '__all__'
class CurrentFilter(django_filters.FilterSet):
#datetimeval = django_filters.DateTimeFromToRangeFilter(widget=SplitDateTimeWidget())
datetimeval = django_filters.DateTimeFromToRangeFilter(
widget=SplitDateTimeWidget(attrs={'type': 'date'}))
datetimeval.label = 'Διάστημα '
status_ok = django_filters.BooleanFilter(
widget=django_filters.widgets.BooleanWidget())
#country_id = django_filters.NumberFilter(method='country_id')
## aaa=Country.objects.filter(countryft=1)
## ccc=[]
## for x in aaa.values():
## print(x['id'],x['name'])
## ccc.append((int(x['id']),x['name'].strip()))
# country_id = django_filters.MultipleChoiceFilter(choices=ccc)
class Meta:
model = ModelClassName
exclude = ('id', )
fields = {
'datetimeval': [],
'metric_id': [
'exact',
],
'metric_id__metric_category': [
'exact',
],
'country_id': [
'exact',
],
## 'country_id': [],
'status_ok': [],
}
class CustomerFilter(django_filters.FilterSet):
entry_timestamp = django_filters.DateTimeFromToRangeFilter(
label='Customer Date Filter',
widget=CustomDateTimeRangeWidget()
)
class Meta:
model = Customer
fields = ['entry_timestamp']
@property
def qs(self):
parent_qs = super(CustomerFilter, self).qs
if not self.request:
raise ValueError('request object is required. Pass request as kwargs when initializing Filter.')
if self.request.user.has_perm('alter_all_customer_data'):
return parent_qs
if not hasattr(self.request.user, 'organization'):
raise Http404('User manages no organization!!!')
organization = self.request.user.organization
return parent_qs.filter(organization=organization.id)
class ObjectChangeFilterSet(BaseFilterSet):
q = django_filters.CharFilter(
method="search",
label="Search",
)
time = django_filters.DateTimeFromToRangeFilter()
changed_object_type = ContentTypeFilter()
user_id = django_filters.ModelMultipleChoiceFilter(
queryset=get_user_model().objects.all(),
label="User (ID)",
)
user = django_filters.ModelMultipleChoiceFilter(
field_name="user__username",
queryset=get_user_model().objects.all(),
to_field_name="username",
label="User name",
)
class Meta:
model = ObjectChange
fields = [
"id",
"user",
"user_name",
"request_id",
"action",
"changed_object_type_id",
"changed_object_id",
"object_repr",
]
def search(self, queryset, name, value):
if not value.strip():
return queryset
return queryset.filter(
Q(user_name__icontains=value) | Q(object_repr__icontains=value))
class ObjectChangeFilter(django_filters.FilterSet):
q = django_filters.CharFilter(
method='search',
label='Search',
)
time = django_filters.DateTimeFromToRangeFilter()
class Meta:
model = ObjectChange
fields = [
'user',
'user_name',
'request_id',
'action',
'changed_object_type',
'changed_object_id',
'object_repr',
]
def search(self, queryset, name, value):
if not value.strip():
return queryset
return queryset.filter(
Q(user_name__icontains=value) | Q(object_repr__icontains=value))
class SampleEventFilterSet(BaseAPIFilterSet):
sample_date = django_filters.DateTimeFromToRangeFilter(field_name="sample_date")
class Meta:
model = SampleEvent
fields = ['site', 'management', 'sample_date']
class PackFilter(django_filters.rest_framework.FilterSet):
time = django_filters.DateTimeFromToRangeFilter()
class Meta:
model = CurrentSignalPack
fields = ['time','motor', ]
class MainRequestFilter(HelpfulFilterSet):
number = django_filters.NumberFilter(
label='№',
lookup_expr='exact',
widget=NumberInput(attrs={'new_line': 'true'}))
input_datetime = django_filters.DateTimeFromToRangeFilter(
label='Дата вводда',
lookup_expr='range',
widget=MyRangeWidget(attrs={
'display': 'inline',
'class': 'datepicker-need'
}))
input_user = django_filters.ModelChoiceFilter(
label='Пользователь',
lookup_expr='exact',
queryset=Profile.objects.filter())
request_dateTime = django_filters.DateTimeFromToRangeFilter(
label='Дата подачи заявки',
lookup_expr='range',
widget=MyRangeWidget(attrs={
'display': 'inline',
'class': 'datepicker-need'
}))
request_user = django_filters.ModelChoiceFilter(
label='Подал',
lookup_expr='exact',
queryset=Profile.objects.filter(),
help_text='Можно ввести с клавиатуры')
request_outer_User = django_filters.CharFilter(label='')
receive_dateTime = django_filters.DateTimeFromToRangeFilter(
label='Дата принятия',
lookup_expr='rangdbe',
widget=MyRangeWidget(attrs={
'display': 'inline',
'class': 'datepicker-need'
}))
receive_user = django_filters.ModelChoiceFilter(
label='Принял', lookup_expr='exact', queryset=Profile.objects.filter())
close_dateTime = django_filters.DateTimeFromToRangeFilter(
label='Дата закрытия',
lookup_expr='range',
widget=MyRangeWidget(attrs={
'display': 'inline',
'class': 'datepicker-need'
}))
close_user = django_filters.ModelChoiceFilter(
label='Закрыл', lookup_expr='exact', queryset=Profile.objects.filter())
place = django_filters.ModelChoiceFilter(label='Место',
lookup_expr='exact',
queryset=Places.objects.all())
close_user__isnull = django_filters.BooleanFilter(name='close_user',
label='Только закрытые',
lookup_expr='isnull',
exclude=True)
departure__end_datetime__isnull = django_filters.BooleanFilter(
name='departure__end_datetime',
label='Только с незакрытыми выездами',
lookup_expr='isnull',
method='filter_departures_not_closed')
def filter_departures_not_closed(self, queryset, name, value):
# construct the full lookup expression.
lookup = '__'.join([name, 'isnull'])
l2 = '__'.join(['departure__id', 'isnull'])
ll = ','.join([lookup, l2])
print(value)
if value:
return queryset.filter(departure__id__isnull=False,
departure__end_datetime__isnull=True)
else:
return queryset
#return queryset.filter(**{lookup: False})
# alternatively, it may not be necessary to construct the lookup.
return queryset.filter(published_on__isnull=False)
class Meta:
model = MainRequest
fields = [
'number', 'input_datetime', 'input_user', 'request_dateTime',
'request_user'
]
filter_overrides = {
models.BooleanField: {
'filter_class': django_filters.BooleanFilter,
'extra': lambda f: {
'widget': CheckboxInput,
},
},
}
class GeneratedCerticatesFilter(BaseDataApiFilter):
"""
TODO: add me
"""
DOWNLOADABLE = 'downloadable'
ALL = 'all'
site = django_filters.CharFilter(field_name="user__usersignupsource__site",
lookup_expr='iexact')
username = django_filters.CharFilter(field_name="user__username",
lookup_expr='icontains')
created_date = django_filters.DateTimeFromToRangeFilter()
course_id = django_filters.CharFilter(method="filter_course_id")
status = django_filters.CharFilter(method="filter_status")
grade = django_filters.CharFilter()
mode = django_filters.CharFilter()
def filter_course_id(self, queryset, name, value):
"""
This custom filter was created to enable filtering by course_id.
See common.djangoapps.xmodule_django.models
When doing queries over opaque fields, we need to instance the
KEY_CLASS of the field with the query string first, and then pass
this instance to the queryset filter.
In this case, the KEY_CLASS for course_id field is CourseKey
"""
if value:
# CourseKey instance creation will fail if course does not exist
try:
# Instantiating CourseKey of the field with query string
instance = CourseKey.from_string(str(value))
# Passing instance to queryset filter
return queryset.filter(course_id=instance)
except Exception: # pylint: disable=broad-except
# If CourseKey instantiation fails, return an empty queryset
return queryset.none()
return queryset
def filter_status(self, queryset, name, value):
"""
This custom filter was created to return a queryset
where certificates have downloadable status or
another queryset with all available certificates.
"""
if value:
if value == self.DOWNLOADABLE:
return queryset.filter(status=value)
if value == self.ALL:
return queryset.exclude(status=self.DOWNLOADABLE)
return queryset
class Meta:
"""
TODO: add me
"""
model = get_generated_certificate()
fields = [
'id', 'course_id', 'grade', 'mode', 'username', 'status', 'site',
'created_date'
]
class TripFilter(django_filters.FilterSet):
route_name__price__gte = django_filters.NumberFilter(
field_name='route_name',
lookup_expr='price__gte',
label='Минимальная цена')
route_name__price__lte = django_filters.NumberFilter(
field_name='route_name',
lookup_expr='price__lte',
label='Максимальная цена')
country = django_filters.ModelChoiceFilter(
queryset=Country.objects.all(),
method='search_trips_by_countries',
label='Страна')
date_range = django_filters.DateTimeFromToRangeFilter(
widget=django_filters.widgets.RangeWidget(
attrs={'placeholder': 'yyyy-mm-dd hh:mm'}),
method='search_trips_by_range',
label="Сроки")
transport = django_filters.ModelChoiceFilter(
queryset=Transport.objects.all(),
method='exclude_transport',
label='Исключить транспорт')
hot_trips = django_filters.BooleanFilter(field_name='hot_trips',
method='show_hot_trips',
label='Горячие путевки')
order_f = django_filters.OrderingFilter(label='Сортировка',
fields=(('route_name__price',
'route_name__price'), ),
field_labels={
'route_name__price': 'Цена',
})
class Meta:
model = Trip
fields = [
'route_name__price__gte', 'route_name__price__lte', 'country',
'date_range', 'transport', 'hot_trips', 'order_f'
]
def search_trips_by_countries(self, queryset, name, value):
routes = queryset.values('route_name')
moves = Move.objects.filter(route__in=routes).filter(
city__country=value)
return queryset.filter(route_name__in=moves.values('route'))
def search_trips_by_range(self, queryset, name, value):
routes = queryset.values('route_name')
moves = Move.objects.filter(
route__in=routes).order_by('departure_time')
start_date = value.start
stop_date = value.stop
country = self.form.cleaned_data['country']
departure_time = None
arrival_time = None
new_move = moves
for move in moves:
departure_time = move.departure_time
if arrival_time and (not country or country and country == move.city.country) \
and arrival_time <= start_date and stop_date <= departure_time:
pass
else:
new_move = new_move.exclude(id=move.id)
arrival_time = move.arrival_time
return queryset.filter(route_name__in=new_move.values('route'))
def exclude_transport(self, queryset, name, value):
routes = queryset.values('route_name')
moves = Move.objects.filter(route__in=routes)
new_move = moves.filter(transport=value)
return queryset.exclude(route_name__in=new_move.values('route'))
def show_hot_trips(self, queryset, name, value):
now = datetime.datetime.now()
now += datetime.timedelta(days=5)
if value:
return queryset.filter(departure_time__lte=now)
else:
return queryset.exclude(departure_time__lte=now)
class SharerSearchFilter(django_filters.FilterSet):
arrival_between = django_filters.DateTimeFromToRangeFilter(field_name='arrival', label='Arrival(Between)')
class Meta:
model = Ride
fields = ['address']
class CommentFilter(django_filters.FilterSet):
created_at = django_filters.DateTimeFromToRangeFilter()
class Meta:
model = Comment
fields = ['movie', 'created_at']
