Django для начинающих: как создать блог с нуля до продвинутого уровня?

# Установка virtualenv (если еще не установлен)
pip install virtualenv

# Создание виртуального окружения
python -m venv venv

# Активация виртуального окружения
# Windows
.\venv\Scripts\activate
# macOS/Linux
source venv/bin/activate

# Установка Django
pip install django

django-admin startproject blog_project .

python manage.py startapp blog

# blog_project/settings.py
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'blog', # Добавляем наше приложение
]

# blog/models.py
from django.db import models
from django.contrib.auth.models import User
from django.utils import timezone

class Post(models.Model):
    """Модель для представления поста в блоге."""
    title: models.CharField = models.CharField(max_length=200, verbose_name="Заголовок")
    content: models.TextField = models.TextField(verbose_name="Содержимое")
    created_at: models.DateTimeField = models.DateTimeField(default=timezone.now, verbose_name="Дата создания")
    author: models.ForeignKey = models.ForeignKey(User, on_delete=models.CASCADE, verbose_name="Автор")
    is_published: models.BooleanField = models.BooleanField(default=True, verbose_name="Опубликовано")

    class Meta:
        verbose_name = "Пост"
        verbose_name_plural = "Посты"
        ordering = ['-created_at'] # Сортировка по умолчанию

    def __str__(self) -> str:
        """Строковое представление объекта модели."""
        return self.title

python manage.py makemigrations blog
python manage.py migrate

# blog/models.py
# ... (импорты и модель Post остаются)

class Category(models.Model):
    """Модель для категорий постов."""
    name: models.CharField = models.CharField(max_length=100, unique=True, verbose_name="Название")
    slug: models.SlugField = models.SlugField(max_length=100, unique=True, verbose_name="URL slug")

    class Meta:
        verbose_name = "Категория"
        verbose_name_plural = "Категории"

    def __str__(self) -> str:
        return self.name

class Tag(models.Model):
    """Модель для тегов постов."""
    name: models.CharField = models.CharField(max_length=100, unique=True, verbose_name="Название")
    slug: models.SlugField = models.SlugField(max_length=100, unique=True, verbose_name="URL slug")

    class Meta:
        verbose_name = "Тег"
        verbose_name_plural = "Теги"

    def __str__(self) -> str:
        return self.name

class Post(models.Model):
    """Модель для представления поста в блоге (обновленная)."""
    title: models.CharField = models.CharField(max_length=200, verbose_name="Заголовок")
    content: models.TextField = models.TextField(verbose_name="Содержимое")
    created_at: models.DateTimeField = models.DateTimeField(default=timezone.now, verbose_name="Дата создания")
    updated_at: models.DateTimeField = models.DateTimeField(auto_now=True, verbose_name="Дата обновления")
    author: models.ForeignKey = models.ForeignKey(User, on_delete=models.CASCADE, related_name='blog_posts', verbose_name="Автор")
    category: models.ForeignKey = models.ForeignKey(Category, on_delete=models.SET_NULL, null=True, blank=True, related_name='posts', verbose_name="Категория")
    tags: models.ManyToManyField = models.ManyToManyField(Tag, blank=True, related_name='posts', verbose_name="Теги")
    is_published: models.BooleanField = models.BooleanField(default=True, verbose_name="Опубликовано")
    slug: models.SlugField = models.SlugField(max_length=200, unique_for_date='created_at', verbose_name="URL slug") # Уникальный slug для даты

    class Meta:
        verbose_name = "Пост"
        verbose_name_plural = "Посты"
        ordering = ['-created_at']

    def __str__(self) -> str:
        return self.title

    # Можно добавить метод get_absolute_url здесь для удобства
    # from django.urls import reverse
    # def get_absolute_url(self):
    #     return reverse('blog:post_detail', args=[self.created_at.year, self.created_at.month, self.created_at.day, self.slug])

python manage.py makemigrations blog
python manage.py migrate

# blog/views.py
from django.shortcuts import render, get_object_or_404
from django.views.generic import ListView, DetailView
from typing import Any
from .models import Post, Category, Tag # Убедитесь, что модели импортированы

