Question

在Django Rest Framework中，如何在串行器嵌套在另一个序列化器中时对其进行过滤？

我的过滤器强加在DRF视图集中，但是当您从另一个序列化程序中调用序列化程序时，嵌套序列化程序的视图集永远不会被调用，因此嵌套结果显示为未过滤。

我尝试在原始视图集上添加过滤器，但它似乎没有过滤嵌套结果，因为嵌套结果会被调用为单独的预先查询。（嵌套的序列化器是反向查找，你看。）

是否可以在嵌套的序列化程序本身中添加get_queryset（）覆盖（将其移出视图集），以在那里添加过滤器？我也尝试过，没有运气。

这是我尝试过的，但它似乎甚至没有被调用：

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

Answer 1

您可以继承ListSerializer并覆盖to_representation方法。

默认情况下，to_representation方法会在嵌套查询集上调用data.all()。因此，在调用方法之前，您需要有效地生成data = data.filter(**your_filters)。然后，您需要在嵌套序列化程序的元数据上添加子类ListSerializer作为list_serializer_class。

子类ListSerializer，覆盖to_representation然后调用super
在嵌套的Serializer

list_serializer_class

以下是您的样本的相关代码。

class FilteredListSerializer(serializers.ListSerializer):

    def to_representation(self, data):
        data = data.filter(user=self.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

Answer 2

测试了SO和其他地方的许多解决方案。

仅为Django 2.0 + DRF 3.7.7找到了一个可行的解决方案。

在模型中定义具有嵌套类的方法。制作符合您需求的过滤器。

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',)

注意source="current_epg"，你就明白了。

Answer 3

当实例化一个序列化器并且传递了许多= True时，a   将创建ListSerializer实例。那么序列化器类   成为父ListSerializer的孩子

此方法将字段的目标作为值参数，并且   应该返回应该用于序列化的表示   目标。 value参数通常是模型实例。

以下是嵌套序列化程序的示例

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', 
        )

在视图中：

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)

Answer 4

我发现在要过滤的序列化器字段上使用SerializerMethodField更容易，更直接。

所以你会做这样的事情。

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

如果您需要为不同的序列化程序使用不同的过滤条件，则不必创建许多serializers.ListSerializer替代。

它还有一个额外的好处，就是可以准确地看到过滤器在序列化器中的功能，而不用深入研究子类定义。

当然，缺点是如果您有一个带有许多嵌套对象的序列化程序，这些对象都需要以某种方式进行过滤。这可能会导致序列化程序代码大大增加。由您决定如何过滤。

希望这会有所帮助！

Answer 5

尽管以上所有答案都有效，但我发现使用Django的Prefetch对象是最简单的方法。

假设一个Restaurant obj有很多MenuItem，其中有些是is_remove == True，而您只希望不删除它们。

在RestaurantViewSet中，执行

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')
)

在RestaurantSerializer中，执行

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

如何在Django Rest Framework中过滤嵌套的序列化程序？

5 个答案: