class MenuFilterSet(filters.FilterSet):
class Meta:
model = Menu
fields = ('modified', 'created')
modified = filters.IsoDateTimeFromToRangeFilter()
created = filters.IsoDateTimeFromToRangeFilter()
class InformationPackageFilter(filters.FilterSet):
archivist_organization = filters.ModelMultipleChoiceFilter(
label=_("Archivist Organization"),
queryset=Agent.objects.filter(role__iexact="archivist", type__iexact="organization"),
)
responsible = filters.ModelMultipleChoiceFilter(
field_name="responsible__username",
to_field_name="username",
queryset=users
)
state = MultipleCharFilter()
object_size = filters.RangeFilter()
start_date = filters.IsoDateTimeFromToRangeFilter()
end_date = filters.IsoDateTimeFromToRangeFilter()
create_date = filters.IsoDateTimeFromToRangeFilter()
entry_date = filters.IsoDateTimeFromToRangeFilter()
package_type = MultipleCharFilter()
package_type_name_exclude = filters.CharFilter(
label=_("Excluded Package Type"),
method='exclude_package_type_name'
)
def exclude_package_type_name(self, queryset, name, value):
for package_type_id, package_type_name in InformationPackage.PACKAGE_TYPE_CHOICES:
if package_type_name.lower() == value.lower():
return queryset.exclude(package_type=package_type_id)
return queryset.none()
class Meta:
model = InformationPackage
fields = ['archivist_organization', 'state', 'responsible',
'create_date', 'entry_date', 'object_size', 'start_date', 'end_date',
'archived', 'cached', 'package_type', 'package_type_name_exclude']
class BookmarkFilter(filters.FilterSet):
date_created = filters.IsoDateTimeFromToRangeFilter()
date_updated = filters.IsoDateTimeFromToRangeFilter()
tags = filters.ModelChoiceFilter(
queryset=Tag.objects.all(),
to_field_name='name',
)
class Meta:
model = Bookmark
fields = ['date_created', 'date_updated', 'tags']
class InformationPackageFilter(filters.FilterSet):
archivist_organization = filters.ModelMultipleChoiceFilter(
label=_("Archivist Organization"),
queryset=Agent.objects.filter(role__iexact="archivist", type__iexact="organization"),
)
responsible = filters.ModelMultipleChoiceFilter(
field_name="responsible__username",
to_field_name="username",
queryset=lambda request: users_in_organization(request.user),
)
state = MultipleCharFilter()
object_size = filters.RangeFilter()
start_date = filters.IsoDateTimeFromToRangeFilter()
end_date = filters.IsoDateTimeFromToRangeFilter()
create_date = filters.IsoDateTimeFromToRangeFilter()
entry_date = filters.IsoDateTimeFromToRangeFilter()
package_type = MultipleCharFilter()
package_type_name_exclude = filters.CharFilter(
label=_("Excluded Package Type"),
method='exclude_package_type_name'
)
migratable = filters.BooleanFilter(label='migratable', method='filter_migratable')
workarea = filters.ChoiceFilter(label=_("Workarea"), field_name='workareas__type', choices=Workarea.TYPE_CHOICES)
medium = filters.ModelChoiceFilter(
label='Storage Medium', queryset=StorageMedium.objects.all(),
field_name='storage__storage_medium',
distinct=True
)
policy = filters.ModelChoiceFilter(
label='Storage Policy', queryset=StoragePolicy.objects.all(),
field_name='submission_agreement__policy',
distinct=True
)
def exclude_package_type_name(self, queryset, name, value):
for package_type_id, package_type_name in InformationPackage.PACKAGE_TYPE_CHOICES:
if package_type_name.lower() == value.lower():
return queryset.exclude(package_type=package_type_id)
return queryset.none()
def filter_migratable(self, queryset, name, value):
return queryset.migratable()
class Meta:
model = InformationPackage
fields = ['archivist_organization', 'state', 'responsible', 'active', 'label',
'create_date', 'entry_date', 'object_size', 'start_date', 'end_date', 'policy',
'archived', 'cached', 'package_type', 'package_type_name_exclude', 'workarea']
class EventIPFilter(filters.FilterSet):
eventDateTime = filters.IsoDateTimeFromToRangeFilter()
class Meta:
model = EventIP
fields = ('eventType', 'eventType__category', 'eventOutcome',
'linkingAgentRole', 'eventDateTime')
class UmpCastNotificationFilter(filters.FilterSet):
date_time = filters.IsoDateTimeFromToRangeFilter(
field_name='notification_date_time')
class Meta:
model = UmpCastNotification
fields = ['date_time']
class ChangeFilter(filters.FilterSet):
timestamp = filters.IsoDateTimeFromToRangeFilter()
action = filters.MultipleChoiceFilter(choices=Change.ACTION_CHOICES)
user = filters.CharFilter(field_name="user__username")
class Meta:
model = Change
fields = ["action", "user", "timestamp"]
class HistoryFilter(filters.FilterSet):
typus = HistoryTypusFilter(choices=HistoryTypus.items())
type = HistoryTypusFilter(choices=HistoryTypus.items(), field_name='typus')
date = filters.IsoDateTimeFromToRangeFilter(field_name='date')
class Meta:
model = History
fields = ('group', 'place', 'users', 'typus', 'type', 'date', 'series', 'activity')
class PreferenceFilter(df_filters.FilterSet):
class Meta:
model = preferences_models.Preference
fields = []
user = df_filters.CharFilter(field_name='user__username')
expressed_at = df_filters.IsoDateTimeFromToRangeFilter(
field_name='expressed_at')
class ApplicationNotificationFilter(filters.FilterSet):
date_time = filters.IsoDateTimeFromToRangeFilter(
field_name='notification_date_time')
user = filters.CharFilter(field_name='application__user', lookup_expr='pk')
class Meta:
model = ApplicationNotification
fields = ['date_time']
class AdminCommentFilterSet(filters.FilterSet):
time_range = filters.IsoDateTimeFromToRangeFilter(field_name="created")
class Meta:
model = models.AdminComment
fields = [
'comment',
'time_range',
]
class ToDoFilter(filters.FilterSet):
#name = filters.CharFilter(lookup_expr='contains')
project = filters.NumberFilter()
create_date = filters.IsoDateTimeFromToRangeFilter(
field_name='change_date')
'''http://127.0.0.1:8000/api/todo/?create_date_after=2021-05-21T09:49:17&create_date_before=2021-05-21T19:49:17'''
class Meta:
model = ToDo
fields = ('project', 'create_date')
class FeedbackFilter(filters.FilterSet):
group = filters.NumberFilter(field_name='about__place__group')
place = filters.NumberFilter(field_name='about__place')
about = filters.NumberFilter(field_name='about')
given_by = filters.NumberFilter(field_name='given_by')
created_at = filters.IsoDateTimeFromToRangeFilter(field_name='created_at')
class Meta:
model = Feedback
fields = ['group', 'place', 'about', 'given_by', 'created_at']
class MessageFilter(filters.FilterSet):
author = filters.NumberFilter(field_name='author')
date = filters.IsoDateTimeFromToRangeFilter(field_name='date')
event = filters.CharFilter(field_name='event_class')
danger = filters.NumberFilter(field_name='danger_level')
address = filters.CharFilter(field_name='address')
class Meta:
model = MessageModel
exclude = ['text']
class CommentFilterSet(filters.FilterSet):
time_range = filters.IsoDateTimeFromToRangeFilter(field_name="created")
class Meta:
model = models.Comment
fields = [
'user',
'consultant',
'time_range',
]
class DecommissionedFilter(filters.FilterSet):
username = filters.CharFilter(field_name='username',
lookup_expr='icontains')
timestamp = filters.IsoDateTimeFromToRangeFilter(field_name='timestamp',
lookup_expr='range')
# timestamp = filters.DateTimeFromToRangeFilter(field_name='timestamp', lookup_expr='range')
class Meta:
model = Decommissioned
fields = ['username', 'timestamp']
class GameNotificationFilter(filters.FilterSet):
date_time = filters.IsoDateTimeFromToRangeFilter(
field_name='notification_date_time')
user = filters.CharFilter(method='game_filter_by_user')
class Meta:
model = GameNotification
fields = ['date_time']
def game_filter_by_user(self, queryset, name, value):
game_ids = Application.objects.filter(user__pk=value).values_list(
'post__game__pk', flat=True)
return queryset.filter(game__pk__in=game_ids)
class GameFilter(filters.FilterSet):
date_time = filters.IsoDateTimeFromToRangeFilter()
division__in = NumberInFilter(field_name='division__pk', lookup_expr='in')
user = filters.CharFilter(method='game_filter_by_user')
class Meta:
model = Game
fields = ['division', 'date_time']
def game_filter_by_user(self, queryset, name, value):
game_ids = Application.objects.filter(user__pk=value).values_list(
'post__game__pk', flat=True)
return queryset.filter(pk__in=game_ids)
class ApplicationFilter(filters.FilterSet):
date_time = filters.IsoDateTimeFromToRangeFilter(
field_name='post__game__date_time')
casted = filters.BooleanFilter(method='get_casted')
class Meta:
model = Application
fields = ['user', 'date_time']
def get_casted(self, queryset, name, value):
app_ids = []
for app in Application.objects.all().iterator():
if app.is_casted() == value:
app_ids.append(app.id)
return Application.objects.filter(id__in=app_ids)
class SessionFilter(filters.FilterSet):
"""Class to be able to filter Session on the API view."""
date = filters.IsoDateTimeFromToRangeFilter(field_name="date")
target_id = filters.NumberFilter(field_name="target__id")
target_name = filters.CharFilter(field_name="target__name")
class Meta(object):
"""The Meta class that defines the fields available."""
model = Session
fields = (
"date",
"target_id",
"target_name",
)
class ExerciseFilter(filters.FilterSet):
"""Class to be able to filter Exercise on the API view."""
due_date = filters.IsoDateTimeFromToRangeFilter(field_name="due_date")
class Meta(object):
"""The Meta class that defines the fields available."""
model = Exercise
fields = (
"due_date",
"difficulty",
"session",
"section",
"tags",
)
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 SpatialEntryFilter(filters.FilterSet):
q = GeometryFilter(
help_text=
'A Well-known text (WKT) representation of a geometry or a GeoJSON.',
label='WKT/GeoJSON',
method='filter_q',
)
predicate = filters.ChoiceFilter(
choices=(
('contains', 'contains'),
('crosses', 'crosses'),
('disjoint', 'disjoint'),
('equals', 'equals'),
('intersects', 'intersects'),
('overlaps', 'overlaps'),
('touches', 'touches'),
('within', 'within'),
),
help_text=
('A named spatial predicate based on the DE-9IM. This spatial predicate will be used '
'to filter data such that `predicate(a, b)` where `b` is the queried geometry.'
),
label='Spatial predicate',
method='filter_predicate',
)
relates = filters.CharFilter(
help_text=
('Specify exactly how the queried geometry should relate to the data using a DE-9IM '
'string code.'),
label='DE-9IM string code',
max_length=9,
method='filter_relates',
min_length=9,
validators=(RegexValidator(
regex=r'^[\*012TF]{9}$',
message='Enter a valid DE-9IM string code.'), ),
)
distance = filters.RangeFilter(
help_text=
'The minimum/maximum distance around the queried geometry in meters.',
label='Distance',
method='filter_distance',
)
acquired = filters.IsoDateTimeFromToRangeFilter(
field_name='acquisition_date',
help_text=
'The ISO 8601 formatted date and time when data was acquired.',
label='Acquired',
)
instrumentation = filters.CharFilter(
field_name='instrumentation',
help_text=
'The instrumentation used to acquire at least one of these data.',
label='Instrumentation',
lookup_expr='icontains',
)
time_of_day = filters.TimeRangeFilter(
help_text=
'The minimum/maximum times during the day the records were aqcuired.',
label='Time of Day',
method='filter_time_of_day',
)
@property
def _geometry(self):
return self.form.cleaned_data['q']
@property
def _has_geom(self):
return self._geometry is not None
def filter_q(self, queryset, name, value):
"""Sort the queryset by distance to queried geometry.
Annotates the queryset with `distance`.
This uses the efficient KNN operation:
https://postgis.net/docs/geometry_distance_knn.html
"""
if value:
queryset = queryset.annotate(distance=GeometryDistance(
'footprint', value)).order_by('distance')
return queryset
def filter_predicate(self, queryset, name, value):
"""Filter the spatial entries by the chosen predicate."""
if value and self._has_geom:
queryset = queryset.filter(
**{f'footprint__{value}': self._geometry})
return queryset
def filter_relates(self, queryset, name, value):
"""Filter the spatial entries by the chosen DE-9IM."""
if value and self._has_geom:
queryset = queryset.filter(footprint__relates=(self._geometry,
value))
return queryset
def filter_distance(self, queryset, name, value):
"""Filter the queryset by distance to the queried geometry.
We may wish to use the distance in degrees later on. This is
very taxing on the DBMS right now. The distance in degrees
can be provided by the initial geometry query.
"""
if value and self._has_geom:
geom = self._geometry
if value.start is not None:
queryset = queryset.filter(
footprint__distance_gte=(geom, D(m=value.start)))
if value.stop is not None:
queryset = queryset.filter(
footprint__distance_lte=(geom, D(m=value.stop)))
return queryset
def filter_time_of_day(self, queryset, name, value):
"""Filter the queryset by time of day acquired.
Use case: find all rasters acquired between 8am and 4pm
for all days in the acquired date range (i.e. only daytime imagery)
"""
if value is not None:
queryset = queryset.annotate(
time_of_day=F('acquisition_date__time'))
if value.start is not None:
queryset = queryset.filter(time_of_day__gte=value.start)
if value.stop is not None:
queryset = queryset.filter(time_of_day__lte=value.stop)
return queryset
class Meta:
model = SpatialEntry
fields = [
'q',
'predicate',
'relates',
'distance',
'acquired',
'instrumentation',
'time_of_day',
]