class PostListView(ListView):
    """Представление для отображения списка опубликованных постов."""
    model = Post
    template_name = 'blog/post_list.html' # Путь к шаблону
    context_object_name = 'posts' # Имя переменной в шаблоне
    paginate_by = 5 # Количество постов на странице

    def get_queryset(self):
        """Возвращает только опубликованные посты."""
        return Post.objects.filter(is_published=True).select_related('author', 'category').prefetch_related('tags')

    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
        """Добавляет категории и теги в контекст."""
        context = super().get_context_data(**kwargs)
        context['categories'] = Category.objects.all()
        context['tags'] = Tag.objects.all()
        return context

class PostDetailView(DetailView):
    """Представление для отображения детальной информации о посте."""
    model = Post
    template_name = 'blog/post_detail.html'
    context_object_name = 'post'
    # slug_url_kwarg = 'slug' # Имя параметра slug из URL
    # pk_url_kwarg = 'pk' # Имя параметра pk из URL (если используется)

    def get_queryset(self):
        """Возвращает только опубликованные посты, оптимизирует запросы."""
        # Используем slug и дату для поиска, если URL настроен соответствующе
        # или просто pk/slug если URL проще
        return Post.objects.filter(is_published=True).select_related('author', 'category').prefetch_related('tags')

    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
        """Добавляет категории и теги в контекст."""
        context = super().get_context_data(**kwargs)
        context['categories'] = Category.objects.all()
        context['tags'] = Tag.objects.all()
        return context

# Можно добавить представления для постов по категориям и тегам
class PostsByCategoryView(ListView):
    model = Post
    template_name = 'blog/post_list.html'
    context_object_name = 'posts'
    paginate_by = 5

    def get_queryset(self):
        category_slug = self.kwargs.get('category_slug')
        category = get_object_or_404(Category, slug=category_slug)
        return Post.objects.filter(category=category, is_published=True).select_related('author', 'category').prefetch_related('tags')

    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
        context = super().get_context_data(**kwargs)
        context['categories'] = Category.objects.all()
        context['tags'] = Tag.objects.all()
        context['current_category'] = get_object_or_404(Category, slug=self.kwargs.get('category_slug'))
        return context

class PostsByTagView(ListView):
    model = Post
    template_name = 'blog/post_list.html'
    context_object_name = 'posts'
    paginate_by = 5

    def get_queryset(self):
        tag_slug = self.kwargs.get('tag_slug')
        tag = get_object_or_404(Tag, slug=tag_slug)
        return Post.objects.filter(tags=tag, is_published=True).select_related('author', 'category').prefetch_related('tags')

    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
        context = super().get_context_data(**kwargs)
        context['categories'] = Category.objects.all()
        context['tags'] = Tag.objects.all()
        context['current_tag'] = get_object_or_404(Tag, slug=self.kwargs.get('tag_slug'))
        return context

# blog/urls.py
from django.urls import path
from .views import (PostListView, PostDetailView, PostsByCategoryView, PostsByTagView)

app_name = 'blog' # Пространство имен для URL'ов приложения

urlpatterns = [
    path('', PostListView.as_view(), name='post_list'),
    # Пример URL с использованием slug
    path('post/<slug:slug>/', PostDetailView.as_view(), name='post_detail'),
    # Пример URL с использованием категории
    path('category/<slug:category_slug>/', PostsByCategoryView.as_view(), name='posts_by_category'),
    # Пример URL с использованием тега
    path('tag/<slug:tag_slug>/', PostsByTagView.as_view(), name='posts_by_tag'),
    # Альтернативный URL для детального поста (если slug не уникален без даты)
    # path('<int:year>/<int:month>/<int:day>/<slug:slug>/', PostDetailView.as_view(), name='post_detail_dated'),
]

# blog_project/urls.py
from django.contrib import admin
from django.urls import path, include # Импортируем include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('blog.urls', namespace='blog')), # Подключаем URL'ы приложения blog
]

<!-- blog/templates/blog/base.html -->
<!DOCTYPE html>
<html lang="ru">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{% block title %}Мой Блог{% endblock %}</title>
    <!-- Подключение CSS (например, Bootstrap) -->
