Как обновить поля many-to-many в Django REST Framework?

# models.py

from django.db import models

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

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

class Project(models.Model):
    title: str = models.CharField(max_length=200)
    description: str = models.TextField()
    # Many-to-Many поле для связи с Tag
    tags = models.ManyToManyField(Tag, related_name='projects')

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

# serializers.py

from rest_framework import serializers
from .models import Project, Tag

class ProjectSerializer(serializers.ModelSerializer):
    # По умолчанию 'tags' будет полем только для чтения
    class Meta:
        model = Project
        fields = '__all__'

# serializers.py (Modified)

from rest_framework import serializers
from .models import Project, Tag

class ProjectSerializer(serializers.ModelSerializer):
    # Явно определяем Many-to-Many поле 'tags'
    # primary_key='id' указывается явно для ясности, хотя often это дефолтное поведение
    tags = serializers.PrimaryKeyRelatedField(
        queryset=Tag.objects.all(), 
        many=True # Указываем, что это отношение "многие"
    )

    class Meta:
        model = Project
        fields = '__all__'

# views.py

from rest_framework import generics
from .models import Project
from .serializers import ProjectSerializer

class ProjectDetailView(generics.RetrieveUpdateDestroyAPIView):
    queryset = Project.objects.all()
    serializer_class = ProjectSerializer

    # POST/PUT/PATCH запрос на /projects/{id}/ с телом вида:
    # {
    #   "title": "Updated Project Title",
    #   "description": "New description.",
    #   "tags": [1, 3, 5] // Список ID тегов
    # }
    # Сериализатор обрабатывает обновление,
    # ModelSerializer вызывает .set() для Many-to-Many поля
    # после сохранения основного объекта.

# Пример переопределения update для добавления, а не замены (нестандартное поведение)
# Этот код не реализует логику удаления!

class ProjectSerializer(serializers.ModelSerializer):
    tags = serializers.PrimaryKeyRelatedField(
        queryset=Tag.objects.all(), 
        many=True, 
        write_only=True # Обычно делаем поле только для записи в таком сценарии
    )

    class Meta:
        model = Project
        fields = '__all__'

    def update(self, instance: Project, validated_data: dict) -> Project:
        # Получаем список тегов из validated_data (если есть)
        tags_data: list[Tag] = validated_data.pop('tags', [])

        # Обновляем остальные поля модели
        instance = super().update(instance, validated_data)

        # Добавляем новые теги, если они были переданы.
        # Обратите внимание: .add() не удаляет существующие связи
        instance.tags.add(*tags_data)

        return instance

# serializers.py

# ... (импорты)

class TagSerializer(serializers.ModelSerializer):
    class Meta:
        model = Tag
        fields = ['id', 'name'] # Показываем ID и имя тега

# serializers.py (Nested)

# ... (импорты и TagSerializer)

class ProjectSerializer(serializers.ModelSerializer):
    # Используем TagSerializer для представления связанных тегов
    tags = TagSerializer(many=True, read_only=True)

    class Meta:
        model = Project
        fields = '__all__'

{
  "id": 1,
  "title": "My Project",
  "description": "About my project",
  "tags": [
    {"id": 1, "name": "Django"},
    {"id": 2, "name": "Python"}
  ]
}

# serializers.py (Writable Nested Many-to-Many)

# ... (импорты и TagSerializer)

class ProjectSerializer(serializers.ModelSerializer):
    # Вложенное поле Many-to-Many - *оно все еще read_only* по умолчанию
    # для десериализации мы будем обрабатывать его вручную в update/create
    tags = TagSerializer(many=True, required=False) # required=False т.к. поле может отсутствовать в запросе

    class Meta:
        model = Project
        fields = '__all__'

    def update(self, instance: Project, validated_data: dict) -> Project:
        # Извлекаем данные тегов перед обновлением основного объекта
        # Pop'ем 'tags_data', чтобы ModelSerializer не пытался обработать их сам
        tags_data: list[dict] = validated_data.pop('tags', [])

        # Обновляем поля основного объекта Project
        # Здесь ModelSerializer обработает title, description и т.д.
        instance = super().update(instance, validated_data)

        # Обрабатываем обновление Many-to-Many связей вручную
        # Предполагаем, что в tags_data пришел список словарей вида {'id': 1, 'name': '...'}
        # или просто {'id': 1} если мы хотим обновлять только по ID

        # Собираем список ID тегов из входящих данных
        incoming_tag_ids: set[int] = {tag_data.get('id') for tag_data in tags_data if tag_data.get('id') is not None}

        # Получаем текущий набор ID связанных тегов
        current_tag_ids: set[int] = set(instance.tags.values_list('id', flat=True))

        # ID тегов для добавления (входящие, которых нет текущих)
        tags_to_add_ids = list(incoming_tag_ids - current_tag_ids)
        # ID тегов для удаления (текущие, которых нет во входящих)
        tags_to_remove_ids = list(current_tag_ids - incoming_tag_ids)

        # Выполняем операции добавления/удаления через ORM
        # Используем bulk=False для каждого add/remove вызова, 
        # чтобы m2m_changed сигнал сработал для каждого объекта (если нужно).
        # Или используем set() для замены, которая эффективнее

        # --- Вариант 1: Использование .set() для полной замены --- 
        # Находим объекты тегов по входящим ID
        # tags_to_set: list[Tag] = Tag.objects.filter(id__in=list(incoming_tag_ids))
        # instance.tags.set(tags_to_set)

        # --- Вариант 2: Явное добавление и удаление --- (Более гибок, но сложнее)
        if tags_to_add_ids:
             # Получаем объекты тегов для добавления
             tags_to_add: list[Tag] = Tag.objects.filter(id__in=tags_to_add_ids)
             instance.tags.add(*tags_to_add)

        if tags_to_remove_ids:
             # Получаем объекты тегов для удаления
             tags_to_remove: list[Tag] = instance.tags.filter(id__in=tags_to_remove_ids)
             instance.tags.remove(*tags_to_remove)
        # Примечание: удаление по ID напрямую тоже возможно: instance.tags.remove(*tags_to_remove_ids)

        return instance

    # Также может потребоваться переопределение create, если вы создаете объект Project
    # и одновременно устанавливаете Many-to-Many связи
    def create(self, validated_data: dict) -> Project:
        tags_data: list[dict] = validated_data.pop('tags', [])

        # Создаем основной объект Project
        project: Project = super().create(validated_data)

        # Находим объекты тегов по их ID из входящих данных
        # Предполагаем, что в tags_data приходят только ID
        tag_ids: list[int] = [tag_data.get('id') for tag_data in tags_data if tag_data.get('id') is not None]
        if tag_ids:
            tags: list[Tag] = Tag.objects.filter(id__in=tag_ids)
            # Устанавливаем Many-to-Many связи
            project.tags.set(tags) # Или project.tags.add(*tags)

        return project

