¿Cómo se filtra un serializador anidado en Django Rest Framework?

En Django Rest Framework, ¿cómo se filtra un serializador cuando está anidado en otro serializador?

Mis filtros se imponen en los conjuntos de vistas DRF, pero cuando llama a un serializador desde dentro de otro serializador, nunca se llama al conjunto de vistas del serializador anidado, por lo que los resultados anidados aparecen sin filtrar.

Intenté agregar un filtro en el conjunto de vistas de origen, pero no parece filtrar los resultados anidados porque los resultados anidados se llaman como una consulta previa separada. (El serializador anidado es una búsqueda inversa, como ve).

¿Es posible agregar una anulación de get_queryset () en el serializador anidado en sí (moviéndolo fuera del conjunto de vistas), para agregar el filtro allí? Yo también lo intenté, sin suerte.

Esto es lo que intenté, pero ni siquiera parece que lo llamen:

class QuestionnaireSerializer(serializers.ModelSerializer):
    edition = EditionSerializer(read_only=True)
    company = serializers.StringRelatedField(read_only=True)

    class Meta:
        model = Questionnaire

    def get_queryset(self):
        query = super(QuestionnaireSerializer, self).get_queryset(instance)
        if not self.request.user.is_staff:
            query = query.filter(user=self.request.user, edition__hide=False)
        return query

Puede crear una subclase de ListSerializer y sobrescribir el to_representationmétodo.

De forma predeterminada, el to_representationmétodo llama data.all()al conjunto de consultas anidado. Por lo tanto, debe realizar data = data.filter(**your_filters)antes de llamar al método. Luego, debe agregar su ListSerializer subclasificado como list_serializer_class en el meta del serializador anidado.

1. subclase ListSerializer, sobrescribiendo to_representationy luego llamando super
2. agregue ListSerializer subclasificado como meta list_serializer_classen el serializador anidado

Aquí está el código relevante para su muestra.

class FilteredListSerializer(serializers.ListSerializer):

    def to_representation(self, data):
        data = data.filter(user=self.context['request'].user, edition__hide=False)
        return super(FilteredListSerializer, self).to_representation(data)


class EditionSerializer(serializers.ModelSerializer):

    class Meta:
        list_serializer_class = FilteredListSerializer
        model = Edition


class QuestionnaireSerializer(serializers.ModelSerializer):
    edition = EditionSerializer(read_only=True)
    company = serializers.StringRelatedField(read_only=True)

    class Meta:
        model = Questionnaire

Probé muchas soluciones de SO y otros lugares.

Encontré solo una solución de trabajo para Django 2.0 + DRF 3.7.7.

Defina un método en el modelo que tenga una clase anidada. Elabore un filtro que se adapte a sus necesidades.

class Channel(models.Model):
    name = models.CharField(max_length=40)
    number = models.IntegerField(unique=True)
    active = models.BooleanField(default=True)

    def current_epg(self):
        return Epg.objects.filter(channel=self, end__gt=datetime.now()).order_by("end")[:6]


class Epg(models.Model):
    start = models.DateTimeField()
    end = models.DateTimeField(db_index=True)
    title = models.CharField(max_length=300)
    description = models.CharField(max_length=800)
    channel = models.ForeignKey(Channel, related_name='onair', on_delete=models.CASCADE)

.

class EpgSerializer(serializers.ModelSerializer):
    class Meta:
        model = Epg
        fields = ('channel', 'start', 'end', 'title', 'description',)


class ChannelSerializer(serializers.ModelSerializer):
    onair = EpgSerializer(many=True, read_only=True, source="current_epg")

    class Meta:
        model = Channel
        fields = ('number', 'name', 'onair',)

Preste atención source="current_epg"y entenderá el punto.

Si bien todas las respuestas anteriores funcionan, creo que el uso del Prefetchobjeto de Django es la forma más fácil de todas.

Supongamos que un Restaurantobj tiene muchos MenuItems, algunos de los cuales lo son is_remove == True, y solo desea los que no se eliminan.

En RestaurantViewSet, haz algo como

from django.db.models import Prefetch

queryset = Restaurant.objects.prefetch_related(
    Prefetch('menu_items', queryset=MenuItem.objects.filter(is_removed=False), to_attr='filtered_menu_items')
)

En RestaurantSerializer, haz algo como

class RestaurantSerializer(serializers.ModelSerializer):
    menu_items = MenuItemSerializer(source='filtered_menu_items', many=True, read_only=True)

Cuando se crea una instancia de un serializador y se pasa many = True, se creará una instancia de ListSerializer. La clase de serializador luego se convierte en un elemento secundario del ListSerializer principal

Este método toma el destino del campo como argumento de valor y debe devolver la representación que se debe usar para serializar el destino. El argumento de valor suele ser una instancia de modelo.

A continuación se muestra el ejemplo del serializador anidado

class UserSerializer(serializers.ModelSerializer):
    """ Here many=True is passed, So a ListSerializer instance will be 
     created"""
    system = SystemSerializer(many=True, read_only=True)

    class Meta:
        model = UserProfile
        fields = ('system', 'name')

class FilteredListSerializer(serializers.ListSerializer):
    
    """Serializer to filter the active system, which is a boolen field in 
       System Model. The value argument to to_representation() method is 
      the model instance"""
    
    def to_representation(self, data):
        data = data.filter(system_active=True)
        return super(FilteredListSerializer, self).to_representation(data)

class SystemSerializer(serializers.ModelSerializer):
    mac_id = serializers.CharField(source='id')
    system_name = serializers.CharField(source='name')
    serial_number = serializers.CharField(source='serial')

    class Meta:
        model = System
        list_serializer_class = FilteredListSerializer
        fields = (
            'mac_id', 'serial_number', 'system_name', 'system_active', 
        )

En vista:

class SystemView(viewsets.GenericViewSet, viewsets.ViewSet):
    def retrieve(self, request, email=None):
        data = get_object_or_404(UserProfile.objects.all(), email=email)
        serializer = UserSerializer(data)
        return Response(serializer.data)

Me resulta más fácil, y más sencillo, usar un SerializerMethodFielden el campo del serializador que desea filtrar.

Entonces harías algo como esto.

class CarTypesSerializer(serializers.ModelSerializer):

    class Meta:
        model = CarType
        fields = '__all__'


class CarSerializer(serializers.ModelSerializer):

    car_types = serializers.SerializerMethodField()

    class Meta:
        model = Car
        fields = '__all__'

    def get_car_types(self, instance):
        # Filter using the Car model instance and the CarType's related_name
        # (which in this case defaults to car_types_set)
        car_types_instances = instance.car_types_set.filter(brand="Toyota")
        return CarTypesSerializer(car_types_instances, many=True).data

Esto le evita tener que crear muchas modificaciones serializers.ListSerializersi necesita diferentes criterios de filtrado para diferentes serializadores.

También tiene el beneficio adicional de ver exactamente lo que hace el filtro dentro del serializador en lugar de sumergirse en una definición de subclase.

Por supuesto, la desventaja es que si tiene un serializador con muchos objetos anidados, todos deben filtrarse de alguna manera. Podría hacer que el código del serializador aumente considerablemente. Depende de usted cómo le gustaría filtrar.

¡Espero que esto ayude!