</head>
<body>
    <header>
        <h1><a href="{% url 'blog:post_list' %}">Мой Блог на Django</a></h1>
        <!-- Навигация, если нужна -->
    </header>

    <div class="container">
        <div class="sidebar">
            <h2>Категории</h2>
            <ul>
                {% for category in categories %}
                <li><a href="{% url 'blog:posts_by_category' category.slug %}">{{ category.name }}</a></li>
                {% empty %}
                <li>Категорий пока нет.</li>
                {% endfor %}
            </ul>
             <h2>Теги</h2>
            <p>
                {% for tag in tags %}
                <a href="{% url 'blog:posts_by_tag' tag.slug %}" class="tag">#{{ tag.name }}</a>
                {% empty %}
                <span>Тегов пока нет.</span>
                {% endfor %}
            </p>
        </div>
        <main>
            {% block content %}
            <!-- Основной контент страницы -->
            {% endblock %}
        </main>
    </div>

    <footer>
        <p>© {% now "Y" %} Мой Блог</p>
    </footer>
</body>
</html>

<!-- blog/templates/blog/post_list.html -->
{% extends 'blog/base.html' %}

{% block title %}
    {% if current_category %}
        Посты в категории: {{ current_category.name }}
    {% elif current_tag %}
        Посты с тегом: #{{ current_tag.name }}
    {% else %}
        Последние посты
    {% endif %}
{% endblock %}