# signals.py

from django.db.models.signals import m2m_changed
from django.dispatch import receiver
from .models import Project

@receiver(m2m_changed, sender=Project.tags.through) # sender - это промежуточная модель Many-to-Many
def project_tags_changed(sender, instance: Project, action: str, 
                           reverse: bool, model, pk_set: set[int], **kwargs) -> None:
    """
    Обработчик сигнала при изменении тегов проекта.

    Args:
        sender: Промежуточная модель M2M.
        instance: Объект Project, у которого изменились теги.
        action: Строка, описывающая действие ('pre_add', 'post_add', 
                  'pre_remove', 'post_remove', 'pre_clear', 'post_clear', 'pre_set', 'post_set').
        reverse: Булево значение, True если отношение "обратное".
        model: Модель, с которой установлено M2M отношение (в данном случае Tag).
        pk_set: Множество PKs объектов, затронутых действием.
        **kwargs: Дополнительные аргументы.
    """
    print(f"Сигнал m2m_changed для проекта {instance.title}. Действие: {action}, PKs затронутых тегов: {pk_set}")

    # Пример логики после изменения связей:
    if action == 'post_add':
        # Логика после добавления тегов
        pass
    elif action == 'post_remove':
        # Логика после удаления тегов
        pass
    elif action == 'post_set':
        # Логика после полной замены тегов
        pass

# Подключите сигналы в вашем приложении (например, в apps.py)

# serializers.py (Переопределение update для кастомной логики)

from rest_framework import serializers
from .models import Project, Tag

class ProjectSerializer(serializers.ModelSerializer):
    # Поле для получения списка ID тегов (writable)
    tag_ids = serializers.ListField(
        child=serializers.IntegerField(), 
        write_only=True, 
        required=False
    )
    # Или используем PrimaryKeyRelatedField как в первом примере
    # tags = serializers.PrimaryKeyRelatedField(queryset=Tag.objects.all(), many=True)

    # Поле только для чтения для отображения тегов (опционально)
    tags_display = serializers.SerializerMethodField(read_only=True)

    class Meta:
        model = Project
        fields = ['id', 'title', 'description', 'tag_ids', 'tags_display'] # Включаем оба поля (или только одно)

    def get_tags_display(self, obj: Project) -> list[str]:
        """Возвращает список имен тегов для отображения."""
        return [tag.name for tag in obj.tags.all()]

    def update(self, instance: Project, validated_data: dict) -> Project:
        # Извлекаем данные для Many-to-Many поля по его имени в validated_data
        # Имя поля в validated_data соответствует имени сериализаторного поля
        # В данном случае, если мы используем tag_ids = serializers.ListField(...)
        # то данные будут по ключу 'tag_ids'
        # Если бы мы использовали tags = serializers.PrimaryKeyRelatedField(...)
        # то данные были бы по ключу 'tags'

        # Предположим, что мы используем tag_ids
        # tags_to_set_ids: list[int] = validated_data.pop('tag_ids', None)

        # Или, если используем tags = PrimaryKeyRelatedField (как в первом примере)
        # DRF автоматически поместит объекты тегов, найденные по ID, в validated_data['tags']
        tags_to_set: list[Tag] | None = validated_data.pop('tags', None)


        # Обновляем остальные поля модели Project
        # super().update() вызовет save() на instance, но не затронет Many-to-Many
        instance = super().update(instance, validated_data)

        # Если данные для тегов были предоставлены в запросе
        if tags_to_set is not None:
            # Используем set() для замены всех текущих тегов на новые
            instance.tags.set(tags_to_set) # set() принимает список объектов или их PKs
                                            # В случае PrimaryKeyRelatedField,
                                            # в validated_data уже будут объекты

        return instance

    # create метод также может быть переопределен по аналогии
    # def create(self, validated_data: dict) -> Project:
    #     tags_to_set: list[Tag] | None = validated_data.pop('tags', None)
    #     project: Project = super().create(validated_data)
    #     if tags_to_set is not None:
    #         project.tags.set(tags_to_set)
    #     return project