class DataStampFilter(filters.FilterSet):
min_temp = filters.NumberFilter(field_name="temperature",
lookup_expr='gte')
max_temp = filters.NumberFilter(field_name="temperature",
lookup_expr='lte')
min_date = filters.DateFilter(field_name="date", lookup_expr='gte')
max_date = filters.DateFilter(field_name="date", lookup_expr='lte')
min_time = filters.TimeFilter(field_name="time", lookup_expr='gte')
max_time = filters.TimeFilter(field_name="time", lookup_expr='lte')
min_humidity = filters.NumberFilter(field_name="humidity",
lookup_expr='gte')
max_humidity = filters.NumberFilter(field_name="humidity",
lookup_expr='lte')
min_wind_speed = filters.NumberFilter(field_name="wind_speed",
lookup_expr='gte')
max_wind_speed = filters.NumberFilter(field_name="wind_speed",
lookup_expr='lte')
min_rain_1h = filters.NumberFilter(field_name="rain_1h", lookup_expr='gte')
max_rain_1h = filters.NumberFilter(field_name="rain_1h", lookup_expr='lte')
class Meta:
model = DataStamp
fields = [
'station', 'min_temp', 'max_temp', 'min_date', 'max_date',
'station__external_id', 'max_time', 'min_time', 'max_humidity',
'min_humidity', 'max_wind_speed', 'min_wind_speed', 'min_rain_1h',
'max_rain_1h'
]
class MessageFilter(filters.FilterSet):
"""Defines the filter fields for ListMessageView."""
created_date = filters.DateFilter(field_name='created_date',
lookup_expr='exact')
created_date__gt = filters.DateFilter(field_name='created_date',
lookup_expr='gt')
created_date__lt = filters.DateFilter(field_name='created_date',
lookup_expr='lt')
created_date__range = filters.DateFilter(field_name='created_date',
lookup_expr='range')
created_time = filters.TimeFilter(field_name='created_time',
lookup_expr='exact')
created_time__gt = filters.TimeFilter(field_name='created_time',
lookup_expr='gt')
created_time__lt = filters.TimeFilter(field_name='created_time',
lookup_expr='lt')
created_time__range = filters.TimeFilter(field_name='created_time',
lookup_expr='range')
sender = filters.ModelChoiceFilter(queryset=get_user_model().objects.all())
subject = filters.CharFilter(field_name='subject', lookup_expr='icontains')
text = filters.CharFilter(field_name='text', lookup_expr='icontains')
class Meta:
model = Message
fields = ['created_date', 'created_time', 'sender', 'subject', 'text']
class HoraActividadFilter(filters.FilterSet):
hora_mayor_que = filters.TimeFilter(field_name="hora_inicio",
lookup_expr='gte')
hora_menor_que = filters.TimeFilter(field_name="hora_inicio",
lookup_expr='lte')
class Meta:
model = Actividad
fields = ['actividad', 'hora_mayor_que', 'hora_menor_que', 'lugar']
class HobbyEventFilter(filters.FilterSet):
category = HierarchyModelMultipleChoiceFilter(
field_name='hobby__categories', queryset=HobbyCategory.objects.all(),
label=_('HobbyCategory id'),
)
ordering = NearestOrderingFilter(
fields=(
# (field name, param name)
('distance_to_point', 'nearest'),
),
field_labels={
'distance_to_point': _('Nearest'),
},
label=_('Ordering. Choices: `nearest`')
)
near_latitude = dummy_filter(filters.NumberFilter(label=_('Near latitude. This field is required when `nearest` ordering is used.')))
near_longitude = dummy_filter(filters.NumberFilter(label=_('Near longitude. This field is required when `nearest` ordering is used.')))
hobby = filters.ModelChoiceFilter(field_name='hobby', queryset=Hobby.objects.all(), label=_('Hobby id'))
start_date_from = filters.DateFilter(field_name='start_date', lookup_expr='gte',
label=_(f'Return results starting from given date (inclusive).'
f' Use ISO 8601 date format, eg. "2020-01-30".'))
start_date_to = filters.DateFilter(field_name='start_date', lookup_expr='lte',
label=_(f'Return results with starting date up to given date (inclusive).'
f' Use ISO 8601 date format, eg. "2020-01-30".'))
start_time_from = filters.TimeFilter(field_name='start_time', lookup_expr='gte',
label=_(f'Return results with starting time from given time (inclusive)'
f' Eg. "19:00".'))
start_time_to = filters.TimeFilter(field_name='start_time', lookup_expr='lte',
label=_(f'Return results with starting time up to given time (inclusive)'
f' Eg. "21:00".'))
start_weekday = filters.MultipleChoiceFilter(choices=HobbyEvent.DAY_OF_WEEK_CHOICES,
label=_(f'Return results with starting date in given weekday.'
f' Enter a number from 1 to 7. Use ISO 8601 weekdays:'
f' 1=Monday, 7=Sunday.'))
exclude_past_events = filters.BooleanFilter(method='filter_past_events', label=_('Show upcoming only'))
price_type = filters.CharFilter(method='filter_price_type', label=_('Filter HobbyEvents by price type'))
class Meta:
model = HobbyEvent
fields = ['category', 'hobby', 'start_date_from', 'start_date_to',
'start_time_from', 'start_time_to', 'start_weekday']
def filter_past_events(self, queryset, name, value):
is_filtering_requested = value
date_is_before_today = Q(end_date__lt=datetime.date.today())
date_is_today_but_time_is_in_past = Q(end_date=datetime.date.today()) & Q(end_time__lt=datetime.datetime.now().time())
if is_filtering_requested:
return queryset.exclude(date_is_before_today | date_is_today_but_time_is_in_past)
else:
return queryset
def filter_price_type(self, queryset, name, value):
value_in_price_type_choices = any(value == price_type for price_type, label in Hobby.PRICE_TYPE_CHOICES)
if value_in_price_type_choices:
queryset = queryset.filter(hobby__price_type=value)
return queryset
class ScheduleFilter(filters.FilterSet): date_from = filters.DateFilter(field_name="date", lookup_expr="gte") date_to = filters.DateFilter(field_name="date", lookup_expr="lte") time_from = filters.TimeFilter(field_name="time", lookup_expr="gte") time_to = filters.TimeFilter(field_name="time", lookup_expr="lte") class Meta: model = Schedule fields = ['is_done']
class HoraFilter(filters.FilterSet):
hora_mayor_que = filters.TimeFilter(field_name="actividad__hora_inicio",
lookup_expr='gte')
hora_menor_que = filters.TimeFilter(field_name="actividad__hora_inicio",
lookup_expr='lte')
class Meta:
model = Lugar
fields = [
'nombre',
'hora_mayor_que',
'hora_menor_que',
]
class RideFilter(filters.FilterSet):
time__gte = filters.TimeFilter(
field_name='time',
lookup_expr='gte',
)
class Meta:
model = Ride
fields = (
'destination',
'departure',
'date',
'time__gte',
)
class EventFilter(filters.FilterSet):
"""Defines the filter fields for ListEventView."""
description = filters.CharFilter(field_name='description',
lookup_expr='icontains')
end_date = filters.DateFilter(field_name='end_date', lookup_expr='exact')
end_date__gt = filters.DateFilter(field_name='end_date', lookup_expr='gt')
end_date__lt = filters.DateFilter(field_name='end_date', lookup_expr='lt')
end_date__range = filters.DateFilter(field_name='end_date',
lookup_expr='range')
end_time = filters.TimeFilter(field_name='end_time', lookup_expr='exact')
end_time__gt = filters.TimeFilter(field_name='end_time', lookup_expr='gt')
end_time__lt = filters.TimeFilter(field_name='end_time', lookup_expr='lt')
end_time__range = filters.TimeFilter(field_name='end_time',
lookup_expr='range')
lineup = filters.ModelChoiceFilter(queryset=Tally.objects.all())
name = filters.CharFilter(field_name='name', lookup_expr='icontains')
promoter = filters.ModelChoiceFilter(queryset=Promoter.objects.all(),
to_field_name='slug')
start_date = filters.DateFilter(field_name='start_date',
lookup_expr='exact')
start_date__gt = filters.DateFilter(field_name='start_date',
lookup_expr='gt')
start_date__lt = filters.DateFilter(field_name='start_date',
lookup_expr='lt')
start_date__range = filters.DateFilter(field_name='start_date',
lookup_expr='range')
start_time = filters.TimeFilter(field_name='start_time',
lookup_expr='exact')
start_time__gt = filters.TimeFilter(field_name='start_time',
lookup_expr='gt')
start_time__lt = filters.TimeFilter(field_name='start_time',
lookup_expr='lt')
start_time__range = filters.TimeFilter(field_name='start_time',
lookup_expr='range')
ticket_types = filters.ModelChoiceFilter(queryset=TicketType.objects.all())
venue = filters.ModelChoiceFilter(queryset=Venue.objects.all(),
to_field_name='slug')
class Meta:
model = Event
fields = [
'description', 'end_date', 'end_time', 'lineup', 'name',
'promoter', 'start_date', 'start_time', 'ticket_types', 'venue'
]
class TaskFilterSet(filters.FilterSet):
"""
Filterset for Task
"""
date = filters.DateFilter(name='date',
lookup_expr=DATETIME_LOOKUPS,
method='filter_timing')
start_time = filters.TimeFilter(name='start_time',
lookup_expr=TIME_LOOKUPS,
method='filter_timing')
end_time = filters.TimeFilter(name='end_time',
lookup_expr=TIME_LOOKUPS,
method='filter_timing')
# pylint: disable=too-few-public-methods
class Meta:
"""
Meta options for TaskFilterSet
"""
model = Task
fields = [
'locations', 'status', 'project', 'parent', 'date', 'start_time',
'end_time'
]
# pylint: disable=unused-argument
def filter_timing(self, queryset, name, value):
"""
Method to filter against task timing using TaskOccurrences
"""
# get the filter
try:
the_filter = self.get_filters()[name]
except KeyError:
# this name isn't a valid filter
return queryset
# first try the exact name
data = self.data.get(name)
if data is not None:
query_name = name
else:
# get the lookups
lookups = the_filter.lookup_expr
# loop through lookups to find which one is being used
if lookups:
for lookup in lookups:
query_name = self.get_filter_name(name, lookup)
data = self.data.get(query_name)
if data is not None:
break
if data is None:
# no data was found
return queryset
filter_args = {query_name: data}
# get task ids
# pylint: disable=no-member
task_ids = TaskOccurrence.objects.filter(**filter_args).values_list(
'task_id', flat=True).distinct()
return queryset.filter(id__in=task_ids)
class SeriesFilter(filters.FilterSet):
"""
Provides filtering functionality for the
:class:`~django_dicom.views.series.SeriesViewSet`.
Available filters are:
* *id*: Primary key
* *uid*: Series Instance UID
* *patient_id*: Related :class:`~django_dicom.models.patient.Patient`
instance's primary key
* *study_uid*: Related :class:`~django_dicom.models.study.Study`
instance's :attr:`~django_dicom.models.study.Study.uid` value
* *study_description*: Related
:class:`~django_dicom.models.study.Study` instance's
:attr:`~django_dicom.models.study.Study.description` value
(in-icontains)
* *modality*: Any of the values defined in
:class:`~dicom_parser.utils.code_strings.modality.Modality`
* *description*: Series description value (contains, icontains, or
exact)
* *number*: Series number value
* *protocol_name*: Protocol name value (contains)
* *scanning_sequence*: Any combination of the values defined in
:class:`~dicom_parser.utils.code_strings.scanning_sequence.ScanningSequence`
* *sequence_variant*: Any combination of the values defined in
:class:`~dicom_parser.utils.code_strings.sequence_variant.SequenceVariant`
* *echo_time*: :attr:`~django_dicom.models.series.Series.echo_time`
value
* *inversion_time*:
:attr:`~django_dicom.models.series.Series.inversion_time` value
* *repetition_time*:
:attr:`~django_dicom.models.series.Series.repetition_time` value
* *flip_angle*: Any of the existing
:attr:`~django_dicom.models.series.Series.flip_angle` in the database
* *created_after_date*: Create after date
* *date*: Exact :attr:`~django_dicom.models.series.Series.date` value
* *created_before_date*: Create before date
* *created_after_time*: Create after time
* *created_before_time*: Create before time
* *manufacturer*: Any of the existing
:attr:`~django_dicom.models.series.Series.manufacturer` in the
database
* *manufacturer_model_name*: Any of the existing
:attr:`~django_dicom.models.series.Series.manufacturer_model_name` in
the database
* *device_serial_number*: Any of the existing
:attr:`~django_dicom.models.series.Series.device_serial_number` in
the database
* *institution_name*: Any of the existing
:attr:`~django_dicom.models.series.Series.institution_name` in the
database
* *pulse_sequence_name*:
:attr:`~django_dicom.models.series.Series.pulse_sequence_name` value
(in-icontains)
* *sequence_name*:
:attr:`~django_dicom.models.series.Series.sequence_name` value
(in-icontains)
"""
study_uid = filters.CharFilter("study__uid",
lookup_expr="exact",
label="Study UID")
study_description = CharInFilter(
field_name="study__description",
lookup_expr="in",
label="Study description icontains",
method=filter_in_string,
)
modality = filters.ChoiceFilter("modality", choices=Modality.choices())
description = filters.LookupChoiceFilter(lookup_choices=[
("contains", "Contains (case-sensitive)"),
("icontains", "Contains (case-insensitive)"),
("exact", "Exact"),
])
protocol_name = filters.CharFilter("protocol_name", lookup_expr="contains")
scanning_sequence = filters.MultipleChoiceFilter(
"scanning_sequence",
choices=ScanningSequence.choices(),
conjoined=True,
method=filter_array,
)
sequence_variant = filters.MultipleChoiceFilter(
"sequence_variant",
choices=SequenceVariant.choices(),
conjoined=True,
method=filter_array,
)
flip_angle = filters.AllValuesFilter("flip_angle")
created_after_date = filters.DateFilter("date", lookup_expr="gte")
date = filters.DateFilter("date")
created_before_date = filters.DateFilter("date", lookup_expr="lte")
created_after_time = filters.TimeFilter("time", lookup_expr="gte")
created_before_time = filters.TimeFilter("time", lookup_expr="lte")
manufacturer = filters.AllValuesFilter("manufacturer")
manufacturer_model_name = filters.AllValuesFilter(
"manufacturer_model_name")
magnetic_field_strength = filters.AllValuesFilter(
"magnetic_field_strength")
device_serial_number = filters.AllValuesFilter("device_serial_number")
institution_name = filters.AllValuesFilter("institution_name")
pulse_sequence_name = CharInFilter(
field_name="pulse_sequence_name",
lookup_expr="icontains",
method=filter_in_string,
)
sequence_name = CharInFilter(
field_name="sequence_name",
lookup_expr="icontains",
method=filter_in_string,
)
pixel_spacing = filters.RangeFilter("pixel_spacing__0")
slice_thickness = filters.RangeFilter("slice_thickness")
repetition_time = filters.RangeFilter("repetition_time")
inversion_time = filters.RangeFilter("inversion_time")
echo_time = filters.RangeFilter("echo_time")
header_fields = filters.CharFilter("image", method=filter_header)
class Meta:
model = Series
fields = (
"id",
"uid",
"patient_id",
"study_uid",
"study_description",
"modality",
"description",
"protocol_name",
"number",
"created_after_date",
"created_before_date",
"created_after_time",
"created_before_time",
"echo_time",
"inversion_time",
"repetition_time",
"slice_thickness",
"pixel_spacing",
"scanning_sequence",
"sequence_variant",
"flip_angle",
"manufacturer",
"manufacturer_model_name",
"magnetic_field_strength",
"device_serial_number",
"institution_name",
"patient__id",
"pulse_sequence_name",
"sequence_name",
)
class SeriesFilter(filters.FilterSet):
"""
Provides useful filtering options for the :class:`~django_dicom.models.series.Series`
class.
"""
study_uid = filters.CharFilter("study__uid",
lookup_expr="exact",
label="Study UID")
study_description = filters.CharFilter("study__description",
lookup_expr="contains",
label="Study description contains")
modality = filters.ChoiceFilter("modality", choices=Modality.choices())
description = filters.LookupChoiceFilter(lookup_choices=[
("contains", "Contains (case-sensitive)"),
("icontains", "Contains (case-insensitive)"),
("exact", "Exact"),
])
protocol_name = filters.CharFilter("protocol_name", lookup_expr="contains")
scanning_sequence = filters.MultipleChoiceFilter(
"scanning_sequence",
choices=ScanningSequence.choices(),
conjoined=True,
method=filter_array,
)
sequence_variant = filters.MultipleChoiceFilter(
"sequence_variant",
choices=SequenceVariant.choices(),
conjoined=True,
method=filter_array,
)
flip_angle = filters.AllValuesFilter("flip_angle")
created_after_date = filters.DateFilter("date", lookup_expr="gte")
date = filters.DateFilter("date")
created_before_date = filters.DateFilter("date", lookup_expr="lte")
created_after_time = filters.TimeFilter("time", lookup_expr="gte")
created_before_time = filters.TimeFilter("time", lookup_expr="lte")
manufacturer = filters.AllValuesFilter("manufacturer")
manufacturer_model_name = filters.AllValuesFilter(
"manufacturer_model_name")
magnetic_field_strength = filters.AllValuesFilter(
"magnetic_field_strength")
device_serial_number = filters.AllValuesFilter("device_serial_number")
institution_name = filters.AllValuesFilter("institution_name")
class Meta:
model = Series
fields = (
"id",
"uid",
"patient_id",
"study_uid",
"study_description",
"modality",
"description",
"protocol_name",
"number",
"created_after_date",
"created_before_date",
"created_after_time",
"created_before_time",
"echo_time",
"inversion_time",
"repetition_time",
"scanning_sequence",
"sequence_variant",
"flip_angle",
"manufacturer",
"manufacturer_model_name",
"magnetic_field_strength",
"device_serial_number",
"institution_name",
"patient__id",
)
class CafeteriaFilterSet(filters.FilterSet):
open_from = filters.TimeFilter(method='get_open_from')
open_to = filters.TimeFilter(method='get_open_to')
open_now = filters.BooleanFilter(method='get_open_now')
prefix_name = filters.CharFilter(method='get_name_prefix')
owner_id = filters.NumberFilter(method='get_for_owner')
have_vegs = filters.BooleanFilter(method='get_for_vegetarian')
min_avg_review = filters.NumberFilter(method='get_with_min_review')
class Meta:
model = Cafeteria
fields = [
'open_from', 'open_to', 'open_now', 'prefix_name', 'owner_id',
'have_vegs', 'min_avg_review'
]
def get_open_now(self, queryset, field_name, value):
is_open = value
now = datetime.now().time()
if is_open is True:
return queryset.filter(open_from__lte=now).filter(open_to__gte=now)
elif is_open is False:
return (queryset.filter(open_from__gt=now)
| queryset.filter(open_to__lt=now)).distinct()
else:
return queryset
def get_name_prefix(self, queryset, field_name, value):
if value is None:
return queryset
prefix = value.strip()
return queryset.filter(name__istartswith=prefix)
def get_for_owner(self, queryset, field_name, value):
owner_id = value
if owner_id is None:
return queryset
return queryset.filter(owner_id=owner_id)
def get_for_vegetarian(self, queryset, field_name, value):
if value is None:
return queryset
for_vegs = FixedMenuOption.objects.filter(
vegetarian=value).values_list('cafeteria_id')
return queryset.filter(id__in=for_vegs)
def get_open_from(self, queryset, field_name, value):
if value is None:
return queryset
return queryset.filter(open_from__lte=value)
def get_open_to(self, queryset, field_name, value):
if value is None:
return queryset
return queryset.filter(open_to__gte=value)
def get_with_min_review(self, queryset, field_name, value):
if value is None:
return queryset
return queryset.annotate(
avg_review=Avg('fixed_menu_options__avg_review_stars')).filter(
avg_review__gte=value)
class KaznetTaskFilterSet(KaznetFilterSet):
"""
Filterset for Task
"""
date = filters.DateFilter(
name='date',
lookup_expr=DATE_LOOKUPS,
method='filter_timing'
)
start_time = filters.TimeFilter(
name='start_time',
lookup_expr=TIME_LOOKUPS,
method='filter_timing'
)
end_time = filters.TimeFilter(
name='end_time',
lookup_expr=TIME_LOOKUPS,
method='filter_timing'
)
modified = filters.DateTimeFilter(
name='modified',
lookup_expr=DATETIME_LOOKUPS,
method='filter_datetime'
)
required_expertise = filters.CharFilter(
name='required_expertise',
lookup_expr=EXPERTISE_LOOKUPS,
method='filter_expertise'
)
# pylint: disable=too-few-public-methods
class Meta:
"""
Meta options for TaskFilterSet
"""
model = Task
fields = [
'locations',
'modified',
'status',
'project',
'parent',
'client',
'date',
'start_time',
'end_time',
'required_expertise'
]
# pylint: disable=unused-argument
def filter_timing(self, queryset, name, value):
"""
Method to filter against task timing using TaskOccurrences
"""
filter_args = self._get_date_time_filter_args(name)
if filter_args is None:
return queryset
# get task ids
# pylint: disable=no-member
task_ids = TaskOccurrence.objects.filter(
**filter_args).values_list('task_id', flat=True).distinct()
return queryset.filter(id__in=task_ids)
def filter_expertise(self, queryset, name, value):
"""
Method to filter against task required_expertise
"""
filter_args = self._get_filter_args(name)
if filter_args is None:
return queryset
return queryset.filter(**filter_args)