Django cms установка на windows

Setup Docker (Step 1)¶

Install docker from here. If you have not used
docker in the past, please read this introduction on docker.

Run the demo project in docker (Step 2)¶

Info: The demo project is a
minimal Django project with some additional requirements in the requirements.txt.

For more details see its Open the terminal application on your computer and go to a safe
folder (i.e. cd ~/Projects), then

git clone git@github.com:django-cms/django-cms-quickstart.git

cd django-cms-quickstart
docker compose build web
docker compose up -d database_default
docker compose run web python manage.py migrate
docker compose run web python manage.py createsuperuser
docker compose up -d

During the installation process, you will be prompted to enter your email address and
set a username and password. Open your browser and insert
http://localhost:8000/admin there you should be invited to login and continue with
Step 3: create your first page

Create your first page (Step 3)¶

• Once you login you can press Create on the top right.

• Then you will see a pop-up window where the “New page” is marked blue.

• Press New Page and select Next.

Картинка с сайта: docs.django-cms.org

After selecting Next, you will add in your title and some basic text content for the new
page, click Create.

Картинка с сайта: docs.django-cms.org

Here is your newly created page.

Publish your first page (Step 4)¶

The page we just created is just a draft and needs to be published once you finish. As
an editor, only you can see and edit your drafts, other visitors to your site will only
see your published pages.

Press “Publish”

Картинка с сайта: docs.django-cms.org

To edit the page, you can switch back into editing mode using the “Edit” button, and
return to the published version of the page using the “view published” button.

In the editing mode, you can double-click on the paragraph of the text to change it, add
formatting, and save it again. Any changes that are made after publishing are saved to a
draft and will not be visible until you re-publish.

Congratulations, you now have installed django CMS and created your first page.

If you need to log in at any time, append ?toolbar_on to the URL and hit Return.
This will enable the toolbar, from where you can log in and manage your website.

Install the django CMS package (Step 1)¶

Check the Python/Django requirements for this version of django
CMS.

django CMS also has other requirements, which it lists as dependencies in its
setup.py.

python3 -m venv .venv  # create a virtualenv
source .venv/bin/activate  # activate it
pip install --upgrade pip  # Upgrade pip

Then:

to install the release candidate version of django CMS. It will also install its
dependencies including Django.

Create a new django CMS project (Step 2)¶

Create a new django CMS project:

This is a shortcut command for creating a new Django project with the right project
template. It performs the following five steps in one simple go:

1. It creates a new Django project:

   django-admin startproject myproject --template https://github.com/django-cms/cms-template/archive/4.1.tar.gz
   

   If django-admin startproject is new to you, you ought to read the official
   Django tutorial, which
   covers starting a new project.

2. It installs additional optional packages which are used in the template project.
   Those are

   • djangocms-text-ckeditor
     for rich text input.

   • djangocms-frontend for
     Bootstrap5 support.

   • django-filer for managing media
     files like images.

   • djangocms-versioning for
     publishing and version management,

   • djangocms-alias for managing
     common content parts such as footers.

   • djangocms_admin_style for
     a consistent user experience with django CMS and Django admin.

3. It changes into the project directory and runs the migrate command to create the
   database:

4. It prompts for creating a superuser by invoking:

   python -m manage createsuperuser
   

5. It runs the django CMS check command to verify the installation is consistent:

   python -m manage cms check
   

Your new project will look like this:

myproject/
    LICENSE
    README.md
    db.sqlite3
    myproject/
        static/
        templates/
            base.html
        __init__.py
        asgi.py
        settings.py
        urls.py
        wsgi.py
    manage.py
    requirements.in

The LICENSE and README.md files are not needed and can be deleted or replaced by
appropriate files for your project.

requirements.in contains dependencies for the project. Add your dependencies here.
We suggest to use pip-compile to freeze your requirements as, for example, discussed in
this blog post.

Spin up your Django development server (Step 3)¶

Now you are ready to spin up Django’s development server by first changing directory into
the project folder and then spinning up the development server:

cd myproject
python -m manage runserver

You can visit your project’s web site by pointing your browser to localhost:8000.

Use the newly created superuser’s credentials to authenticate and create your first
page!

Minimally-required applications and settings¶

To run django CMS you will only need to modify the settings.py and urls.py
files.

Open the new project’s settings.py file in your text editor.

"django.contrib.sites",
"cms",
"menus",
"treebeard",

LANGUAGES = [
    ("en", "English"),
    ("de", "German"),
    ("it", "Italian"),
]
LANGUAGE_CODE = "en"

pip install psycopg2     # for Postgres
pip install mysqlclient  # for MySQL or MariaDB

CMS_CONFIRM_VERSION4 = True

Sekizai¶

Django Sekizai is required by the CMS for
static files management. You need to have:

listed in INSTALLED_APPS, and:

"sekizai.context_processors.sekizai"

in the TEMPLATES['OPTIONS']['context_processors']:

TEMPLATES = [
    {
        ...
        "OPTIONS": {
            "context_processors": [
                ...
                "django.template.context_processors.i18n",
                "sekizai.context_processors.sekizai",
            ],
        },
    },
]

Middleware¶

in your MIDDLEWARE you’ll need
django.middleware.locale.LocaleMiddleware — it’s not installed in
Django projects by default.

