class IssueFilter(django_filters.FilterSet):
author_email = django_filters.CharFilter(lookup_expr='icontains')
location = django_filters.CharFilter(lookup_expr='icontains')
landowner = django_filters.CharFilter(lookup_expr='icontains')
create_between = django_filters.DateFromToRangeFilter(
field_name='created_at',
widget=django_filters.widgets.RangeWidget(attrs={'type': 'date'}))
# TODO: useful Date ranges e.g. 30d, 1y, ... (daterangefilter)
category__name = django_filters.CharFilter(lookup_expr='icontains')
assigned = django_filters.ModelMultipleChoiceFilter(
queryset=Group.objects.all().order_by('name'),
widget=forms.SelectMultiple(),
)
status = django_filters.MultipleChoiceFilter(
choices=StatusTypes.choices(),
widget=forms.CheckboxSelectMultiple(),
)
class Meta:
model = Issue
# TODO: category, delegated
fields = [
'id', 'assigned', 'author_trust', 'location', 'priority',
'landowner', 'status', 'published'
]
def __init__(self, data, *args, **kwargs):
# set default fields if not other requested
super().__init__(data, *args, **kwargs)
self.form.initial['status'] = [
int(StatusTypes.WIP),
int(StatusTypes.REVIEW)
]
self.form.initial['assigned'] = self.request.user.groups.all()
class AgentFilter(django_filters.FilterSet):
username_q = django_filters.CharFilter(name='username',
lookup_type='contains')
real_name_q = django_filters.CharFilter(name='real_name',
lookup_type='contains')
phone_q = django_filters.CharFilter(name='phone', lookup_type='contains')
email_q = django_filters.CharFilter(name='email', lookup_type='contains')
wechat_q = django_filters.CharFilter(name='wechat', lookup_type='contains')
qq_q = django_filters.CharFilter(name='qq', lookup_type='contains')
qq_q = django_filters.CharFilter(name='qq', lookup_type='contains')
bank_name = django_filters.CharFilter(name='bank__bank_name',
lookup_type='exact')
bank_name_q = django_filters.CharFilter(name='bank__bank_name',
lookup_type='contains')
bank_account = django_filters.CharFilter(name='bank__account',
lookup_type='exact')
bank_account_q = django_filters.CharFilter(name='bank__account',
lookup_type='contains')
return_settings = django_filters.NumberFilter(
name='default_return_settings', lookup_type='exact')
register_at = django_filters.DateFromToRangeFilter()
commission_settings = django_filters.NumberFilter(
name='commission_settings', lookup_type='exact')
class Meta:
model = Agent
class VfbEntryListFilter(django_filters.FilterSet):
class Meta:
model = VfbEntry
fields = "__all__"
entry_signatur = django_filters.CharFilter(
lookup_expr='icontains',
help_text=VfbEntry._meta.get_field('entry_signatur').help_text,
label=VfbEntry._meta.get_field('entry_signatur').verbose_name)
vollregest = django_filters.CharFilter(
lookup_expr='icontains',
help_text=VfbEntry._meta.get_field('vollregest').help_text,
label=VfbEntry._meta.get_field('vollregest').verbose_name)
located_in__year = django_filters.DateFromToRangeFilter(
help_text=VerfachBuch._meta.get_field('year').help_text,
label=VerfachBuch._meta.get_field('year').verbose_name)
adm_action_type = django_filters.ModelMultipleChoiceFilter(
queryset=SkosConcept.objects.filter(
collection__name__icontains="adm_type"),
help_text=VfbEntry._meta.get_field('adm_action_type').help_text,
label=VfbEntry._meta.get_field('adm_action_type').verbose_name,
method=generous_concept_filter,
widget=autocomplete.Select2Multiple(
url="/vocabs-ac/concept-by-colleciton-ac/adm_type",
attrs={
'data-placeholder': 'Autocomplete ...',
'data-minimum-input-length': 0,
},
))
class LockedPagesReportFilterSet(WagtailFilterSet):
locked_at = django_filters.DateFromToRangeFilter(
widget=DateRangePickerWidget)
class Meta:
model = Page
fields = ['locked_by', 'locked_at', 'live']
class PostFilter(filters.FilterSet):
created = filters.DateFromToRangeFilter(
field_name='created',
widget=RangeWidget(attrs={
'class': "form-control",
'placeholder': 'mm/dd/yyyy',
'type': 'date'
}))
sort = filters.OrderingFilter(fields=(
("created", "created"),
("title", "title"),
("description", "description"),
),
field_labels={
'created': "Published Date",
'title': "Title",
'description': "Description",
},
choices=[
('created', "Oldest"),
('-created', "Latest"),
('title', "By Title (A-Z)"),
('-title', "By Title (Z-A)"),
('body', "By Description (A-Z)"),
('-body', "By Description (Z-A)"),
],
widget=forms.RadioSelect)
class Meta:
model = Post
fields = {
'source__name': ['icontains'],
'title': ['icontains'],
}
class JobFilter(django_filters.FilterSet):
business_title = django_filters.CharFilter(
field_name="business_title", lookup_expr="icontains", label="Job Title"
)
department = django_filters.ModelMultipleChoiceFilter(
queryset=Department.objects.all()
)
work_location = django_filters.CharFilter(
field_name="work_location", lookup_expr="icontains", label="Location"
)
posting_date = django_filters.DateFromToRangeFilter(
field_name="posting_date", label="Posted (Between)"
)
job_description = django_filters.CharFilter(
field_name="job_description", lookup_expr="icontains", label="Description"
)
class Meta:
model = Job
fields = [
"business_title",
"work_location",
"posting_date",
"department",
"job_description",
]
class QuestionFilterSet(django_filters.FilterSet):
"""Allows question to be filtered by user, date, or if it's unanswered."""
user = django_filters.ModelChoiceFilter(
queryset=User.objects.all(),
widget=autocomplete_light.ChoiceWidget('UserAutocomplete'))
date = django_filters.DateFromToRangeFilter(
label='Date Range',
lookup_expr='contains',
widget=RangeWidget(attrs={
'class': 'datepicker',
'placeholder': 'MM/DD/YYYY',
}),
)
unanswered = django_filters.BooleanFilter(method='unanswered_filter',
widget=forms.CheckboxInput())
tags = django_filters.ModelMultipleChoiceFilter(
name='tags__name',
queryset=Tag.objects.all(),
label='Tags',
widget=autocomplete_light.MultipleChoiceWidget('TagAutocomplete'),
)
def unanswered_filter(self, queryset, name, value):
"""Filter to show either only unanswered questions or all questions"""
# pylint: disable=unused-argument
if value:
return queryset.filter(answers__isnull=True)
else:
return queryset
class Meta:
model = Question
fields = ['user', 'date']
class InsurancePolicyFilter(django_filters.FilterSet):
customer = django_filters.CharFilter(field_name='customer',
method='filter_customer')
car = django_filters.CharFilter(field_name='car', method='filter_car')
end_date = django_filters.DateFromToRangeFilter(widget=DateRangeWidget(
attrs={'type': 'date'}))
def filter_customer(self, queryset, name, value):
return queryset.filter(customer__name__icontains=value)
def filter_car(self, queryset, name, value):
return queryset.filter(car__registration_number__icontains=value)
class Meta:
model = InsurancePolicy
fields = [
'number', 'registration_date', 'begin_date', 'end_date',
'customer', 'car', 'insurance_code'
]
filter_overrides = {
models.DateField: {
'filter_class': django_filters.DateFilter,
'extra': lambda f: {
'widget': DatePickerInput(format=DATE_INPUT_FORMAT),
},
},
}
class TaskFilterSet(django_filters.FilterSet):
"""Allows tasks to be filtered by whether they're resolved, and by who resolved them."""
resolved = django_filters.BooleanFilter(label='Show Resolved',
widget=forms.CheckboxInput())
resolved_by = django_filters.ModelMultipleChoiceFilter(
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('UserTaskAutocomplete'))
assigned = django_filters.ModelMultipleChoiceFilter(
queryset=User.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('UserTaskAutocomplete'))
deferred = django_filters.BooleanFilter(label='Deferred',
method='filter_deferred',
widget=forms.CheckboxInput())
date_created = django_filters.DateFromToRangeFilter(
label='Date Range',
lookup_expr='contains',
widget=RangeWidget(attrs={
'class': 'datepicker',
'placeholder': 'MM/DD/YYYY',
}),
)
class Meta:
model = Task
fields = ['resolved', 'resolved_by']
def filter_deferred(self, queryset, name, value):
"""Check if the foia has a tracking number."""
#pylint: disable=unused-argument
if value:
queryset = queryset.get_deferred()
else:
queryset = queryset.get_undeferred()
return queryset
class SiteHistoryReportFilterSet(WagtailFilterSet):
action = django_filters.ChoiceFilter(
choices=page_log_action_registry.get_choices)
hide_commenting_actions = django_filters.BooleanFilter(
label=_('Hide commenting actions'),
method='filter_hide_commenting_actions',
widget=forms.CheckboxInput,
)
timestamp = django_filters.DateFromToRangeFilter(
label=_('Date'), widget=DateRangePickerWidget)
label = django_filters.CharFilter(label=_('Title'),
lookup_expr='icontains')
user = django_filters.ModelChoiceFilter(
field_name='user',
queryset=lambda request: PageLogEntry.objects.all().get_users())
def filter_hide_commenting_actions(self, queryset, name, value):
if value:
queryset = queryset.exclude(action__startswith='wagtail.comments')
return queryset
class Meta:
model = PageLogEntry
fields = [
'label', 'action', 'user', 'timestamp', 'hide_commenting_actions'
]
class TimelineFilter(django_filters.rest_framework.FilterSet):
teacher = django_filters.NumberFilter(name='teacher__id')
start = django_filters.DateFromToRangeFilter()
class Meta:
model = TimelineEntry
fields = ['teacher', 'start']
class CalorieRecordFilterSet(django_filters.FilterSet):
calories = django_filters.RangeFilter()
date = django_filters.DateFromToRangeFilter(lookup_expr='date')
class Meta:
model = CalorieRecord
fields = ('user', 'calories')
class RetrievalRequestFilter(django_filters.FilterSet):
class Meta:
models = RetrievalRequest
fields = ('id', 'requester', 'date_created', 'date_complete',
'date_deleted', 'incomplete', 'on_gws', 'finished')
id = django_filters.NumberFilter(field_name='id')
requester = django_filters.CharFilter(field_name='requester__username',
lookup_expr='icontains')
date_time = django_filters.DateFromToRangeFilter(field_name='date_created')
incomplete = django_filters.NumberFilter(method='filter_incomplete')
on_gws = django_filters.NumberFilter(method='filter_on_gws')
finished = django_filters.NumberFilter(method='filter_finished')
def filter_incomplete(self, queryset, name, value):
if value:
return queryset.filter(date_complete__isnull=True)
return queryset
def filter_on_gws(self, queryset, name, value):
if value:
return queryset.filter(date_complete__isnull=False,
date_deleted__isnull=True)
return queryset
def filter_finished(self, queryset, name, value):
if value:
return queryset.filter(data_finished=True)
return queryset
class ArticleDateRangeFilterSet(django_filters.FilterSet):
"""Allows a list of news items to be filtered by a date range, an author, or many tags."""
projects = django_filters.ModelMultipleChoiceFilter(
name="projects",
queryset=Project.objects.get_public(),
widget=autocomplete_light.MultipleChoiceWidget('ProjectAutocomplete'),
)
authors = django_filters.ModelMultipleChoiceFilter(
queryset=(User.objects.annotate(
article_count=Count('authored_articles')).filter(
article_count__gt=0)),
widget=autocomplete_light.MultipleChoiceWidget(
'UserAuthorAutocomplete'))
pub_date = django_filters.DateFromToRangeFilter(
label='Date Range',
lookup_expr='contains',
widget=RangeWidget(attrs={
'class': 'datepicker',
'placeholder': 'MM/DD/YYYY',
}),
)
tags = django_filters.ModelMultipleChoiceFilter(
name='tags__name',
queryset=Tag.objects.all(),
widget=autocomplete_light.MultipleChoiceWidget('TagAutocomplete'),
)
class Meta:
model = Article
fields = ['projects', 'authors', 'pub_date', 'tags']
class Meta:
model = Employee
fields = '__all__'
#testing this
date_between = django_filters.DateFromToRangeFilter(
name='DateOfHire', label='Date of Hire (Between)')
order_by = ['pk']
class IndividualFilter(django_filters.FilterSet):
Name = django_filters.CharFilter(lookup_expr='contains', label="Name:")
ENAR = django_filters.CharFilter(lookup_expr='contains', label="ENAR:")
location = django_filters.CharFilter(lookup_expr='contains',
label="Location:")
date_range = django_filters.DateFromToRangeFilter(
label="Date:", widget=RangeWidget(attrs={'placeholder': 'YYYY/MM/DD'}))
o = django_filters.OrderingFilter(fields={
'ENAR': 'ENAR',
'Name': 'Name',
'Location': 'location',
'Sub Species': 'subspecies',
'Sex': 'sex',
'Birth Date': 'date',
},
field_labels={
'ENAR': 'ENAR',
'Name': 'Name',
'Location': 'Location',
'Sub Species': 'Sub Species',
'Sex': 'Sex',
'Birth Date': 'Birth Date',
})
class Meta:
model = Individual
fields = ['Name', 'ENAR', 'location', 'subspecies', 'sex']
class AgencyFOIARequestFilterSet(django_filters.FilterSet):
"""Filters for agency users"""
user = django_filters.ModelMultipleChoiceFilter(
field_name="composer__user",
label="User",
queryset=User.objects.all(),
widget=autocomplete.ModelSelect2Multiple(
url="user-autocomplete",
attrs={
"data-placeholder": "Search users",
"data-minimum-input-length": 2
},
),
)
tags = django_filters.ModelMultipleChoiceFilter(
field_name="tags__name",
queryset=Tag.objects.all(),
label="Tags",
widget=autocomplete.ModelSelect2Multiple(
url="tag-autocomplete", attrs={"data-placeholder": "Search tags"}),
)
date_range = django_filters.DateFromToRangeFilter(
field_name="communications__datetime",
label="Date Range",
lookup_expr="contains",
widget=RangeWidget(attrs={
"class": "datepicker",
"placeholder": "MM/DD/YYYY"
}),
)
class Meta:
model = FOIARequest
fields = ["user"]
class EventFilter(filters.FilterSet):
name = django_filters.CharFilter(name="name", lookup_expr=['search'])
category = django_filters.CharFilter(label='Category',
name="name",
method='filter_by_category')
city = django_filters.CharFilter(name='data__place__location__city',
label='City')
since = django_filters.DateFromToRangeFilter(
name="start_time",
label='Since',
)
order = CustomOrderingFilter(fields=(
("name", "name"),
("start_time", "time"),
),
field_labels={
'name': "Event name",
'start_time': "Event start time",
})
def filter_by_category(self, queryset, name, value):
query = reduce(operator.or_,
(Q(name__icontains=keyword)
for keyword in categories.get(value, [])))
return queryset.filter(query)
class Meta:
model = Event
fields = ['name', 'since', 'city', 'category']
class EventFilter(django_filters.FilterSet):
category = django_filters.ModelChoiceFilter(
queryset=EventCategory.objects.all(),
empty_label="Alle",
)
first_day = django_filters.DateFromToRangeFilter(
label="Datum eingrenzen",
field_name="first_day",
lookup_expr="month",
widget=django_filters.widgets.RangeWidget(
attrs={
"type":
"date",
"class":
"w-1/4 p-3 mt-2 text-gray-700 bg-gray-200 appearance-none focus:outline-none focus:bg-gray-300 focus:shadow-inner",
# "class": "w-full h-10 px-3 text-base placeholder-gray-600 border rounded-lg focus:shadow-outline",
}),
)
class Meta:
model = Event
fields = [
"category",
"first_day",
]
class JobFilter(django_filters.FilterSet):
"""
create filter for class job
"""
title = django_filters.CharFilter(field_name = 'title', lookup_expr = 'icontains')
location = django_filters.CharFilter(field_name = 'location', lookup_expr = 'icontains')
tag = TagsFilter(field_name = "tags",lookup_expr = 'icontains')
category = django_filters.CharFilter(field_name = 'category__cate_name')
s_date = django_filters.DateFromToRangeFilter(field_name = "start_date")
e_date = django_filters.DateFromToRangeFilter(field_name = "due_date")
class Meta:
model = Job
fields = ['title','location','category','tag','s_date','e_date']
class AppointmentFilter(django_filters.FilterSet):
owner = django_filters.CharFilter(
method="owner_filter",
help_text='Can either be a UUID or "me", to display only the events '
'owned by the current logged in user')
invitee = django_filters.CharFilter(
method="invitee_filter",
help_text='Can either be a UUID or "me", to display only the events '
'to which the current logged in user is invited')
workflowlevel2_uuid = django_filters.CharFilter(
method='workflowlevel2_uuid_filter', help_text='UUID for the project')
start_date = django_filters.DateFromToRangeFilter(widget=DateRangeWidget())
class Meta:
model = Appointment
fields = [
'contact_uuid', 'owner', 'invitee', 'workflowlevel2_uuid',
'start_date'
]
def owner_filter(self, queryset, field_name, value):
if value == CURRENT_USER_FILTER_KEYWORD:
my_uuid = self.request.session.get('jwt_core_user_uuid')
return queryset.filter(owner=my_uuid)
else:
try:
UUID(value)
except ValueError:
raise exceptions.ValidationError(
'owner field can only have value "{}" or a valid User UUID'
.format(CURRENT_USER_FILTER_KEYWORD))
else:
return queryset.filter(owner=value)
def invitee_filter(self, queryset, field_name, value):
if value == CURRENT_USER_FILTER_KEYWORD:
return queryset.filter(invitee_uuids__contains=[
self.request.session.get('jwt_core_user_uuid')
])
else:
try:
UUID(value)
except ValueError:
raise exceptions.ValidationError(
'invitee field can only have value "{}" or a valid '
'User UUID'.format(CURRENT_USER_FILTER_KEYWORD))
else:
return queryset.filter(invitee_uuids__contains=[value])
def workflowlevel2_uuid_filter(self, queryset, field_name, value):
try:
UUID(value)
except ValueError:
raise exceptions.ValidationError(
'workflowlevel2_uuids field can only have a valid UUID'.format(
CURRENT_USER_FILTER_KEYWORD))
else:
return queryset.filter(workflowlevel2_uuids__contains=[value])
class ExportFilter(django_filters.FilterSet):
created = django_filters.DateFromToRangeFilter()
total = SliderFilter(label=_('Total items'), step=10, has_range=True, segment='outputs.Export.total')
creator = django_filters.ModelChoiceFilter(queryset=get_user_model().objects.all(), widget=Select2Widget)
content_type = django_filters.ModelChoiceFilter(
queryset=ContentType.objects.filter(pk__in=Export.objects.order_by('content_type').values_list('content_type', flat=True).distinct()),
widget=Select2Widget
)
class Meta:
model = Export
fields = [
'id', 'created', 'format', 'context', 'content_type', 'status',
'total', 'creator'
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.form.fields['format'].empty_label = _("Doesn't matter")
self.form.fields['context'].empty_label = _("Doesn't matter")
self.helper = SingleSubmitFormHelper()
self.helper.form_tag = False
self.helper.disable_csrf = True
self.helper.layout = Layout(
Row(
Div(
Row(
Fieldset(
_('Generic'),
Row(
Div('id', css_class='col-md-4'),
Div(Field('created', css_class='date-picker form-control'), css_class='col-md-8 range-filter')
),
css_class='col-md-12'
),
),
Row(
Fieldset(
_('Related'),
Row(
Div('creator', css_class='col-md-5'),
Div(Field('total', css_class='form-control'), css_class='col-md-7 range-filter')
),
Row(
Div('content_type', css_class='col-md-5')
),
css_class='col-md-12'
),
),
css_class='col-md-9'
),
Fieldset(
_('Attributes'),
InlineRadios('format'),
InlineRadios('context'),
css_class='col-md-3'
),
)
)
class VerfachBuchListFilter(django_filters.FilterSet):
signatur = django_filters.CharFilter(
lookup_expr='icontains',
help_text=VerfachBuch._meta.get_field('signatur').help_text,
label=VerfachBuch._meta.get_field('signatur').verbose_name)
year = django_filters.DateFromToRangeFilter(
help_text=VerfachBuch._meta.get_field('year').help_text,
label=VerfachBuch._meta.get_field('year').verbose_name)
class PackageFilter(django_filters.FilterSet):
nama = django_filters.CharFilter(lookup_expr='icontains')
dibuat_pada = django_filters.DateFromToRangeFilter()
class Meta:
model = Package
fields = ['nama', 'kategori', 'dibuat_pada']
order_by = ['-id']
class SiteNodeFilter(FilterSet):
siteName = django_filters.CharFilter(
field_name='siteName', lookup_expr="icontains") # icontains 包含,忽略大小写
dateTimeRange = django_filters.DateFromToRangeFilter(field_name='dateTime')
class Meta:
model = SiteNode # 关联的模型
fields = ['siteName']
class MyFOIARequestFilterSet(JurisdictionFilterSet):
"""Allows filtering a request by status, agency, jurisdiction, or tags."""
status = django_filters.ChoiceFilter(choices=BLANK_STATUS)
agency = django_filters.ModelMultipleChoiceFilter(
queryset=Agency.objects.get_approved(),
widget=autocomplete.ModelSelect2Multiple(
url="agency-autocomplete",
attrs={"data-placeholder": "Search agencies"}),
)
tags = django_filters.ModelMultipleChoiceFilter(
field_name="tags__name",
queryset=Tag.objects.all(),
label="Tags",
widget=autocomplete.ModelSelect2Multiple(
url="tag-autocomplete", attrs={"data-placeholder": "Search tags"}),
)
has_embargo = django_filters.BooleanFilter(
field_name="embargo",
widget=forms.Select(choices=NULL_BOOLEAN_CHOICES))
has_crowdfund = django_filters.BooleanFilter(
field_name="crowdfund",
lookup_expr="isnull",
exclude=True,
widget=forms.Select(choices=NULL_BOOLEAN_CHOICES),
)
minimum_pages = django_filters.NumberFilter(
field_name="communications__files__pages",
lookup_expr="gte",
label="Min. Pages",
distinct=True,
widget=forms.NumberInput(),
)
date_range = django_filters.DateFromToRangeFilter(
field_name="communications__datetime",
label="Date Range",
lookup_expr="contains",
widget=RangeWidget(attrs={
"class": "datepicker",
"placeholder": "MM/DD/YYYY"
}),
)
file_types = django_filters.CharFilter(label="File Types",
method="filter_file_types")
def filter_file_types(self, queryset, name, value):
"""Filter requests with certain types of files"""
# pylint: disable=unused-argument
file_types = value.split(",")
query = Q()
for file_type in file_types:
query |= Q(
communications__files__ffile__endswith=file_type.strip())
return queryset.filter(query)
class Meta:
model = FOIARequest
fields = ["status", "agency", "jurisdiction"]
class WeeklyRecordFilter(django_filters.rest_framework.FilterSet):
# motor = django_filters.CharFilter(lookup_expr='icontains')
c_day = django_filters.DateFromToRangeFilter()
class Meta:
model = WeeklyRecord
fields = [
'c_day',
]
class NewsPublicFilters(django_filters.FilterSet):
published_date = django_filters.DateFromToRangeFilter()
class Meta:
model = News
fields = (
'author',
'published_date',
)
class RatingFilter(django_filters.FilterSet):
classtype = django_filters.CharFilter(lookup_expr='icontains')
rate = django_filters.NumberFilter()
date = django_filters.DateFromToRangeFilter(
field_name='date', label='Date (Between) in format YYYY-MM-DD')
class Meta:
model = Rating
fields = "__all__"
class BookFilter(django_filters.FilterSet):
published_date = django_filters.DateFromToRangeFilter(field_name='published_date')
class Meta:
model = Book
fields = {
'title': ['icontains'],
'language': ['exact'],
'authors__name': ['icontains'],
}
