Introduction
In this tutorial, we are going to create a nice crispy range slider using django-crispy-forms for an integer filter provided by django-filters. Tutorial can be split into four sections. In the first or prerequisite section, we will install the required packages and initiate the Django project. In the next section, we will create the simple app with a model, view, and template. In the third section, we will create the simple range filter using django-filters package without a slider. In the fourth and last section, we will describe how to create a range-slider and integrate it into our Django app created in the third section.
Prerequisite
First things first, let’s create a directory with the working environment:
$ mkdir myproject
$ cd myproject
$ pipenv shell
Then, install packages that are required in this tutorial using pip
:
$ pip install Django
$ pip install django-crispy-forms
$ pip install django-filter
Next, create a new Django project called myproject :
$ django-admin startproject myproject
$ mv myproject src
Similarly, create a new Django app called myapp :
$ python manage.py startapp myapp
In the following sections, you are going to need to generate sample data for our model. Hence, let’s create a new Django admin super-user using the following command:
$ python manage.py createsuperuser
To enable packages in Django project, add following lines to the INSTALLED_APPS
in /src/myproject/settings.py
:
INSTALLED_APPS = [
...
'django.forms', # Required in the last section.
'django_filters', # Django-filter
'crispy_forms',
'myapp'
]
Then, add the following line to TEMPLATES
in /src/myproject/settings.py
:
TEMPLATES = [
{
...
'DIRS': [BASE_DIR / 'templates'],
...
},
]
Next, add path /src/myproject/static
to STATICFILES_DIRS
in /src/myproject/settings.py
to enable the CSS and JS files, which will be required in upcoming sections:
...
STATICFILES_DIRS = [BASE_DIR / 'static']
...
Finally, add the following line of code to /src/myproject/settings.py
to enable widget customization in our Django project.
...
FORM_RENDERER = 'django.forms.renderers.TemplatesSetting'
...
Getting Ready
In this section, we will create a model called People
, a view for this model, and a template for that view.
The Model
Create a model called People
using three fields name , surname and age. The target filter-field is IntegerField
named age :
class People(models.Model):
name = models.CharField(null=True,blank=True,max_length=50)
surname = models.CharField(null=True,blank=True,max_length=50)
age = models.IntegerField()
Run makemigrations
and then migrate
to apply change to the default SQLite database:
$ python manage.py makemigrations
$ python manage.py migrate
Then, register the model in Django admin by adding the following code to file /src/myapp/admin.py
:
from django.contrib import admin
from .models import People
class PeopleAdmin(admin.ModelAdmin):
pass
admin.site.register(People, PeopleAdmin)
NOTE: Add some items to the database from the Django admin page at http://127.0.0.1:8000/admin/.
The View
Now let’s create a simple view that will print all instances of People
model in /src/myapp/views.py
.
from django.shortcuts import render
from .models import People
def index(request):
all_people = People.objects.all()
return render(request, 'index.html', {'all_people':all_people})
URLs
Create a URL path by adding following line to the file /src/myproject/urls.py
:
...
from myapp.views import index
urlpatterns = [
...
path('', index),
]
The Template
In order to create the simplest template to render all People instances, create a file /src/templates/index.html
with the following content:
<table border='1' style="width:100%; text-align:center">
<thead>
<tr>
<th> Name </th>
<th> Surname </th>
<th> Age </th>
</tr>
</thead>
<tbody>
{% for person in all_people %}
<tr>
<td> {{ person.name }} </td>
<td> {{ person.surname }} </td>
<td> {{ person.age }} </td>
</tr>
{% endfor %}
</tbody>
</table>
Recap
In this section, we created a simple view and template to print database records for People
model. Executing $ python manage.py runserver
should make available the following screen:
Naive Range Filter
In order to ensure coherence let’s first create a simple(or naive) RangeFilter
provide by django-filters package.
The Filter
Create in a new file /src/myapp/filters.py
and insert the following code:
import django_filters
from .models import People
class PeopleFilter(django_filters.FilterSet):
age = django_filters.AllValuesFilter()
class Meta:
model = People
fields = ['age']
This will create a simple range-filter with minimum and maximum value requirements for age
field of People
model.
The View
Now that filtering logic is ready, let’s add the filtering feature to the main view in /src/myapp/views.py
.
from django.shortcuts import render
from .filters import PeopleFilter
def index(request):
people_filter = RangeFilter(request.GET)
return render(request, 'index.html', {'people_filter':people_filter})
In the above code, RangeFilter
instantiation takes request.GET
as a single parameter since our form is set to GET mode.
The Template
With our filter ready, we can add filter controls in the front. Once again change the primary template file /src/template/index.html
to look like this:
<form method="get">
{{ people_filter.form.as_p }}
<input type="submit" />
</form>
<table border='1' style="width:100%; text-align:center">
<thead>
<tr>
<th> Name </th>
<th> Surname </th>
<th> Age </th>
</tr>
</thead>
<tbody>
{% for person in people_filter.qs %}
<tr>
<td> {{ person.name }} </td>
<td> {{ person.surname }} </td>
<td> {{ person.age }} </td>
</tr>
{% endfor %}
</tbody>
</table>
Notice that we now have an additional filtering form provided by django-filters. In addition, observe that for
statement loops over people_filter.qs
instead of all_people
. The .qs
stands for query set, which is self-explanatory.
Recap
In this section, we created the simplest or naive filter. The final result should look like this:
Crispy Range-Slider
To create a working crispy range-slider we need the following:
- Front-end Backbone: Actual range-slider with HTML, CSS and JavaScript.
- Django Widget: Custom Django widget for the actual range-slider backbone.
- Crispy Form: Crispy form with a layout template for the custom widget.
- Range Filter: Custom filter from django-filters package that utilizes the range-slider widget with the Crispy form.
Each point will be described in details so let’s move step-by-step:
The Front-End
The first and obvious step is to create an actual slider. Since range-slider is fancy filtering “thing” and not a real HTML form element, let’s use a popular trick to make such a fancy “thing” act like an HTML form element. Particularly, we use jQuery’s range slider feature to make our range-slider work. Here is a sample HTML blueprint for our slider:
<div id="my-numeric-slider"
class="form-group numeric-slider"
data-range_min="[Min. Possible Value]"
data-range_max="[Max. Possible Value]"
data-cur_min="[Current Min. Value]"
data-cur_max="[Current Max. Value]">
<div class="numeric-slider-range ui-slider ui-slider-horizontal ui-slider-range"></div>
<span class="numeric-slider-range_text" id='my-numeric-slider_text'>[Lower Value] - [Upper Value]</span>
<input type='hidden' id='my-numeric-slider_min' name='slider-min'/>
<input type='hidden' id='my-numeric-slider_max' name='slider-max'/>
</div>
The above HTML markup is comprised of outer Div element where the first two data- attributes represent possible minimum and maximum values of the range filter, last two data- attributes represent current lower and upper values of the range filter that were established when the page is loaded. Likewise, the first inner elements Div with the class numeric-slider-range
is the main element transformed to the range slider by jQuery when the page is loaded. The last two hidden Input form-elements represent the primary means by which the data is passed from the client to the server-side when the form is submitted. Additionally, the above HTML markup requires a JS script to make the slider work and a CSS markup to render the elements properly. Both can be found in GitHub repo. Finally, apply the last template code bellow to the file /src/templates/index.html
:
{% load static %}
{% load crispy_forms_tags %}
<head>
<link rel="stylesheet" href="{% static 'custom_slider.css' %}"> # CSS of our range-slider.
<link rel="stylesheet" href="//code.jquery.com/ui/1.12.1/themes/base/jquery-ui.css">
<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
<script src="https://code.jquery.com/ui/1.12.1/jquery-ui.js"></script>
</head>
<body>
{% crispy people_filter.form %}
<table border='1' style="width:100%; text-align:center">
<thead>
<tr>
<th> Name </th>
<th> Surname </th>
<th> Age </th>
</tr>
</thead>
<tbody>
{% for person in people_filter.qs %}
<tr>
<td> {{ person.name }} </td>
<td> {{ person.surname }} </td>
<td> {{ person.age }} </td>
</tr>
{% endfor %}
</tbody>
</table>
<script src="{% static 'custom_slider.js' %}"></script> # JS of our range-slider.
</body>
Notice that in the HTML above we load the crispy_forms_tags
and use {% crispy people_filter.form %}
instead of .as_p
. Doing so we let django-crispy-forms package handle our form rendering.
NOTE: The django-crispy-forms package provides two ways to render crispy forms. Common way is to use
|crispy filter
to render the form but it expects to be wrapped in<form>...</form>
HTML tag. In our tutorial, we use{% crispy %}
tag because we will generate our form using theFormHelper
.
The Django Widget
Django uses widgets to render form-fields and present them as final HTML markup. Therefore, to let Django handle the rendering of our front-end backbone, we need a working widget. In Django, a widget consists of two parts:
- a widget-template that represents the final HTML
- a class that inherits Django’s
Widget
class withrender()
method.
Widget Class
The django-filters package provides a working RangeFilter
with a predefined RangeWidget
that we seamlessly/automagically used in the previous section. This widget uses two text-fields associated with two text-input HTML form-elements. Notice that it is similar to hidden input-elements required in our case. To make our widget work we will simply rewrite the default RangeWidget
provided by django-filter to be compatible with our range-slider. For simplicity let’s call it the CustomRangeWidget
:
from django.forms.widgets import HiddenInput
from django_filters.widgets import RangeWidget
class CustomRangeWidget(RangeWidget):
template_name = 'forms/widgets/range-slider.html'
def __init__ (self, attrs=None):
widgets = (HiddenInput(), HiddenInput())
super(RangeWidget, self). __init__ (widgets, attrs)
def get_context(self, name, value, attrs):
ctx = super().get_context(name, value, attrs)
cur_min, cur_max = value
if cur_min is None:
cur_min = ctx['widget']['attrs']['data-range_min']
if cur_max is None:
cur_max = ctx['widget']['attrs']['data-range_max']
ctx['widget']['attrs'].update({'data-cur_min':cur_min,
'data-cur_max':cur_max})
base_id = ctx['widget']['attrs']['id']
for swx, subwidget in enumerate(ctx['widget']['subwidgets']):
subwidget['attrs']['id'] = base_id + "_" + self.suffixes[swx]
ctx['widget']['value_text'] = "{} - {}".format(cur_min,cur_max)
return ctx
Widget Template
The widget also requires an associated template. Let’s create a file in /src/templates/forms/widgets/range-slider.html
and insert the following content.
<div class="form-group numeric-slider" {% include "django/forms/widgets/attrs.html" %}>
<div class="numeric-slider-range ui-slider ui-slider-horizontal ui-slider-range"></div>
<span class="numeric-slider-range_text" id='{{ widget.attrs.id }}_text'>
{{ widget.value_text }}
</span>
{% for widget in widget.subwidgets %}
{% include widget.template_name %}
{% endfor %}
</div>
In the above widget-template, we use {% include "django/forms/widgets/attrs.html" %}
to let Django handle the widget attributes. It does so by parsing dictionary ctx['widget']['attrs']
from previous part. Likewise, the for
loop add widget’s HiddenInput
elements.
The Crispy Form
At last, we have our actual widget ready and now we can create a crispy-form with a special template for our slider. This crispy layout template basically helps our widget to fit the Bootstrap markup logic. In other words, it makes it crispy.
Crispy Template
Create a new file /src/templates/forms/fields/range-slider.html
. Then add the following template code:
{% load crispy_forms_field %}
<div class="form-group{% if 'form-horizontal' in form_class %} row{% endif %}">
<label for="{{ field.id_for_label }}" class="{% if 'form-horizontal' in form_class %}col-form-label {% endif %}{{ label_class }}{% if field.field.required %} requiredField{% endif %}">
{{ field.label|safe }}
{% if field.field.required %}
<span class="asteriskField">*</span>
{% endif %}
</label>
{% crispy_field field %}
</div>
NOTE: the above code is based on django-crispy-forms’s bootstrap4 templates and was not tested in bootstrap3 or other crispy template-engine.
Crispy Form Helper
Once the crispy template is ready we need a form where the template will be utilized. Create a file /src/myapp/forms.py
and add the following code:
from crispy_forms.helper import FormHelper
from crispy_forms.bootstrap import StrictButton
from crispy_forms.layout import Field, Layout
from django import forms
from django_filters.fields import RangeField
class PeopleFilterFormHelper(forms.Form):
def __init__ (self, *args, **kwargs):
super(). __init__ (*args, **kwargs)
self.helper = FormHelper(self)
self.helper.form_method = 'get'
layout_fields = []
for field_name, field in self.fields.items():
if isinstance(field, RangeField):
layout_field = Field(field_name, template="forms/fields/range-slider.html")
else:
layout_field = Field(field_name)
layout_fields.append(layout_field)
layout_fields.append(StrictButton("Submit", name='submit', type='submit', css_class='btn btn-fill-out btn-block mt-1'))
self.helper.layout = Layout(*layout_fields)
In the code above the class PeopleFilterFormHelper
is nothing different than a simple Django form with a fancy name. However, instead of a common way of constructing Django form we use the Crispy approach with its FormHelper
.
NOTE: the
FormHelper
simply helps you to create a fancy form, which would most certainly be possible to create with the same Django means but with more effort. Our form is rather basic for the sake of clarity of our tutorial, so it is not obvious.
Range Filter
At last, we have everything ready except the actual filtering logic.
Custom Range Filter
Insert following final filter code to the file /src/myapp/filters.py
.
from django_filters import FilterSet
from django_filters.filters import RangeFilter
from .models import People
from .forms import PeopleFilterFormHelper
from .widgets import CustomRangeWidget
class AllRangeFilter(RangeFilter):
def __init__ (self, *args, **kwargs):
super(). __init__ (*args, **kwargs)
values = [p.age for p in People.objects.all()]
min_value = min(values)
max_value = max(values)
self.extra['widget'] = CustomRangeWidget(attrs={'data-range_min':min_value,'data-range_max':max_value})
class PeopleFilter(FilterSet):
age = AllRangeFilter()
class Meta:
model = People
fields = ['age']
form = PeopleFilterFormHelper
In the code above, PeopleFilter
represents the set of filters for model People
. Notice the line form = PeopleFilterFormHelper
, which overrides default form builder of django-filters to our custom PeopleFilterFormHelper
. The actual filter is the AllRangeFilter
class, which is a customized version of the original django-filters package’s RangeFilter
. We override its __init__
method and initiate our custom widget CustomRangeWidget
with initial minimum and maximum values of all possible age values from People
model’s age
field.
NOTE: I totally agree that list comprehension is far not the best way to get the min. and max. values but this is a tutorial and its for only for educational purpose.
Recap
At last, we created our range filter with a fancy slider that should looks like this:
Summary
In this tutorial, you learned how to create a fancy jQuery range slider with the custom widget for custom range filter provided by django-filters
package. Moreover, you learned how to use render the custom widget using django-crispy-forms
package. The source code for this tutorial can be found on my GitHub repo. I hope this tutorial was helpful to the reader and eased his suffering while learning these amazing Django packages.
Top comments (0)