How to choose a different serializer class in genericviewsets based on the data sent by the front end

Question

thee are my serializers for different users

class PlayerSerializer(serializers.ModelSerializer):   
       class Meta:
            model = player
            fields = ('contact_name', 'contact_email', 'address',)


class ManagerSerializer(serializers.ModelSerializer):

    class Meta:
        model = Manager
        fields = ('contact_name', 'contact_email', 'address',
                  'city', 'country',)


class CoachSerializer(serializers.ModelSerializer):

    class Meta:
        model = Shipper
        fields = (' 'contact_name', 'contact_email', 'address', 'city', 'about', 'country',)


these are my user Serializers with relation with each user type 

class playerUserSerialzers(serializers.ModelSerializer):
   player =PlayerSerializer()

    class Meta:
        model = MyUser
        fields = ('email', 'id', 'password', 'player',)
        extra_kwargs = {'password': {'write_only': True}}

    def create(self, validated_data):
        player_data = validated_data.pop('player')
        user = MyUser(
            email=validated_data['email'],
        )
        user.set_password(validated_data['password'])
        user = MyUser.objects.create(**validated_data)
        Player.objects.create(user=user, **player_data)
        user.save()
        return user


class managerUserSerialzers(serializers.ModelSerializer):
   manager =ManagerSerializer()

    class Meta:
        model = MyUser
        fields = ('email', 'id', 'password', 'manager',)
        extra_kwargs = {'password': {'write_only': True}}

    def create(self, validated_data):
        manager_data = validated_data.pop('manager')
        user = MyUser(
            email=validated_data['email'],
        )
        user.set_password(validated_data['password'])
        user = MyUser.objects.create(**validated_data)
        Manager.objects.create(user=user, **manager_data)
        user.save()
        return user


class managerUserSerialzers(serializers.ModelSerializer):
  coach =CoachSerializer()

    class Meta:
        model = MyUser
        fields = ('email', 'id', 'password', 'coach',)
        extra_kwargs = {'password': {'write_only': True}}

    def create(self, validated_data):
        coach_data = validated_data.pop('coach')
        user = MyUser(
            email=validated_data['email'],
        )
        user.set_password(validated_data['password'])
        user = MyUser.objects.create(**validated_data)
       Coach.objects.create(user=user, **coach_data)
        user.save()
        return user

this doesn't work but i would like to use different serializers based on the front end request

class MyUserViewSet(mixins.CreateModelMixin,
                        mixins.RetrieveModelMixin,
                        mixins.DestroyModelMixin,
                        mixins.UpdateModelMixin,
                        mixins.ListModelMixin,
                        GenericViewSet):
        queryset = MyUser.objects.all()
        pagination_class = LimitOffsetPagination
        permission_classes = (AllowAny,)

how do i switch bases on serializer class here def get_serializer_class(self,): if self.request.query_params.get("player", None): return MyBrokerUserSerialzers

score 1 · Answer 1 · answered Jun 01 '16 at 04:30

From the documentation you can specify the serializer_class property telling the right serializer you want.

Then, as you are inheriting many mixing classes you can overwrite their methods and get the information from your frontend. For each kind of request method you will have to get the frontend information in a different way.

class MyUserViewSet(mixins.CreateModelMixin,
                        mixins.RetrieveModelMixin,
                        mixins.DestroyModelMixin,
                        mixins.UpdateModelMixin,
                        mixins.ListModelMixin,
                        GenericViewSet):
    queryset = MyUser.objects.all()
    pagination_class = LimitOffsetPagination
    permission_classes = (AllowAny,)

    def define_serializer_class(self, serializer_class_name):
        serializer_class = serializer_class_name

    def get(self, request, *args, **kwargs):
        #here in GET METHOD you wil user the RetrieveModelMixin
        #So get the kind of serializer from you get params in request.GET["param name"] 
        #and set the right one with a 'if' condition and calling
        # self.define_serializer_class(<the name of the right serializer class>)
        return self.retrieve(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        #here in POST METHOD you wil user the CreateModelMixin
        #So get the kind of serializer from you post playload in request.POST["param name"]
        #and set the right one with a 'if' condition and calling
        # self.define_serializer_class(<the name of the right serializer class>)
        return self.update(request, *args, **kwargs)

    def put(self, request, *args, **kwargs):
        #Do the same here get the info from the frontend
        return self.update(request, *args, **kwargs)

    def delete(self, request, *args, **kwargs):
        #Do the same here get the info from the frontend
        return self.destroy(request, *args, **kwargs)

I'm sorry I cannot tell the right code to do what you want, but the comments in the code explain step-by-step a way to solve your problem. I never have done it myself because I don't like to use mixings (they make up everying), but it will work for you. Just find the right way to get the information from the frontend for each kind of HTTP method that the mixins use and set the serializer_class as I said above.

I hope it helps you.

score 1 · Answer 2 · answered Jun 05 '16 at 01:09

In my opinion this is unclear what you are trying to achieve and why are you doing things this way.

Let me put it in the perspective, if you have 3 seaparate objects, create 3 separate backends for them and you do not need anything else.

class UserMixin(object):

    def create(self, validated_data):
        user = MyUser(email=validated_data.pop('email'))
        user.set_password(validated_data.pop('password')
        user.save()  # now you can use user in relations
        validated_data['user'] = user

        super(UserMixin, self).create(**validated_data)

        return user

class PlayerSerializer(serializers.ModelSerializer, UserMixin): 

    class Meta:
        model = Player
        fields = ('id', 'email', 'password', 'contact_name', 'contact_email',
                  'address')
        read_only_fields = ('id',)
        extra_kwargs = {'password': {'write_only': True}}


class ManagerSerializer(serializers.ModelSerializer, UserMixin):

    class Meta:
        model = Manager
        fields = ('id', 'email', 'password', 'contact_name', 'contact_email', 
                  'address', 'city', 'country')
        read_only_fields = ('id',)
        extra_kwargs = {'password': {'write_only': True}}


class CoachSerializer(serializers.ModelSerializer, UserMixin):

    class Meta:
        model = Shipper
        fields = ('id', 'email', 'password', 'contact_name', 'contact_email',       
                  'address', 'city', 'about', 'country',)
        read_only_fields = ('id',)
        extra_kwargs = {'password': {'write_only': True}}

# now 3 viewsets
class PlayerViewset(viewsets.ModelViewSet):
    model = Player
    queryset = Player.objects.all()
    serializer_class = PlayerSerializer

class ManagerViewset(viewsets.ModelViewSet):
    model = Manager
    queryset = Manager.objects.all()
    serializer_class = ManagerSerializer

class CoachViewset(viewsets.ModelViewSet):
    model = Shipper
    queryset = Shipper.objects.all()
    serializer_class = CoachSerializer

# register api ends
api_router.register('player', PlayerViewset)
api_router.register('manager', ManagerViewset)
api_router.register('coach', CoachViewset)

simple, efective and not much work...

p.s. class names starts with capital letter - please read pep-8

How to choose a different serializer class in genericviewsets based on the data sent by the front end

2 Answers2