Configuration¶

CMS_TEMPLATES¶

default

() (Not a valid setting!)

A list of templates you can select for a page.

Example:

CMS_TEMPLATES = (
    ('base.html', gettext('default')),
    ('2col.html', gettext('2 Column')),
    ('3col.html', gettext('3 Column')),
    ('extra.html', gettext('Some extra fancy template')),
)

CMS_TEMPLATE_INHERITANCE¶

default

True

Enables the inheritance of templates from parent pages.

When enabled, pages’ Template options will include a new default: Inherit from the parent page (unless the page is a root page).

CMS_TEMPLATES_DIR¶

default

None

Instead of explicitly providing a set of templates via CMS_TEMPLATES a directory can be provided using this configuration.

CMS_TEMPLATES_DIR can be set to the (absolute) path of the templates directory, or set to a dictionary with SITE_ID: template path items:

CMS_TEMPLATES_DIR: {
    1: '/absolute/path/for/site/1/',
    2: '/absolute/path/for/site/2/',
}

The provided directory is scanned and all templates in it are loaded as templates for django CMS.

Template loaded and their names can be customized using the templates dir as a python module, by creating a __init__.py file in the templates directory. The file contains a single TEMPLATES dictionary with the list of templates as keys and template names as values:::

# -*- coding: utf-8 -*-
from django.utils.translation import ugettext_lazy as _
TEMPLATES = {
    'col_two.html': _('Two columns'),
    'col_three.html': _('Three columns'),
}

Being a normal python file, templates labels can be passed through gettext for translation.

CMS_PLACEHOLDER_CONF¶

default

{}

Used to configure placeholders. If not given, all plugins will be available in all placeholders.

Example:

CMS_PLACEHOLDER_CONF = {
    'content': {
        'plugins': ['TextPlugin', 'PicturePlugin'],
        'text_only_plugins': ['LinkPlugin'],
        'extra_context': {"width":640},
        'name': gettext("Content"),
        'language_fallback': True,
        'default_plugins': [
            {
                'plugin_type': 'TextPlugin',
                'values': {
                    'body':'<p>Lorem ipsum dolor sit amet...</p>',
                },
            },
        ],
        'child_classes': {
            'TextPlugin': ['PicturePlugin', 'LinkPlugin'],
        },
        'parent_classes': {
            'LinkPlugin': ['TextPlugin'],
        },
    },
    'right-column': {
        "plugins": ['TeaserPlugin', 'LinkPlugin'],
        "extra_context": {"width": 280},
        'name': gettext("Right Column"),
        'limits': {
            'global': 2,
            'TeaserPlugin': 1,
            'LinkPlugin': 1,
        },
        'plugin_modules': {
            'LinkPlugin': 'Extra',
        },
        'plugin_labels': {
            'LinkPlugin': 'Add a link',
        },
    },
    'base.html content': {
        "plugins": ['TextPlugin', 'PicturePlugin', 'TeaserPlugin'],
        'inherit': 'content',
    },
}

You can combine template names and placeholder names to granularly define plugins, as shown above with base.html content.

plugins

A list of plugins that can be added to this placeholder. If not supplied, all plugins can be selected.

text_only_plugins

A list of additional plugins available only in the TextPlugin, these plugins can’t be added directly to this placeholder.

extra_context

Extra context that plugins in this placeholder receive.

name

The name displayed in the Django admin. With the gettext stub, the name can be internationalized.

limits

Limit the number of plugins that can be placed inside this placeholder. Dictionary keys are plugin names and the values are their respective limits. Special case: global - Limit the absolute number of plugins in this placeholder regardless of type (takes precedence over the type-specific limits).

language_fallback

When True, if the placeholder has no plugin for the current language it falls back to the fallback languages as specified in CMS_LANGUAGES. Defaults to True since version 3.1.

default_plugins

You can specify the list of default plugins which will be automagically added when the placeholder will be created (or rendered). Each element of the list is a dictionary with following keys :

plugin_type

The plugin type to add to the placeholder Example : ‘TextPlugin’

values

