class MusicalExperienceFilter(filters.FilterSet):
experience = filters.ModelMultipleChoiceFilter(
queryset=MusicalSkill.objects.all(),
widget=Select2MultipleWidget(attrs={}),
label="Skilled In Any Of",
field_name="experience")
m_proficiency = filters.MultipleChoiceFilter(
field_name="proficiency",
choices=PROFICIENCY_M_CHOICES,
widget=Select2MultipleWidget(),
lookup_expr='icontains',
label="Proficiency Level")
m_age_learning_started = filters.RangeFilter(
field_name="age_learning_started",
label="Age Learning Started Range",
widget=RangeWidget(attrs={
'type': 'number',
'class': 'form-control mb-2'
}))
m_age_learning_ended = filters.RangeFilter(
field_name="age_learning_ended",
label="Age Learning Ended Range",
widget=RangeWidget(attrs={
'type': 'number',
'class': 'form-control mb-2'
}))
class Meta:
model = MusicalExperience
fields = [
'experience', 'proficiency', 'age_learning_started',
'age_learning_ended'
]
def test_widget_attributes(self):
w = RangeWidget(attrs={'type': 'date'})
self.assertEqual(len(w.widgets), 2)
self.assertHTMLEqual(w.render('date', ''), """
<input type="date" name="date_min" />
-
<input type="date" name="date_max" />""")
class RidingFilter(BaseSportFilter):
hills = django_filters.RangeFilter(
field_name='hill_avg',
widget=RangeWidget(
attrs={
'class': "form-control form-control-sm col",
'placeholder': "Speed in kph",
'style': 'margin-left: 10px; margin-right: 10px;'
}))
flats = django_filters.RangeFilter(
field_name='flat_avg',
widget=RangeWidget(
attrs={
'class': "form-control form-control-sm col",
'placeholder': "Speed in kph",
'style': 'margin-left: 10px; margin-right: 10px;'
}))
weekly_volume = django_filters.NumberFilter(
field_name='weekly_volume',
lookup_expr='gt',
widget=TextInput(
attrs={
'class': "form-control form-control col",
'placeholder': "Minimum Weekly Volume (in km)"
}))
class Meta:
model = RidingProfile
fields = []
def test_widget_attributes(self):
w = RangeWidget(attrs={'type': 'date'})
self.assertEqual(len(w.widgets), 2)
self.assertHTMLEqual(w.render('date', ''), """
<input type="date" name="date_0" />
-
<input type="date" name="date_1" />""")
class AdultFilter(filters.FilterSet):
given_name = filters.AllValuesMultipleFilter(
widget=Select2MultipleWidget(),
field_name='given_name',
lookup_expr="icontains",
label="Given Name")
surname = filters.AllValuesMultipleFilter(widget=Select2MultipleWidget(),
field_name='surname',
lookup_expr='icontains',
label="Surname")
preferred_name = filters.AllValuesMultipleFilter(
widget=Select2MultipleWidget(),
field_name='preferred_name',
lookup_expr='icontains',
label="Preferred Name")
birth_date = filters.DateFromToRangeFilter(
label="Birth Date Range",
widget=RangeWidget(attrs={
'type': 'date',
'class': 'form-control mb-2'
}))
years_of_education = filters.RangeFilter(
label="Years of Education Range",
widget=RangeWidget(attrs={
'type': 'number',
'class': 'form-control mb-2'
}))
contact_pref = filters.MultipleChoiceFilter(choices=CONTACT_CHOICES,
widget=Select2MultipleWidget(),
lookup_expr='icontains',
label="Contact Preference")
gender = filters.AllValuesMultipleFilter(widget=Select2MultipleWidget(),
lookup_expr='icontains',
label="Gender")
health_notes_inc = filters.CharFilter(field_name='health_notes',
lookup_expr='icontains',
label="Health Notes Include")
personal_notes_inc = filters.CharFilter(field_name='personal_notes',
lookup_expr='icontains',
label="Personal Notes Include")
has_family = filters.BooleanFilter(field_name='parent',
lookup_expr='isnull',
exclude=True,
label="Family In Database")
class Meta:
model = Adult
exclude = ['id', 'address', 'phone', 'email']
class RecordFilter(FilterSet):
date = DateFromToRangeFilter(
label='対象期間', widget=RangeWidget(attrs={'placeholder': 'YYYY-MM-DD'}))
time = TimeRangeFilter(label='対象時間',
widget=RangeWidget(attrs={'placeholder': 'hh:mm'}))
class Meta:
model = Record
fields = ['sns', 'date', 'time']
class CertificateFilter(FilterSet):
DATE_ATTR = {'type': 'date', 'placeholder': 'mm/dd/yyyy'}
status = MultipleChoiceFilter(
choices=Certificate.STATUS_CHOICES,
widget=CheckboxSelectMultiple(attrs={
'class': 'usa-unstyled-list',
'legend': 'Certificate Status'
}))
last_modified = DateFromToRangeFilter(widget=RangeWidget(attrs=DATE_ATTR))
date_of_sale = DateFromToRangeFilter(widget=RangeWidget(attrs=DATE_ATTR))
shipped_value = RangeFilter(widget=RangeWidget())
number_of_parcels = RangeFilter(widget=RangeWidget())
carat_weight = RangeFilter(widget=RangeWidget())
date_of_issue = DateFromToRangeFilter(widget=RangeWidget(attrs=DATE_ATTR))
date_of_expiry = DateFromToRangeFilter(widget=RangeWidget(attrs=DATE_ATTR))
licensee__name = ModelChoiceFilter(queryset=licensees)
date_of_delivery = DateFromToRangeFilter(widget=RangeWidget(
attrs=DATE_ATTR))
date_of_shipment = DateFromToRangeFilter(widget=RangeWidget(
attrs=DATE_ATTR))
date_voided = DateFromToRangeFilter(widget=RangeWidget(attrs=DATE_ATTR))
aes = CharFilter(lookup_expr='icontains')
exporter = CharFilter(lookup_expr='icontains')
exporter_address = CharFilter(lookup_expr='icontains')
consignee = CharFilter(lookup_expr='icontains')
consignee_address = CharFilter(lookup_expr='icontains')
class Meta:
model = Certificate
default_fields = ['status', 'aes', 'date_of_issue']
extra_fields = [
'licensee__name', 'country_of_origin', 'harmonized_code',
'port_of_export', 'shipped_value', 'number_of_parcels',
'carat_weight', 'date_of_expiry', 'date_of_shipment',
'date_of_delivery', 'exporter', 'exporter_address', 'consignee',
'consignee_address', 'last_modified', 'date_of_sale', 'date_voided'
]
fields = default_fields + extra_fields
@property
def default_fields(self):
return [
field for field in self.form
if field.name in self.Meta.default_fields
]
@property
def extra_fields(self):
return [
field for field in self.form
if field.name in self.Meta.extra_fields
]
class PostFilter(FilterSet):
published_date = DateTimeFromToRangeFilter(widget=RangeWidget(
attrs={"placeholder": "dd/mm/yyyy hh:mm"}))
updated_date = DateTimeFromToRangeFilter(widget=RangeWidget(
attrs={"placeholder": "dd/mm/yyyy hh:mm"}))
class Meta:
model = Post
fields = ("title", "slug", "author__name", "published_date",
"updated_date")
def test_widget(self):
w = RangeWidget()
self.assertEqual(len(w.widgets), 2)
self.assertHTMLEqual(w.render('price', ''), """
<input type="text" name="price_0" />
-
<input type="text" name="price_1" />""")
self.assertHTMLEqual(w.render('price', slice(5.99, 9.99)), """
<input type="text" name="price_0" value="5.99" />
-
<input type="text" name="price_1" value="9.99" />""")
def test_widget(self):
w = RangeWidget()
self.assertEqual(len(w.widgets), 2)
self.assertHTMLEqual(w.render('price', ''), """
<input type="text" name="price_min" />
-
<input type="text" name="price_max" />""")
self.assertHTMLEqual(w.render('price', slice(5.99, 9.99)), """
<input type="text" name="price_min" value="5.99" />
-
<input type="text" name="price_max" value="9.99" />""")
class SampleFilter(django_filters.FilterSet):
class Meta:
model = Sample
fields = ['md5', 'sha1', 'sha2', 'name', 'size', 'file_type']
md5 = django_filters.CharFilter(label='MD5', lookup_expr='icontains')
sha1 = django_filters.CharFilter(label='SHA1', lookup_expr='icontains')
sha2 = django_filters.CharFilter(label='SHA2', lookup_expr='icontains')
name = django_filters.CharFilter(label='File name', lookup_expr='icontains')
size_gte = django_filters.NumberFilter(label='Minimum Size', field_name='size', lookup_expr='gte')
size_lte = django_filters.NumberFilter(label='Maximum Size', field_name='size', lookup_expr='lte')
uploaded_on = django_filters.DateTimeFromToRangeFilter(widget=RangeWidget(attrs={'placeholder': 'MM/DD/YYYY'}))
file_type = django_filters.TypedChoiceFilter(choices=FILE_TYPE_CHOICES)
redisjob__status = django_filters.TypedChoiceFilter(choices=REDIS_JOB_CHOICES,
label='Status')
result__processed_on = django_filters.DateTimeFromToRangeFilter(widget=RangeWidget(attrs={'placeholder': 'MM/DD/YYYY'}))
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 ConsultationFilter(django_filters.FilterSet):
CSS_CLASS_CHOICES = (
('', _('')),
('event-success', _('Low')),
('event-warning', _('Medium')),
('event-important', _('High')),
)
title = django_filters.CharFilter(name='title', lookup_expr='icontains')
priority = django_filters.ChoiceFilter(name='css_class',
choices=CSS_CLASS_CHOICES)
start = DateFromToRangeFilter(widget=RangeWidget(
attrs={'placeholder': 'DD/MM/YYYY'}))
zID = django_filters.ModelChoiceFilter(queryset=student.objects.all())
class Meta:
model = CalendarEvent
fields = ['title']
dateTimeOptions = {
'daysOfWeekDisabled': [0, 6],
'format': 'dd/mm/yyyy HH:ii P',
'hoursDisabled': [0, 9],
}
widgets = {
#Use localization and bootstrap 3
'start':
DateTimeWidget(attrs={'id': "yourdatetimeid"},
usel10n=True,
bootstrap_version=3,
options=dateTimeOptions),
}
def test_clean(self):
w = RangeWidget()
f = RangeField(widget=w)
self.assertEqual(
f.clean(['12.34', '55']),
slice(to_d(12.34), to_d(55)))
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 PlantProductionFilter(django_filters.FilterSet):
# plant = django_filters.ModelChoiceFilter(queryset=Plant.objects.all())
# date = django_filters.DateRangeFilter(field_name="date")
date = django_filters.DateFromToRangeFilter(
field_name="date",
# widget=DatePickerInput(format='%d/%m/%Y'),
widget=RangeWidget(attrs={
"type": "text",
"placeholder": "DD/MM/YYYY"
}))
plant = django_filters.CharFilter(max_length=3,
field_name='plant__name',
lookup_expr='icontains')
shift = django_filters.CharFilter(max_length=5, lookup_expr='icontains')
operator_name = django_filters.CharFilter(max_length=100,
field_name='operator_name__name',
lookup_expr='icontains')
product_code = django_filters.CharFilter(max_length=10)
production = django_filters.CharFilter(max_length=10, )
class Meta:
model = PlantProduction
fields = [
'date', 'plant', 'shift', 'operator_name', 'no_of_winderman',
'product_code', 'start_reading', 'end_reading', 'wastage'
]
def test_clean(self):
w = RangeWidget()
f = RangeField(widget=w, required=False)
self.assertEqual(f.clean(['12.34', '55']),
slice(to_d(12.34), to_d(55)))
self.assertIsNone(f.clean([]))
class JCFilter(django_filters.FilterSet):
title = django_filters.CharFilter(
lookup_expr='icontains',
widget=forms.TextInput(attrs={'class': 'form-control'}))
journal = django_filters.CharFilter(
lookup_expr='icontains',
widget=forms.TextInput(attrs={'class': 'form-control'}))
hwl_recommend = django_filters.BooleanFilter()
content = django_filters.CharFilter(
lookup_expr='icontains',
widget=forms.TextInput(attrs={'class': 'form-control'}))
date_posted = django_filters.DateFromToRangeFilter(
field_name="date_posted",
lookup_expr='gte',
widget=RangeWidget(attrs={'type': 'date'}))
class Meta:
model = Jcpaper
fields = [
'title', 'journal', 'hwl_recommend', 'content', 'presenter',
'date_posted'
]
class SnippetFilter(FilterSet):
created_at = DateFromToRangeFilter(widget=RangeWidget(
attrs={'type': 'date'}))
class Meta:
model = Snippet
fields = ['created_at']
class CommitFilter(django_filters.FilterSet):
creation_date = django_filters.DateFromToRangeFilter(widget=RangeWidget(
attrs={"class": "datepicker_from"}))
class Meta:
model = Commit
fields = {"sha": ["icontains"]}
class BookFilter(django_filters.FilterSet):
CHOICES = (("ascending", "Ascending"), ("descending", "Descending"))
title = django_filters.CharFilter(
label="Title", field_name="title", lookup_expr="icontains"
)
genre = django_filters.ModelChoiceFilter(
label="Genre", queryset=Genre.objects.all(), field_name="genre"
)
author = django_filters.ModelChoiceFilter(
label="Author", queryset=Author.objects.all(), field_name="authors"
)
ordering = django_filters.ChoiceFilter(
label="Ordering by Price", choices=CHOICES, method="filter_by_order"
)
rating = django_filters.RangeFilter(
label="Rating Between",
field_name="rating",
widget=RangeWidget(attrs={"class": "textinput textInput form-control"}),
)
class Meta:
model = Book
fields = ["title", "genre", "author", "rating"]
@staticmethod
def filter_by_order(queryset, name, value):
expression = "price" if value == "ascending" else "-price"
return queryset.order_by(expression)
class DealFilter(django_filters.FilterSet):
STATUS_CHOICES = [('Z', _('Все контракты'))]
for STATUS in list(DealStatus.STATUS_CHOICES):
STATUS_CHOICES.append(STATUS)
STATUS_CHOICES = tuple(STATUS_CHOICES)
label = _(DealStatus._meta.get_field('status').verbose_name.title())
status = django_filters.ChoiceFilter(choices=STATUS_CHOICES,
method='filter_deal',
label=label)
label = _(DealStatus._meta.get_field('deal_data').verbose_name.title())
deal_data = django_filters.DateTimeFromToRangeFilter(
label=label, widget=RangeWidget(attrs={'placeholder': 'YYYY-MM-DD'}))
deal_data.widget.widgets[0] = DateWidget(attrs={'id': "yourdateid"},
usel10n=True,
bootstrap_version=3)
deal_data.widget.widgets[1] = DateWidget(attrs={'id': "yourdateid"},
usel10n=True,
bootstrap_version=3)
def filter_deal(self, queryset, name, value):
if value != 'Z':
queryset = queryset.filter(dealstatus__status__exact=value)
return queryset
class Meta:
model = Deal
fields = ['sales_person']
def test_clean(self):
w = RangeWidget()
f = DateRangeField(widget=w)
self.assertEqual(
f.clean(['2015-01-01', '2015-01-10']),
slice(datetime(2015, 1, 1, 0, 0, 0),
datetime(2015, 1, 10, 23, 59, 59, 999999)))
def test_clean(self):
w = RangeWidget()
f = TimeRangeField(widget=w)
self.assertEqual(
f.clean(['10:15', '12:30']),
slice(time(10, 15, 0), time(12, 30, 0)))
def test_clean(self):
w = RangeWidget()
f = DateTimeRangeField(widget=w)
self.assertEqual(
f.clean(['2015-01-01 10:30', '2015-01-10 8:45']),
slice(datetime(2015, 1, 1, 10, 30, 0),
datetime(2015, 1, 10, 8, 45, 0)))
class ExpenseFilter(FilterSet):
date_range = DateFromToRangeFilter(field_name='pub_date',
widget=RangeWidget())
class Meta:
model = Expense
fields = '__all__'
exclude = ('user', 'pub_date')
class WeatherFilter(django_filters.rest_framework.FilterSet):
datetime = DateTimeFromToRangeFilter(
lookup_expr=("icontains"),
widget=RangeWidget(attrs={"type": "datetime-local"}))
class Meta:
model = WeatherForecast
fields = ("datetime", )
class ToDoFilter(filters.FilterSet):
name = filters.CharFilter(lookup_expr='contains')
project = filters.ModelChoiceFilter(queryset=Project.objects.all())
created = filters.DateFromToRangeFilter(widget=RangeWidget(
attrs={'placeholder': 'YYYY-MM-DD'}))
class Meta:
model = ToDo
fields = ['name', 'project', 'created']
class TrackingFilter(django_filters.FilterSet):
type = django_filters.ModelChoiceFilter(queryset=get_types)
date = django_filters.DateFromToRangeFilter(
field_name='date', widget=RangeWidget(attrs={'type': 'date'}))
tags = django_filters.ModelChoiceFilter(queryset=get_tags)
class Meta:
model = TrackRecord
fields = ['type', 'date', 'tags']
def test_clean(self):
w = RangeWidget()
f = IsoDateTimeRangeField(widget=w)
expected = slice(
datetime(2015, 1, 1, 9, 30, 1, 123000, tzinfo=timezone.utc),
datetime(2015, 1, 10, 7, 45, 2, 345000, tzinfo=timezone.utc)
)
actual = f.clean(['2015-01-01T10:30:01.123000+01:00', '2015-01-10T08:45:02.345000+01:00'])
self.assertEqual(expected, actual)
class RequestFilter(django_filters.FilterSet):
created = DateFilter(field_name='created',
lookup_expr='icontains',
label='Created',
widget=DateInput(attrs={'type': 'date'}))
created_range = DateTimeFromToRangeFilter(
field_name='created',
lookup_expr='icontains',
label='Created Range',
widget=RangeWidget(attrs={'type': 'datetime-local'}))
fulfilled = DateFilter(field_name='fulfilled',
lookup_expr='icontains',
label='Fulfilled',
widget=DateInput(attrs={'type': 'date'}))
fulfilled_range = DateTimeFromToRangeFilter(
field_name='fulfilled',
lookup_expr='icontains',
label='Fulfilled Range',
widget=RangeWidget(attrs={'type': 'datetime-local'}))
reopened = NumberFilter(field_name='reopened',
lookup_expr='exact',
label='Reopened Count')
reopened_range = RangeFilter(field_name='reopened',
lookup_expr='icontains',
label='Reopened Count Range')
#Set choices for select fields
assignee = MultipleChoiceFilter(choices=get_all_customer_choices())
assignment_group = MultipleChoiceFilter(
choices=get_assignment_group_choices())
customer = MultipleChoiceFilter(choices=get_all_customer_choices())
location = MultipleChoiceFilter(choices=get_all_location_choices())
priority = MultipleChoiceFilter(choices=get_priority_choices())
status = MultipleChoiceFilter(choices=get_status_choices(
ticket_type=TicketType.objects.get(name='Request')))
class Meta:
model = Request
fields = '__all__'
exclude = [
'sysID',
'ticket_type',
]
class DadoFilter(django_filters.FilterSet):
date_range = DateTimeFromToRangeFilter(
field_name='date',
widget=RangeWidget(attrs={'placeholder': 'DD/MM/YYYY hh:mm'}))
sensor = ModelChoiceFilter(queryset=dispositivo)
class Meta:
model = Dado
fields = ['valor_char', 'valor_int']