Also add:

"django.middleware.locale.LocaleMiddleware",  # not installed by default

"cms.middleware.user.CurrentUserMiddleware",
"cms.middleware.page.CurrentPageMiddleware",
"cms.middleware.toolbar.ToolbarMiddleware",
"cms.middleware.language.LanguageCookieMiddleware",

to the list.

You can also add 'cms.middleware.utils.ApphookReloadMiddleware'. It’s not absolutely
necessary, but it’s useful. If included, should be at the
start of the list.

add the following configuration to your settings.py:

X_FRAME_OPTIONS = "SAMEORIGIN"

Context processors¶

Add "cms.context_processors.cms_settings" to
TEMPLATES['OPTIONS']['context_processors'].

Also add 'django.template.context_processors.i18n' if it’s not already present.

cms check should now be unable to identify any further issues with your project.
Some additional configuration is required however.

URLs¶

In the project’s urls.py, add path("", include("cms.urls")) to the
urlpatterns list, preferably as i18n_patterns. It should come after other
patterns, so that specific URLs for other applications can be detected first.

You’ll also need to have an import for django.urls.include. For example:

from django.conf.urls.i18n import i18n_patterns
from django.urls import include, path

urlpatterns = i18n_patterns(
    path("admin/", admin.site.urls),
    path("", include("cms.urls")),
)

The django CMS project will now run, as you’ll see if you launch it with python
manage.py runserver. You’ll be able to reach it at http://localhost:8000/, and the
admin at http://localhost:8000/admin/. You won’t yet actually be able to do anything
very useful with it though.

pip install djangocms-versioning
pip install djangocms-alias

"djangocms_versioning",
"djangocms_alias",

CMS_TEMPLATES = [
    ('home.html', 'Home page template'),
]

{% load cms_tags sekizai_tags %}
<html>
    <head>
        <title>{% page_attribute "page_title" %}</title>
        {% render_block "css" %}
    </head>
    <body>
        {% cms_toolbar %}
        {% placeholder "content" %}
        {% render_block "js" %}
    </body>
</html>

TEMPLATES = [
    {
        ...
        'DIRS': ['templates'],
        ...
    },
]

MEDIA_URL = "/media/"
MEDIA_ROOT = os.path.join(BASE_DIR, "media")

from django.conf import settings
from django.conf.urls.static import static

urlpatterns = [...] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

Using cms check for configuration¶

Once you have completed the minimum required set-up described above, you can use django
CMS’s built-in cms check command to help you identify and install other components.
Run:

python manage.py cms check

This will check your configuration, your applications and your database, and report on
any problems.

After each of the steps below run cms check to verify that you have resolved that
item in its checklist.

Adding content-handling functionality¶

You now have the basics set up for a django CMS site, which is able to manage and serve
up pages. However the project so far has no plugins installed, which means it has no way
of handling content in those pages. All content in django CMS is managed via plugins.
So, we now need to install some additional addon applications to provide plugins and
other functionality.

You don’t actually need to install any of these. django CMS doesn’t commit you to
any particular applications for content handling. The ones listed here however provide
key functionality and are strongly recommended.

pip install django-filer\>=3.0

'filer',
'easy_thumbnails',

THUMBNAIL_HIGH_RESOLUTION = True

THUMBNAIL_PROCESSORS = (
    'easy_thumbnails.processors.colorspace',
    'easy_thumbnails.processors.autocrop',
    'filer.thumbnail_processors.scale_and_crop_with_subject_location',
    'easy_thumbnails.processors.filters'
)

python manage.py migrate filer
python manage.py migrate easy_thumbnails

python manage.py migrate djangocms_text_ckeditor

INSTALLED_APPS = [
    ...,
    "easy_thumbnails",
    "djangocms_frontend",
    "djangocms_link",
    "djangocms_frontend.contrib.accordion",
    "djangocms_frontend.contrib.alert",
    "djangocms_frontend.contrib.badge",
    "djangocms_frontend.contrib.card",
    "djangocms_frontend.contrib.carousel",
    "djangocms_frontend.contrib.collapse",
    "djangocms_frontend.contrib.content",
    "djangocms_frontend.contrib.grid",
    "djangocms_frontend.contrib.image",
    "djangocms_frontend.contrib.jumbotron",
    "djangocms_frontend.contrib.link",
    "djangocms_frontend.contrib.listgroup",
    "djangocms_frontend.contrib.media",
    "djangocms_frontend.contrib.tabs",
    "djangocms_frontend.contrib.utilities",
    ...,
]

Miscellaneous plugins¶

There are plugins for django CMS that cover a vast range of functionality. To get
started, it’s useful to be able to rely on a set of well-maintained plugins that cover
some general content management needs.

• djangocms-file

• djangocms-picture

• djangocms-video

• djangocms-googlemap

• djangocms-snippet

• djangocms-style

To install:

pip install djangocms-file djangocms-picture djangocms-video djangocms-googlemap djangocms-snippet djangocms-style

and add:

"djangocms_file",
"djangocms_picture",
"djangocms_video",
"djangocms_googlemap",
"djangocms_snippet",
"djangocms_style",

to INSTALLED_APPS.

Then run migrations:

These and other plugins are described in more detail in Some commonly-used plugins.

Картинка с сайта: docs.django-cms.org