Dictionary to use for the plugin creation. It depends on the plugin_type. See the documentation of each plugin type to see which parameters are required and available. Example for a Textplugin: {‘body’:’<p>Lorem ipsum</p>’} Example for a LinkPlugin : {‘name’:’Django-CMS’,’url’:’https://www.django-cms.org‘}

children

It is a list of dictionnaries to configure default plugins to add as children for the current plugin (it must accepts children). Each dictionary accepts same args than dictionnaries of default_plugins : plugin_type, values, children (yes, it is recursive).

Complete example of default_plugins usage:

CMS_PLACEHOLDER_CONF = {
    'content': {
        'name' : _('Content'),
        'plugins': ['TextPlugin', 'LinkPlugin'],
        'default_plugins':[
            {
                'plugin_type':'TextPlugin',
                'values':{
                    'body':'<p>Great websites : %(_tag_child_1)s and %(_tag_child_2)s</p>'
                },
                'children':[
                    {
                        'plugin_type':'LinkPlugin',
                        'values':{
                            'name':'django',
                            'url':'https://www.djangoproject.com/'
                        },
                    },
                    {
                        'plugin_type':'LinkPlugin',
                        'values':{
                            'name':'django-cms',
                            'url':'https://www.django-cms.org'
                        },
                        # If using LinkPlugin from djangocms-link which
                        # accepts children, you could add some grandchildren :
                        # 'children' : [
                        #     ...
                        # ]
                    },
                ]
            },
        ]
    }
}

plugin_modules

A dictionary of plugins and custom module names to group plugin in the toolbar UI.

plugin_labels

A dictionary of plugins and custom labels to show in the toolbar UI.

child_classes

A dictionary of plugin names with lists describing which plugins may be placed inside each plugin. If not supplied, all plugins can be selected.

parent_classes

A dictionary of plugin names with lists describing which plugins may contain each plugin. If not supplied, all plugins can be selected.

require_parent

A boolean indication whether that plugin requires another plugin as parent or not.

inherit

Placeholder name or template name + placeholder name which inherit. In the example, the configuration for “base.html content” inherits from “content” and just overwrite the “plugins” setting to allow TeaserPlugin, thus you have not to duplicate your “content“‘s configuration.

CMS_PLUGIN_CONTEXT_PROCESSORS¶

default

[]

A list of plugin context processors. Plugin context processors are callables that modify all plugins’ context before rendering. See Custom Plugins for more information.

CMS_PLUGIN_PROCESSORS¶

default

[]

A list of plugin processors. Plugin processors are callables that modify all plugins’ output after rendering. See Custom Plugins for more information.

CMS_APPHOOKS¶

default:

()

A list of import paths for cms.app_base.CMSApp subclasses.

By default, apphooks are auto-discovered in applications listed in all INSTALLED_APPS, by trying to import their cms_app module.

When CMS_APPHOOKS is set, auto-discovery is disabled.

Example:

CMS_APPHOOKS = (
    'myapp.cms_app.MyApp',
    'otherapp.cms_app.MyFancyApp',
    'sampleapp.cms_app.SampleApp',
)

CMS_LANGUAGES¶

default

Value of LANGUAGES converted to this format

Defines the languages available in django CMS.

Example:

CMS_LANGUAGES = {
    1: [
        {
            'code': 'en',
            'name': gettext('English'),
            'fallbacks': ['de', 'fr'],
            'public': True,
            'hide_untranslated': True,
            'redirect_on_fallback':False,
        },
        {
            'code': 'de',
            'name': gettext('Deutsch'),
            'fallbacks': ['en', 'fr'],
            'public': True,
        },
        {
            'code': 'fr',
            'name': gettext('French'),
            'public': False,
        },
    ],
    2: [
        {
            'code': 'nl',
            'name': gettext('Dutch'),
            'public': True,
            'fallbacks': ['en'],
        },
    ],
    'default': {
        'fallbacks': ['en', 'de', 'fr'],
        'redirect_on_fallback':True,
        'public': True,
        'hide_untranslated': False,
    }
}

CMS_LANGUAGES has different options where you can define how different languages behave, with granular control.

On the first level you can set values for each SITE_ID. In the example above we define two sites. The first site has 3 languages (English, German and French) and the second site has only Dutch.

The default node defines default behavior for all languages. You can overwrite the default settings with language-specific properties. For example we define hide_untranslated as False globally, but the English language overwrites this behavior.

Every language node needs at least a code and a name property. code is the ISO 2 code for the language, and name is the verbose name of the language.

What are the properties a language node can have?

Unicode support for automated slugs¶

django CMS supports automated slug generation from page titles that contain unicode characters via the unihandecode.js project. To enable support for unihandecode.js, at least CMS_UNIHANDECODE_HOST and CMS_UNIHANDECODE_VERSION must be set.

CMS_UNIHANDECODE_HOST = '/static/unihandecode/'
CMS_UNIHANDECODE_VERSION = '1.0.0'
CMS_UNIHANDECODE_DECODERS = ['ja', 'zh', 'vn', 'kr', 'diacritic']

project/
    static/
        unihandecode/
            unihandecode-1.0.0.core.min.js
            unihandecode-1.0.0.diacritic.min.js
            unihandecode-1.0.0.ja.min.js
            unihandecode-1.0.0.kr.min.js
            unihandecode-1.0.0.vn.min.js
            unihandecode-1.0.0.zh.min.js

CMS_MEDIA_PATH¶

default

cms/

The path from MEDIA_ROOT to the media files located in cms/media/

CMS_MEDIA_ROOT¶

default

MEDIA_ROOT + CMS_MEDIA_PATH

The path to the media root of the cms media files.

CMS_MEDIA_URL¶

default

MEDIA_URL + CMS_MEDIA_PATH

The location of the media files that are located in cms/media/cms/

CMS_PAGE_MEDIA_PATH¶

default

'cms_page_media/'

By default, django CMS creates a folder called cms_page_media in your static files folder where all uploaded media files are stored. The media files are stored in subfolders numbered with the id of the page.

You need to ensure that the directory to which it points is writable by the user under which Django will be running.

CMS_PERMISSION¶

default

False

When enabled, 3 new models are provided in Admin:

• Pages global permissions
• User groups - page
• Users - page

In the edit-view of the pages you can now assign users to pages and grant them permissions. In the global permissions you can set the permissions for users globally.

If a user has the right to create new users he can now do so in the “Users - page”, but he will only see the users he created. The users he created can also only inherit the rights he has. So if he only has been granted the right to edit a certain page all users he creates can, in turn, only edit this page. Naturally he can limit the rights of the users he creates even further, allowing them to see only a subset of the pages to which he is allowed access.

CMS_RAW_ID_USERS¶

default

False

This setting only applies if CMS_PERMISSION is True

The view restrictions and page permissions inlines on the cms.models.Page admin change forms can cause performance problems where there are many thousands of users being put into simple select boxes. If set to a positive integer, this setting forces the inlines on that page to use standard Django admin raw ID widgets rather than select boxes if the number of users in the system is greater than that number, dramatically improving performance.

CMS_PUBLIC_FOR¶

default

all

Determines whether pages without any view restrictions are public by default or staff only. Possible values are all and staff.

CMS_CACHE_DURATIONS¶

This dictionary carries the various cache duration settings.

CMS_CACHE_PREFIX¶

default

cms-

The CMS will prepend the value associated with this key to every cache access (set and get). This is useful when you have several django CMS installations, and you don’t want them to share cache objects.

Example:

CMS_CACHE_PREFIX = 'mysite-live'

CMS_PAGE_CACHE¶

default

True

Should the output of pages be cached? Takes the language, and timezone into account. Pages for logged in users are not cached. If the toolbar is visible the page is not cached as well.

CMS_PLACEHOLDER_CACHE¶

default

True

Should the output of the various placeholder templatetags be cached? Takes the current language and timezone into account. If the toolbar is in edit mode or a plugin with cache=False is present the placeholders will not be cached.

CMS_PLUGIN_CACHE¶

default

True

Default value of the cache attribute of plugins. Should plugins be cached by default if not set explicitly?

CMS_MAX_PAGE_HISTORY_REVERSIONS¶

default

15

Configures how many undo steps are saved in the db excluding publish steps. In the page admin there is a History button to revert to previous version of a page. In the past, databases using django-reversion could grow huge. To help address this issue, only a limited number of edit revisions will now be saved.

This setting declares how many edit revisions are saved in the database. By default the newest 15 edit revisions are kept.

CMS_MAX_PAGE_PUBLISH_REVERSIONS¶

default

10

If django-reversion is installed everything you do with a page and all plugin changes will be saved in a revision.

In the page admin there is a History button to revert to previous version of a page. In the past, databases using django-reversion could grow huge. To help address this issue, only a limited number of published revisions will now be saved.

This setting declares how many published revisions are saved in the database. By default the newest 10 published revisions are kept; all others are deleted when you publish a page.

If set to 0 all published revisions are kept, but you will need to ensure that the revision table does not grow excessively large.

CMS_TOOLBARS¶

default

None

If defined, specifies the list of toolbar modifiers to be used to populate the toolbar as import paths. Otherwise, all available toolbars from both the CMS and the 3rd party apps will be loaded.

Example:

CMS_TOOLBARS = [
    # CMS Toolbars
    'cms.cms_toolbar.PlaceholderToolbar',
    'cms.cms_toolbar.BasicToolbar',
    'cms.cms_toolbar.PageToolbar',

    # 3rd Party Toolbar
    'aldryn_blog.cms_toolbar.BlogToolbar',
]

CMS_TOOLBAR_ANONYMOUS_ON¶

default

True

This setting controls if anonymous users can see the CMS toolbar with a login form when ?edit is appended to a URL. The default behaviour is to show the toolbar to anonymous users.

CMS_TOOLBAR_HIDE¶

default

False

If True, the toolbar is hidden in the pages out django CMS. To determine the internal url of django cms, you need to assign CMS_APP_NAME to use when you include 'cms.urls'

Example:

urlpatterns += i18n_patterns('',
    url(r'^admin/', include(admin.site.urls)),
    url(r'^content/', include('cms.urls', app_name=settings.CMS_APP_NAME)),
)

CMS_DEFAULT_X_FRAME_OPTIONS¶

default

Page.X_FRAME_OPTIONS_INHERIT

This setting is the default value for a Page’s X Frame Options setting. This should be an integer preferably taken from the Page object e.g.

• X_FRAME_OPTIONS_INHERIT
• X_FRAME_OPTIONS_ALLOW
• X_FRAME_OPTIONS_SAMEORIGIN
• X_FRAME_OPTIONS_DENY