{% block content %}
    {% if current_category %}
        <h2>Посты в категории: {{ current_category.name }}</h2>
    {% elif current_tag %}
        <h2>Посты с тегом: #{{ current_tag.name }}</h2>
    {% else %}
        <h2>Последние посты</h2>
    {% endif %}

    {% for post in posts %}
        <article>
            <h3><a href="{% url 'blog:post_detail' post.slug %}">{{ post.title }}</a></h3>
            <p>Автор: {{ post.author.username }} | Дата: {{ post.created_at|date:"d.m.Y H:i" }}</p>
            {% if post.category %}
                <p>Категория: <a href="{% url 'blog:posts_by_category' post.category.slug %}">{{ post.category.name }}</a></p>
            {% endif %}
            <div>{{ post.content|truncatewords:30|linebreaks }}</div> {# Краткое содержание #}
             {% if post.tags.all %}
                <p>Теги: 
                {% for tag in post.tags.all %}
                    <a href="{% url 'blog:posts_by_tag' tag.slug %}">#{{ tag.name }}</a> 
                {% endfor %}
                </p>
            {% endif %}
        </article>
        <hr>
    {% empty %}
        <p>Постов пока нет.</p>
    {% endfor %}

    {% include 'blog/includes/pagination.html' %} {# Пагинация #}

{% endblock %}

<!-- blog/templates/blog/post_detail.html -->
{% extends 'blog/base.html' %}

{% block title %}{{ post.title }}{% endblock %}

{% block content %}
    <article>
        <h2>{{ post.title }}</h2>
        <p>Автор: {{ post.author.username }} | Дата: {{ post.created_at|date:"d.m.Y H:i" }}</p>
        {% if post.category %}
            <p>Категория: <a href="{% url 'blog:posts_by_category' post.category.slug %}">{{ post.category.name }}</a></p>
        {% endif %}
        <div>{{ post.content|linebreaks }}</div> {# Полное содержание #}
        {% if post.tags.all %}
            <p>Теги: 
            {% for tag in post.tags.all %}
                <a href="{% url 'blog:posts_by_tag' tag.slug %}">#{{ tag.name }}</a> 
            {% endfor %}
            </p>
        {% endif %}
    </article>

    <hr>
    {# Здесь будет раздел комментариев #}

{% endblock %}

<!-- blog/templates/blog/includes/pagination.html -->
{% if is_paginated %}
<div class="pagination">
    <span class="step-links">
        {% if page_obj.has_previous %}
            <a href="?page=1">« первая</a>
            <a href="?page={{ page_obj.previous_page_number }}">предыдущая</a>
        {% endif %}

        <span class="current">
            Страница {{ page_obj.number }} из {{ page_obj.paginator.num_pages }}.
        </span>

        {% if page_obj.has_next %}
            <a href="?page={{ page_obj.next_page_number }}">следующая</a>
            <a href="?page={{ page_obj.paginator.num_pages }}">последняя »</a>
        {% endif %}
    </span>
</div>
{% endif %}

# blog/admin.py
from django.contrib import admin
from .models import Post, Category, Tag

# Простая регистрация
# admin.site.register(Post)
# admin.site.register(Category)
# admin.site.register(Tag)

# Регистрация с настройками отображения
@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    list_display: tuple[str, ...] = ('title', 'author', 'category', 'created_at', 'is_published', 'tag_list') # Отображаемые поля в списке
    list_filter: tuple[str, ...] = ('is_published', 'created_at', 'author', 'category', 'tags') # Фильтры
    search_fields: tuple[str, ...] = ('title', 'content') # Поля для поиска
    prepopulated_fields: dict[str, tuple[str]] = {'slug': ('title',)} # Автозаполнение slug на основе title
    date_hierarchy: str = 'created_at' # Навигация по дате
    ordering: tuple[str, ...] = ('-created_at', 'is_published') # Сортировка по умолчанию
    list_editable: tuple[str, ...] = ('is_published',) # Редактируемые поля в списке
    readonly_fields: tuple[str, ...] = ('created_at', 'updated_at') # Поля только для чтения в форме
    # Оптимизация запросов в админке
    list_select_related: tuple[str, ...] = ('author', 'category')
    autocomplete_fields: tuple[str, ...] = ('tags',)

    def get_queryset(self, request):
        # Оптимизация для ManyToMany
        return super().get_queryset(request).prefetch_related('tags')

    def tag_list(self, obj: Post) -> str:
        """Отображает теги в списке постов."""
        return ", ".join(t.name for t in obj.tags.all())
    tag_list.short_description = 'Теги' # Название колонки

@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
    list_display: tuple[str, ...] = ('name', 'slug')
    prepopulated_fields: dict[str, tuple[str]] = {'slug': ('name',)}
    search_fields: tuple[str, ...] = ('name',)

@admin.register(Tag)
class TagAdmin(admin.ModelAdmin):
    list_display: tuple[str, ...] = ('name', 'slug')
    prepopulated_fields: dict[str, tuple[str]] = {'slug': ('name',)}
    search_fields: tuple[str, ...] = ('name',)
    # Важно для autocomplete_fields в PostAdmin
    search_fields = ['name']

# blog/models.py
# ... (импорты и другие модели)

class Comment(models.Model):
    """Модель для комментариев к постам."""
    post: models.ForeignKey = models.ForeignKey(Post, on_delete=models.CASCADE, related_name='comments', verbose_name="Пост")
    author_name: models.CharField = models.CharField(max_length=80, verbose_name="Имя автора") # Или ForeignKey на User, если комментируют только залогиненные
    email: models.EmailField = models.EmailField(verbose_name="Email") # Опционально
    body: models.TextField = models.TextField(verbose_name="Текст комментария")
    created_at: models.DateTimeField = models.DateTimeField(auto_now_add=True, verbose_name="Дата создания")
    is_active: models.BooleanField = models.BooleanField(default=True, verbose_name="Активен") # Для модерации

    class Meta:
        verbose_name = "Комментарий"
        verbose_name_plural = "Комментарии"
        ordering = ['created_at']

    def __str__(self) -> str:
        return f'Комментарий от {self.author_name} к посту "{self.post.title}"'

# blog/forms.py
from django import forms
from .models import Comment

class CommentForm(forms.ModelForm):
    """Форма для добавления комментариев."""
    class Meta:
        model = Comment
        fields: tuple[str, ...] = ('author_name', 'email', 'body')
        widgets = {
            'author_name': forms.TextInput(attrs={'placeholder': 'Ваше имя'}),
            'email': forms.EmailInput(attrs={'placeholder': 'Ваш email (не будет опубликован)'}),
            'body': forms.Textarea(attrs={'rows': 4, 'placeholder': 'Ваш комментарий'}),
        }

# blog/views.py
from django.shortcuts import render, get_object_or_404, redirect
from django.views import View
from django.views.generic import ListView, DetailView
from django.views.generic.edit import FormMixin # Добавляем FormMixin
from .models import Post, Comment, Category, Tag
from .forms import CommentForm
from typing import Any

# ... (PostListView и другие представления) ...

class PostDetailView(FormMixin, DetailView): # Добавляем FormMixin
    model = Post
    template_name = 'blog/post_detail.html'
    context_object_name = 'post'
    form_class = CommentForm # Указываем класс формы

    def get_queryset(self):
        return Post.objects.filter(is_published=True).select_related('author', 'category').prefetch_related('tags', 'comments') # Добавляем comments

    def get_success_url(self) -> str:
        """URL для редиректа после успешной отправки формы."""
        return self.request.path # Возвращаемся на ту же страницу поста

    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
        context = super().get_context_data(**kwargs)
        post = self.get_object()
        context['comments'] = post.comments.filter(is_active=True)
        context['comment_form'] = self.get_form() # Добавляем форму в контекст
        context['categories'] = Category.objects.all()
        context['tags'] = Tag.objects.all()
        return context

    def post(self, request, *args, **kwargs):
        """Обрабатывает POST-запрос (отправку формы комментария)."""
        self.object = self.get_object()
        form = self.get_form()
        if form.is_valid():
            return self.form_valid(form)
        else:
            return self.form_invalid(form)

    def form_valid(self, form):
        """Сохраняет комментарий, если форма валидна."""
        comment = form.save(commit=False)
        comment.post = self.object
        # Если нужна привязка к пользователю:
        # if self.request.user.is_authenticated:
        #     comment.author = self.request.user
        #     comment.author_name = self.request.user.username
        #     comment.email = self.request.user.email
        comment.save()
        return super().form_valid(form)

<!-- blog/templates/blog/post_detail.html -->
{% extends 'blog/base.html' %}

{# ... (остальная часть шаблона) ... #}

<hr>
<section class="comments">
    <h3>Комментарии ({{ comments.count }})</h3>
    {% for comment in comments %}
        <div class="comment">
            <p><strong>{{ comment.author_name }}</strong> ({{ comment.created_at|date:"d.m.Y H:i" }})</p>
            <p>{{ comment.body|linebreaks }}</p>
        </div>
    {% empty %}
        <p>Комментариев пока нет. Станьте первым!</p>
    {% endfor %}

    <h4>Добавить комментарий</h4>
    <form method="post">
        {% csrf_token %}
        {{ comment_form.as_p }}
        <button type="submit">Отправить</button>
    </form>
</section>

{% endblock %}

# blog/views.py
from django.db.models import Q
# ... (другие импорты)

class SearchView(ListView):
    """Представление для поиска постов."""
    model = Post
    template_name = 'blog/search_results.html'
    context_object_name = 'results'
    paginate_by = 10

    def get_queryset(self):
        query = self.request.GET.get('q')
        if query:
            # Ищем по заголовку ИЛИ содержимому (регистронезависимо)
            return Post.objects.filter(
                Q(title__icontains=query) | Q(content__icontains=query),
                is_published=True
            ).select_related('author', 'category').prefetch_related('tags')
        return Post.objects.none() # Если запроса нет, возвращаем пустой QuerySet

    def get_context_data(self, **kwargs: Any) -> dict[str, Any]:
        context = super().get_context_data(**kwargs)
        context['query'] = self.request.GET.get('q', '')
        # Можно добавить категории и теги для боковой панели, если нужно
        # context['categories'] = Category.objects.all()
        # context['tags'] = Tag.objects.all()
        return context

# blog/urls.py
# ...
path('search/', SearchView.as_view(), name='search'),
# ...

<!-- blog/templates/blog/base.html (пример формы поиска) -->
<form method="get" action="{% url 'blog:search' %}">
    <input type="search" name="q" placeholder="Поиск по блогу..." value="{{ request.GET.q }}">
    <button type="submit">Найти</button>
</form>

<!-- blog/templates/blog/search_results.html -->
{% extends 'blog/base.html' %}

{% block title %}Результаты поиска по запросу "{{ query }}"{% endblock %}

{% block content %}
    <h2>Результаты поиска по запросу "{{ query }}"</h2>

    {% if results %}
        {% for post in results %}
            <article>
                <h3><a href="{% url 'blog:post_detail' post.slug %}">{{ post.title }}</a></h3>
                <p>Автор: {{ post.author.username }} | Дата: {{ post.created_at|date:"d.m.Y H:i" }}</p>
                <div>{{ post.content|truncatewords_html:40|safe }}</div> {# Используем truncatewords_html для безопасности #}
            </article>
            <hr>
        {% endfor %}
        {% include 'blog/includes/pagination.html' with page_obj=page_obj is_paginated=is_paginated %}
    {% else %}
        <p>По вашему запросу ничего не найдено.</p>
    {% endif %}
{% endblock %}

server {
    listen 80;
    server_name your_domain.com www.your_domain.com;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /path/to/your/project/staticfiles; # Путь, указанный в STATIC_ROOT
    }
    location /media/ {
        root /path/to/your/project/media; # Путь, указанный в MEDIA_ROOT
    }

    location / {
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_pass http://unix:/path/to/your/project/gunicorn.sock; # Путь к сокету Gunicorn
        # или proxy_pass http://127.0.0.1:8000; # если Gunicorn слушает порт
    }
}