Hopiu/django-select2
1
0
Fork 0
mirror of https://github.com/Hopiu/django-select2.git synced 2026-04-24 15:04:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
django-select2/docs/get_started.rst

118 lines
5.2 KiB
ReStructuredText
Raw Normal View History

Added AUTO_RENDER_SELECT2_STATICS setting.
2012-09-14 06:34:36 +00:00
===========
Get Started
===========
Overview
--------
.. automodule:: django_select2
:members:
Installation
------------
1. Install `django_select2`::
pip install django_select2
2. Add `django_select2` to your `INSTALLED_APPS` in your project settings.
3. When deploying on production server, run::
python manage.py collectstatic
fix random typos found while reading the project
2013-11-20 00:44:28 +00:00
Update get_started.rst
2013-09-29 08:23:18 +00:00
4. Add `django_select` to your urlconf **if** you use any 'Auto' fields::
fix random typos found while reading the project
2013-11-20 00:44:28 +00:00
Update get_started.rst
2013-09-29 08:22:45 +00:00
url(r'^select2/', include('django_select2.urls')),
Added AUTO_RENDER_SELECT2_STATICS setting.
2012-09-14 06:34:36 +00:00
Update get_started.rst
2013-09-29 08:22:45 +00:00
5. (Optionally) If you need multiple processes support, then::
* Multi-process support. * Updated Select2 to 3.3.1.
2013-03-02 05:55:00 +00:00
python manage.py syncdb
v4.0.0 Added Hashed Id generation scheme
2013-03-15 06:00:40 +00:00
Available Settings
------------------
Added AUTO_RENDER_SELECT2_STATICS setting.
2012-09-14 06:34:36 +00:00
``AUTO_RENDER_SELECT2_STATICS`` [Default ``True``]
* Multi-process support. * Updated Select2 to 3.3.1.
2013-03-02 05:55:00 +00:00
..................................................
Added AUTO_RENDER_SELECT2_STATICS setting.
2012-09-14 06:34:36 +00:00
fix random typos found while reading the project
2013-11-20 00:44:28 +00:00
This, when specified and set to ``False`` in ``settings.py`` then Django_Select2 widgets won't automatically include the required scripts and stylesheets. When this setting is ``True`` then every Select2 field on the page will output ``<script>`` and ``<link>`` tags to include the required JS and CSS files. This is convenient but will output the same JS and CSS files multiple times if there are more than one Select2 fields on the page.
Added AUTO_RENDER_SELECT2_STATICS setting.
2012-09-14 06:34:36 +00:00
When this settings is ``False`` then you are responsible for including the JS and CSS files. To help you with this the following template tags are available in ``django_select2_tags``.
* Multi-process support. * Updated Select2 to 3.3.1.
2013-03-02 05:55:00 +00:00
* ``import_django_select2_js`` - Outputs ``<script>`` tags to include all the JS files, required by Light and Heavy widgets.
* ``import_django_select2_css`` - Outputs ``<link>`` tags to include all the CSS files, required by Light and Heavy widgets.
* ``import_django_select2_js_css`` - Outputs both ``<script>`` and ``<link>`` tags to include all the JS and CSS files, required by Light and Heavy widgets.
Added AUTO_RENDER_SELECT2_STATICS setting.
2012-09-14 06:34:36 +00:00
fix random typos found while reading the project
2013-11-20 00:44:28 +00:00
.. tip:: Make sure to include them at the top of the page, preferably in ``<head>...</head>``.
v3.3.1 commit
2013-03-12 18:59:02 +00:00
fix random typos found while reading the project
2013-11-20 00:44:28 +00:00
.. note:: (Since version 3.3.1) The above template tags accept one argument ``light``. Default value for that is ``0``.
Removed own caching solution in favour of django caching The old multiprocessing support was hard to maintain. Since signing and caching are part of `django.core` there is really no need to stick to our own solution. As a result multimachine support and security are now always in place. Fields are stored in Django's cache. The default cache used by select2 is called 'default' but can be cachanged overwriting the setting `SELECT2_CACHE_BACKEND`. Recommended cache backends are memcached, redis or a DB-cache. Refactored AutoResponseView The main reason for this refactoring is the fact that the pagingnation was slow. I dropped major parts of the initial code and wrote a more django-like-approach. Noteabley: - get_results now retuns a QuerySet - This commit drops django 1.6 support in favour of the JsonResponse (Backporting is possible).
2015-07-17 18:10:16 +00:00
If that is set to ``1`` then only the JS and CSS libraries needed by Select2Widget (Light fields) are rendered.
That effectively leaves out ``heavy.js`` and ``extra.css``.
Added AUTO_RENDER_SELECT2_STATICS setting.
2012-09-14 06:34:36 +00:00
Removed own caching solution in favour of django caching The old multiprocessing support was hard to maintain. Since signing and caching are part of `django.core` there is really no need to stick to our own solution. As a result multimachine support and security are now always in place. Fields are stored in Django's cache. The default cache used by select2 is called 'default' but can be cachanged overwriting the setting `SELECT2_CACHE_BACKEND`. Recommended cache backends are memcached, redis or a DB-cache. Refactored AutoResponseView The main reason for this refactoring is the fact that the pagingnation was slow. I dropped major parts of the initial code and wrote a more django-like-approach. Noteabley: - get_results now retuns a QuerySet - This commit drops django 1.6 support in favour of the JsonResponse (Backporting is possible).
2015-07-17 18:10:16 +00:00
``SELECT2_CACHE_BACKEND`` [Default ``default``]
...............................................
v4.0.0 Added Hashed Id generation scheme
2013-03-15 06:00:40 +00:00
Removed own caching solution in favour of django caching The old multiprocessing support was hard to maintain. Since signing and caching are part of `django.core` there is really no need to stick to our own solution. As a result multimachine support and security are now always in place. Fields are stored in Django's cache. The default cache used by select2 is called 'default' but can be cachanged overwriting the setting `SELECT2_CACHE_BACKEND`. Recommended cache backends are memcached, redis or a DB-cache. Refactored AutoResponseView The main reason for this refactoring is the fact that the pagingnation was slow. I dropped major parts of the initial code and wrote a more django-like-approach. Noteabley: - get_results now retuns a QuerySet - This commit drops django 1.6 support in favour of the JsonResponse (Backporting is possible).
2015-07-17 18:10:16 +00:00
Django-Select2 uses Django's cache to sure a consistent state across multiple machines.
v4.0.0 Added Hashed Id generation scheme
2013-03-15 06:00:40 +00:00
Removed own caching solution in favour of django caching The old multiprocessing support was hard to maintain. Since signing and caching are part of `django.core` there is really no need to stick to our own solution. As a result multimachine support and security are now always in place. Fields are stored in Django's cache. The default cache used by select2 is called 'default' but can be cachanged overwriting the setting `SELECT2_CACHE_BACKEND`. Recommended cache backends are memcached, redis or a DB-cache. Refactored AutoResponseView The main reason for this refactoring is the fact that the pagingnation was slow. I dropped major parts of the initial code and wrote a more django-like-approach. Noteabley: - get_results now retuns a QuerySet - This commit drops django 1.6 support in favour of the JsonResponse (Backporting is possible).
2015-07-17 18:10:16 +00:00
Example of settings.py::
v4.0.0 Added Hashed Id generation scheme
2013-03-15 06:00:40 +00:00
Removed own caching solution in favour of django caching The old multiprocessing support was hard to maintain. Since signing and caching are part of `django.core` there is really no need to stick to our own solution. As a result multimachine support and security are now always in place. Fields are stored in Django's cache. The default cache used by select2 is called 'default' but can be cachanged overwriting the setting `SELECT2_CACHE_BACKEND`. Recommended cache backends are memcached, redis or a DB-cache. Refactored AutoResponseView The main reason for this refactoring is the fact that the pagingnation was slow. I dropped major parts of the initial code and wrote a more django-like-approach. Noteabley: - get_results now retuns a QuerySet - This commit drops django 1.6 support in favour of the JsonResponse (Backporting is possible).
2015-07-17 18:10:16 +00:00
CACHES = {
"default": {
"BACKEND": "django_redis.cache.RedisCache",
"LOCATION": "redis://127.0.0.1:6379/1",
"OPTIONS": {
"CLIENT_CLASS": "django_redis.client.DefaultClient",
}
},
'select2': {
'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
'LOCATION': '127.0.0.1:11211',
}
}
* Multi-process support. * Updated Select2 to 3.3.1.
2013-03-02 05:55:00 +00:00
Removed own caching solution in favour of django caching The old multiprocessing support was hard to maintain. Since signing and caching are part of `django.core` there is really no need to stick to our own solution. As a result multimachine support and security are now always in place. Fields are stored in Django's cache. The default cache used by select2 is called 'default' but can be cachanged overwriting the setting `SELECT2_CACHE_BACKEND`. Recommended cache backends are memcached, redis or a DB-cache. Refactored AutoResponseView The main reason for this refactoring is the fact that the pagingnation was slow. I dropped major parts of the initial code and wrote a more django-like-approach. Noteabley: - get_results now retuns a QuerySet - This commit drops django 1.6 support in favour of the JsonResponse (Backporting is possible).
2015-07-17 18:10:16 +00:00
# Set the cache backend to select2
SELECT2_CACHE_BACKEND = 'select2'
* Multi-process support. * Updated Select2 to 3.3.1.
2013-03-02 05:55:00 +00:00
Removed own caching solution in favour of django caching The old multiprocessing support was hard to maintain. Since signing and caching are part of `django.core` there is really no need to stick to our own solution. As a result multimachine support and security are now always in place. Fields are stored in Django's cache. The default cache used by select2 is called 'default' but can be cachanged overwriting the setting `SELECT2_CACHE_BACKEND`. Recommended cache backends are memcached, redis or a DB-cache. Refactored AutoResponseView The main reason for this refactoring is the fact that the pagingnation was slow. I dropped major parts of the initial code and wrote a more django-like-approach. Noteabley: - get_results now retuns a QuerySet - This commit drops django 1.6 support in favour of the JsonResponse (Backporting is possible).
2015-07-17 18:10:16 +00:00
.. tip:: To ensure a consistent state across all you machines you need to user
a consistent external cache backend like Memcached, Redis or a database.
v4.0.0 Added Hashed Id generation scheme
2013-03-15 06:00:40 +00:00
Removed own caching solution in favour of django caching The old multiprocessing support was hard to maintain. Since signing and caching are part of `django.core` there is really no need to stick to our own solution. As a result multimachine support and security are now always in place. Fields are stored in Django's cache. The default cache used by select2 is called 'default' but can be cachanged overwriting the setting `SELECT2_CACHE_BACKEND`. Recommended cache backends are memcached, redis or a DB-cache. Refactored AutoResponseView The main reason for this refactoring is the fact that the pagingnation was slow. I dropped major parts of the initial code and wrote a more django-like-approach. Noteabley: - get_results now retuns a QuerySet - This commit drops django 1.6 support in favour of the JsonResponse (Backporting is possible).
2015-07-17 18:10:16 +00:00
.. note:: Select2 requires the cache to never expire. Therefore you should avoid clearing the cache.
As third party apps might add unpredictable behavior we recommend to always use an separate cache server.
* Multi-process support. * Updated Select2 to 3.3.1.
2013-03-02 05:55:00 +00:00
Removed own caching solution in favour of django caching The old multiprocessing support was hard to maintain. Since signing and caching are part of `django.core` there is really no need to stick to our own solution. As a result multimachine support and security are now always in place. Fields are stored in Django's cache. The default cache used by select2 is called 'default' but can be cachanged overwriting the setting `SELECT2_CACHE_BACKEND`. Recommended cache backends are memcached, redis or a DB-cache. Refactored AutoResponseView The main reason for this refactoring is the fact that the pagingnation was slow. I dropped major parts of the initial code and wrote a more django-like-approach. Noteabley: - get_results now retuns a QuerySet - This commit drops django 1.6 support in favour of the JsonResponse (Backporting is possible).
2015-07-17 18:10:16 +00:00
``ENABLE_SELECT2_MULTI_PROCESS_SUPPORT`` [Default ``False``]
............................................................
.. warning:: Deprecated in favour of ``SELECT2_CACHE_BACKEND``. Will be removed in version 5.
* Multi-process support. * Updated Select2 to 3.3.1.
2013-03-02 05:55:00 +00:00
Removed own caching solution in favour of django caching The old multiprocessing support was hard to maintain. Since signing and caching are part of `django.core` there is really no need to stick to our own solution. As a result multimachine support and security are now always in place. Fields are stored in Django's cache. The default cache used by select2 is called 'default' but can be cachanged overwriting the setting `SELECT2_CACHE_BACKEND`. Recommended cache backends are memcached, redis or a DB-cache. Refactored AutoResponseView The main reason for this refactoring is the fact that the pagingnation was slow. I dropped major parts of the initial code and wrote a more django-like-approach. Noteabley: - get_results now retuns a QuerySet - This commit drops django 1.6 support in favour of the JsonResponse (Backporting is possible).
2015-07-17 18:10:16 +00:00
Since version 4.3 django-select2 supports multiprocessing support out of the box.
If you want to have multiple machine support take a look at ``SELECT2_CACHE_BACKEND``.
* Multi-process support. * Updated Select2 to 3.3.1.
2013-03-02 05:55:00 +00:00
Removed own caching solution in favour of django caching The old multiprocessing support was hard to maintain. Since signing and caching are part of `django.core` there is really no need to stick to our own solution. As a result multimachine support and security are now always in place. Fields are stored in Django's cache. The default cache used by select2 is called 'default' but can be cachanged overwriting the setting `SELECT2_CACHE_BACKEND`. Recommended cache backends are memcached, redis or a DB-cache. Refactored AutoResponseView The main reason for this refactoring is the fact that the pagingnation was slow. I dropped major parts of the initial code and wrote a more django-like-approach. Noteabley: - get_results now retuns a QuerySet - This commit drops django 1.6 support in favour of the JsonResponse (Backporting is possible).
2015-07-17 18:10:16 +00:00
``SELECT2_MEMCACHE_HOST`` [Default ``None``], ``SELECT2_MEMCACHE_PORT`` [Default ``None``]
..........................................................................................
* Multi-process support. * Updated Select2 to 3.3.1.
2013-03-02 05:55:00 +00:00
Removed own caching solution in favour of django caching The old multiprocessing support was hard to maintain. Since signing and caching are part of `django.core` there is really no need to stick to our own solution. As a result multimachine support and security are now always in place. Fields are stored in Django's cache. The default cache used by select2 is called 'default' but can be cachanged overwriting the setting `SELECT2_CACHE_BACKEND`. Recommended cache backends are memcached, redis or a DB-cache. Refactored AutoResponseView The main reason for this refactoring is the fact that the pagingnation was slow. I dropped major parts of the initial code and wrote a more django-like-approach. Noteabley: - get_results now retuns a QuerySet - This commit drops django 1.6 support in favour of the JsonResponse (Backporting is possible).
2015-07-17 18:10:16 +00:00
.. warning:: Deprecated in favour of ``SELECT2_CACHE_BACKEND``. Will be removed in version 5.
* Multi-process support. * Updated Select2 to 3.3.1.
2013-03-02 05:55:00 +00:00
Removed own caching solution in favour of django caching The old multiprocessing support was hard to maintain. Since signing and caching are part of `django.core` there is really no need to stick to our own solution. As a result multimachine support and security are now always in place. Fields are stored in Django's cache. The default cache used by select2 is called 'default' but can be cachanged overwriting the setting `SELECT2_CACHE_BACKEND`. Recommended cache backends are memcached, redis or a DB-cache. Refactored AutoResponseView The main reason for this refactoring is the fact that the pagingnation was slow. I dropped major parts of the initial code and wrote a more django-like-approach. Noteabley: - get_results now retuns a QuerySet - This commit drops django 1.6 support in favour of the JsonResponse (Backporting is possible).
2015-07-17 18:10:16 +00:00
Since version 4.3 dajngo-select2 uses Django's own caching solution.
The hostname and port will be used to create a new django cache backend.
* Multi-process support. * Updated Select2 to 3.3.1.
2013-03-02 05:55:00 +00:00
Removed own caching solution in favour of django caching The old multiprocessing support was hard to maintain. Since signing and caching are part of `django.core` there is really no need to stick to our own solution. As a result multimachine support and security are now always in place. Fields are stored in Django's cache. The default cache used by select2 is called 'default' but can be cachanged overwriting the setting `SELECT2_CACHE_BACKEND`. Recommended cache backends are memcached, redis or a DB-cache. Refactored AutoResponseView The main reason for this refactoring is the fact that the pagingnation was slow. I dropped major parts of the initial code and wrote a more django-like-approach. Noteabley: - get_results now retuns a QuerySet - This commit drops django 1.6 support in favour of the JsonResponse (Backporting is possible).
2015-07-17 18:10:16 +00:00
.. note:: It is recommended to upgrade to ``SELECT2_CACHE_BACKEND`` to avoid cache consistency issues.
* Multi-process support. * Updated Select2 to 3.3.1.
2013-03-02 05:55:00 +00:00
Adds bootstrap 3 support to make select2 look a little nicer
2013-11-08 02:34:03 +00:00
``SELECT2_BOOTSTRAP`` [Default ``False``]
Removed own caching solution in favour of django caching The old multiprocessing support was hard to maintain. Since signing and caching are part of `django.core` there is really no need to stick to our own solution. As a result multimachine support and security are now always in place. Fields are stored in Django's cache. The default cache used by select2 is called 'default' but can be cachanged overwriting the setting `SELECT2_CACHE_BACKEND`. Recommended cache backends are memcached, redis or a DB-cache. Refactored AutoResponseView The main reason for this refactoring is the fact that the pagingnation was slow. I dropped major parts of the initial code and wrote a more django-like-approach. Noteabley: - get_results now retuns a QuerySet - This commit drops django 1.6 support in favour of the JsonResponse (Backporting is possible).
2015-07-17 18:10:16 +00:00
.........................................
Adds bootstrap 3 support to make select2 look a little nicer
2013-11-08 02:34:03 +00:00
Setting to True will include the CSS for making Select2 fit in with Bootstrap a bit better using the css found here https://github.com/fk/select2-bootstrap-css.
Added AUTO_RENDER_SELECT2_STATICS setting.
2012-09-14 06:34:36 +00:00
External Dependencies
---------------------
* Django - This is obvious.
fix random typos found while reading the project
2013-11-20 00:44:28 +00:00
* jQuery - This is not included in the package since it is expected that in most scenarios this would already be available. The above template tags also won't output ``<script>`` tag to include this. You need to do this yourself.
update capitalization of proper nouns I usually spell ajax as AJAX, but after doing some reasearch, it seems like Ajax is more commonly used.
2013-11-20 00:49:49 +00:00
* Memcached (python-memcached) - If you plan on running multiple Python processes, which is usually the case in production, then you need to turn on ``ENABLE_SELECT2_MULTI_PROCESS_SUPPORT``. In that mode it is highly recommended that you use Memcached, to minimize DB hits.
Added AUTO_RENDER_SELECT2_STATICS setting.
2012-09-14 06:34:36 +00:00
Example Application
-------------------
Please see ``testapp`` application. This application is used to manually test the functionalities of this package. This also serves as a good example.
You need only Django 1.4 or above to run that. It might run on older versions but that is not tested.
Reference in a new issue Copy permalink