Django в боевом режиме: ежедневные лайфхаки, которые ускоряют разработку

# notes/models.py
from django.db import models
from django.contrib.auth import get_user_model

User = get_user_model()


class Tag(models.Model):
    name = models.CharField(max_length=30, unique=True)

    class Meta:
        indexes = [
            models.Index(fields=["name"], name="idx_tag_name"),
        ]

    def __str__(self):
        return self.name


class Note(models.Model):
    author = models.ForeignKey(User, on_delete=models.CASCADE, related_name="notes")
    title = models.CharField(max_length=200)
    body = models.TextField()
    created = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)
    tags = models.ManyToManyField(Tag, related_name="notes", blank=True)

    class Meta:
        indexes = [
            models.Index(fields=["-created"], name="idx_note_created_desc"),
            models.Index(
                name="idx_note_author_created",
                fields=["author", "-created"],
            ),
        ]
        ordering = ["-created"]

    def __str__(self):
        return self.title

# notes/managers.py
from django.db import models


class NoteQuerySet(models.QuerySet):
    def with_author_and_tags(self):
        return self.select_related("author").prefetch_related("tags")


class NoteManager(models.Manager):
    def get_queryset(self):
        return NoteQuerySet(self.model, using=self._db)

    def recent_for_user(self, user, limit=20):
        return (
            self.get_queryset()
            .filter(author=user)
            .with_author_and_tags()
            .order_by("-created")[:limit]
        )

# notes/serializers.py
from rest_framework import serializers
from .models import Note, Tag


class TagSerializer(serializers.ModelSerializer):
    class Meta:
        model = Tag
        fields = ("id", "name")


class NoteSerializer(serializers.ModelSerializer):
    author = serializers.StringRelatedField(read_only=True)
    tags = TagSerializer(many=True, read_only=True)

    class Meta:
        model = Note
        fields = ("id", "title", "body", "created", "updated", "author", "tags")

# notes/views.py
from rest_framework import viewsets, permissions
from .models import Note
from .serializers import NoteSerializer
from .managers import NoteManager


class NoteViewSet(viewsets.ReadOnlyModelViewSet):
    """
    read‑only API для списка и детализации заметок.
    """
    queryset = Note.objects.with_author_and_tags()
    serializer_class = NoteSerializer
    permission_classes = [permissions.IsAuthenticated]

    def get_queryset(self):
        # пользователь видит только свои записи
        return super().get_queryset().filter(author=self.request.user)

# notes/views_async.py
import csv
import io
from django.http import StreamingHttpResponse
from django.db.models import Prefetch
from asgiref.sync import sync_to_async
from .models import Note, Tag


async def export_notes(request):
    """
    Асинхронный endpoint, отдаёт CSV без блокирующей IO.
    """
    qs = (
        Note.objects.filter(author=request.user)
        .select_related("author")
        .prefetch_related(Prefetch("tags", queryset=Tag.objects.only("name")))
    )

    async def stream():
        header = ["id", "title", "tags", "created"]
        yield ",".join(header) + "\n"
        async for note in sync_to_async(list)(qs):
            tags = "|".join(t.name for t in note.tags.all())
            row = [str(note.id), note.title, tags, note.created.isoformat()]
            yield ",".join(row) + "\n"

    return StreamingHttpResponse(stream(), content_type="text/csv")

# notes/management/commands/bulk_tag_add.py
from django.core.management.base import BaseCommand
from notes.models import Note, Tag
from django.db import transaction


class Command(BaseCommand):
    help = "Добавляет указанный тег ко всем заметкам автора"

    def add_arguments(self, parser):
        parser.add_argument("username")
        parser.add_argument("tag_name")

    @transaction.atomic
    def handle(self, *args, **options):
        tag, _ = Tag.objects.get_or_create(name=options["tag_name"])
        notes = Note.objects.filter(author__username=options["username"])
        # bulk_create через through‑модель
        through = Note.tags.through
        objs = [
            through(note_id=n.id, tag_id=tag.id) for n in notes.iterator()
        ]
        through.objects.bulk_create(objs, ignore_conflicts=True)
        self.stdout.write(self.style.SUCCESS("Тег добавлен ко всем записям"))

# Пример: только нужные поля у тега, экономим трафик к БД
qs = Note.objects.prefetch_related(
    Prefetch("tags", queryset=Tag.objects.only("name"))
)

# notes/utils.py
from django.core.cache import cache
from django.conf import settings


def get_recent_notes(user, limit=20):
    key = f"recent_notes:{user.id}:{limit}"
    notes = cache.get(key)
    if notes is None:
        notes = list(Note.objects.recent_for_user(user, limit))
        cache.set(key, notes, timeout=30)  # 30 секунд
    return notes