Django REST Framework: Как работать с фильтрами, формами и шаблоном does_not_exist?

# settings.py
REST_FRAMEWORK = {
    'DEFAULT_FILTER_BACKENDS': [
        'django_filters.rest_framework.DjangoFilterBackend',
        'rest_framework.filters.SearchFilter',
        'rest_framework.filters.OrderingFilter',
    ],
    # ... другие настройки
}

# views.py
from rest_framework import generics
from .models import AdCampaign
from .serializers import AdCampaignSerializer
from django_filters.rest_framework import DjangoFilterBackend
from rest_framework.filters import SearchFilter, OrderingFilter

class AdCampaignListView(generics.ListAPIView):
    """Представление для списка рекламных кампаний с фильтрацией и сортировкой."""
    queryset = AdCampaign.objects.all()
    serializer_class = AdCampaignSerializer
    filter_backends = [DjangoFilterBackend, SearchFilter, OrderingFilter]
    filterset_fields = ['status', 'budget']  # Поля для точной фильтрации
    search_fields = ['name', 'description']  # Поля для поиска
    ordering_fields = ['name', 'budget', 'start_date'] # Поля для сортировки
    ordering = ['-start_date'] # Сортировка по умолчанию

# filters.py
import django_filters
from .models import AdCampaign
from typing import List

class AdCampaignFilter(django_filters.FilterSet):
    """Набор фильтров для модели AdCampaign."""
    min_budget = django_filters.NumberFilter(field_name="budget", lookup_expr='gte')
    max_budget = django_filters.NumberFilter(field_name="budget", lookup_expr='lte')
    start_date_after = django_filters.DateFilter(field_name="start_date", lookup_expr='gte')
    active_within_dates = django_filters.DateFromToRangeFilter(field_name="start_date") # Пример сложного фильтра

    class Meta:
        model = AdCampaign
        fields: List[str] = ['status', 'name'] # Можно указать базовые поля здесь

# views.py
class AdCampaignListView(generics.ListAPIView):
    # ...
    filterset_class = AdCampaignFilter # Используем кастомный FilterSet
    # filterset_fields убираем или оставляем для базовых полей, не описанных в AdCampaignFilter

# serializers.py
from rest_framework import serializers
from .models import AdCampaign
from typing import Dict, Any

class AdCampaignSerializer(serializers.ModelSerializer):
    """Сериализатор для модели AdCampaign."""
    class Meta:
        model = AdCampaign
        fields: List[str] = ['id', 'name', 'budget', 'status', 'start_date', 'end_date', 'description']
        read_only_fields: List[str] = ['id'] # Поля только для чтения

    def validate_budget(self, value: float) -> float:
        """Пример кастомной валидации поля budget."""
        if value  Dict[str, Any]:
        """Пример валидации на уровне всего объекта."""
        if data.get('start_date') and data.get('end_date') and data['start_date'] > data['end_date']:
            raise serializers.ValidationError("Дата начала не может быть позже даты окончания.")
        return data

# views.py
from rest_framework import viewsets
from rest_framework.response import Response
from rest_framework import status
from typing import Any

class AdCampaignViewSet(viewsets.ModelViewSet):
    """ViewSet для управления рекламными кампаниями."""
    queryset = AdCampaign.objects.all()
    serializer_class = AdCampaignSerializer
    filter_backends = [DjangoFilterBackend]
    filterset_class = AdCampaignFilter

    def perform_create(self, serializer: AdCampaignSerializer) -> None:
        """Кастомизация процесса создания объекта."""
        # Можно добавить дополнительную логику перед сохранением
        # Например, связать с текущим пользователем (если аутентификация настроена)
        # serializer.save(owner=self.request.user)
        serializer.save()

    def create(self, request: Any, *args: Any, **kwargs: Any) -> Response:
        """Обработка POST-запроса для создания кампании."""
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True) # Валидация данных
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

    # Методы update, partial_update и т.д. работают аналогично

# Нетипичный случай: рендеринг сериализатора как формы в Django шаблоне
# views.py (Django view, не DRF)
from django.shortcuts import render
from .serializers import AdCampaignSerializer

def campaign_add_view(request):
    serializer = AdCampaignSerializer() # Пустой сериализатор для рендеринга
    # Логика обработки POST (если форма сабмитится на этот же view)
    return render(request, 'campaign_form.html', {'serializer': serializer})

# templates/campaign_form.html

    {% csrf_token %}
    {% for field in serializer %}
        

            {{ field.label_tag }} {{ field }}
            {% if field.help_text %}
            
{{ field.help_text|safe }}
            {% endif %}
            {{ field.errors }}
        
    {% endfor %}
    Save Campaign

# settings.py
import os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')], # Основная директория шаблонов
        'APP_DIRS': True, # Искать шаблоны в директориях приложений (app/templates/)
        'OPTIONS': {
            'context_processors': [
                # ... стандартные процессоры
            ],
        },
    },
]

    Статус:
    
        Любой
        Активна
        На паузе
        Завершена
    

    Мин. бюджет:
    

    Сортировка:
    
        По имени (А-Я)
        По имени (Я-А)
        По бюджету (возр.)
        По бюджету (убыв.)
    

    Фильтровать

# models.py
class Category(models.Model):
    name = models.CharField(max_length=100)

class Product(models.Model):
    name = models.CharField(max_length=200)
    category = models.ForeignKey(Category, on_delete=models.CASCADE)
    price = models.DecimalField(max_digits=10, decimal_places=2)

# filters.py
import django_filters
from .models import Product

class ProductFilter(django_filters.FilterSet):
    min_price = django_filters.NumberFilter(field_name="price", lookup_expr='gte')
    max_price = django_filters.NumberFilter(field_name="price", lookup_expr='lte')
    category_name = django_filters.CharFilter(field_name='category__name', lookup_expr='icontains')

    class Meta:
        model = Product
        fields = ['category'] # Можно фильтровать по ID категории

# views.py
class ProductListView(generics.ListAPIView):
    queryset = Product.objects.select_related('category').all()
    serializer_class = ProductSerializer # Определите сериализатор ProductSerializer
    filter_backends = [DjangoFilterBackend]
    filterset_class = ProductFilter

# models.py
class Comment(models.Model):
    author = models.CharField(max_length=100)
    text = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)
    parent_campaign = models.ForeignKey(AdCampaign, related_name='comments', on_delete=models.CASCADE)

# serializers.py
class CommentSerializer(serializers.ModelSerializer):
    author = serializers.CharField(max_length=100, required=True)
    text = serializers.CharField(required=True)

    class Meta:
        model = Comment
        fields = ['id', 'author', 'text', 'created_at', 'parent_campaign']
        read_only_fields = ['id', 'created_at']
        extra_kwargs = {
            'parent_campaign': {'write_only': True, 'required': True} # Не показываем в ответе, но требуем при создании
        }

    def validate_text(self, value: str) -> str:
        if len(value) < 5:
            raise serializers.ValidationError("Комментарий слишком короткий.")
        # Проверка на нецензурную лексику (пример)
        # if contains_profanity(value):
        #    raise serializers.ValidationError("Комментарий содержит недопустимые слова.")
        return value

# views.py
class CommentCreateView(generics.CreateAPIView):
    serializer_class = CommentSerializer
    # queryset не нужен для CreateAPIView

    # Можно переопределить perform_create для дополнительной логики,
    # например, чтобы убедиться, что parent_campaign существует или доступен пользователю.