CODEWITHSUNDEEP
djangodjango-modelsdjango-rest-framework
fangsterr
fangsterr

Reputation: 3820

djangorestframework: Filtering in a related field

Basically, I want to filter out inactive users from a related field of a ModelSerializer. I tried Dynamically limiting queryset of related field as well as the following:

class MySerializer(serializers.ModelSerializer):
  users = serializers.PrimaryKeyRelatedField(queryset=User.objects.filter(active=True), many=True)
  class Meta:
    model = MyModel
    fields = ('users',)

Neither of these approaches worked for just filtering the queryset. I want to do this for a nested related Serializer class as a field (but couldn't even get it to work with a RelatedField).

How do I filter queryset for nested relation?

Upvotes: 38

Views: 15120

Answers (3)

burnedikt
burnedikt

Reputation: 1007

Another way to avoid the SerializerMethodField solution and therefore still allow writing to the serializer as well would be to subclass the RelatedField and do the filtering there.

To only allow active users as values for the field, the example would look like:

class ActiveUsersPrimaryKeyField(serializers.PrimaryKeyRelatedField):
    def get_queryset(self):
        return super().get_queryset().filter(active=True)

class MySerializer(serializers.ModelSerializer):
    users = ActiveUsersPrimaryKeyField(many=True)
    class Meta:
        model = MyModel
        fields = ('users',)

Also see this response.

Note that this only restricts the set of input values to active users, though, i.e. only when creating or updating model instances, inactive users will be disallowed.

If you also use your serializer for reading and MyModel already has a relation to a user that has become inactive in the meantime, it will still be serialized. To prevent this, one way is to filter the relation using django's Prefetch objects. Basically, you'll filter out inactive users before they even get into the serializer:

from django.db.models import Prefetch

# Fetch a model instance, eagerly prefetching only those users that are active
model_with_active_users = MyModel.objects.prefetch_related(
    Prefetch("users", queryset=User.objects.filter(active=True))
).first()

# serialize the data with the serializer defined above and see that only active users are returned
data = MyModelSerializer(model_with_active_users).data

Upvotes: 4

user7870824
user7870824

Reputation:

One way to do this is to create a method on the Model itself and reference it in the serializer:

#Models.py
class MyModel(models.Model):
    #...
    def my_filtered_field (self):
            return self.othermodel_set.filter(field_a = 'value_a').order_by('field_b')[:10]
#Serialziers.py
class MyModelSerialzer(serializers.ModelSerializer):
    my_filtered_field = OtherModelSerializer (many=True, read_only=True)
    class Meta:
        model   = MyModel
        fields  = [
            'my_filtered_field'             ,
            #Other fields ...
        ]

Upvotes: 5

François Constant
François Constant

Reputation: 5496

I'll be curious to see a better solution as well. I've used a custom method in my serializer to do that. It's a bit more verbose but at least it's explicit.

Some pseudo code where a GarageSerializer would filter the nested relation of cars:

class MyGarageSerializer(...):
    users = serializers.SerializerMethodField('get_cars')

    def get_cars(self, garage):
        cars_queryset = Car.objects.all().filter(Q(garage=garage) | ...).select_related()
        serializer = CarSerializer(instance=cars_queryset, many=True, context=self.context)

        return serializer.data

Obviously replace the queryset with whatever you want. You don't always need the to give the context (I used it to retrieve some query parameters in the nested serializer) and you probably don't need the .select_related (that was an optimisation).

Upvotes: 40

Related Questions