Module source.polls.serializers

Classes

class MyTokenObtainPairSerializer (*args, **kwargs)

The BaseSerializer class provides a minimal class which may be used for writing custom serializer implementations.

Note that we strongly restrict the ordering of operations/properties that may be used on the serializer in order to enforce correct usage.

In particular, if a data= argument is passed then:

.is_valid() - Available. .initial_data - Available. .validated_data - Only available after calling is_valid() .errors - Only available after calling is_valid() .data - Only available after calling is_valid()

If a data= argument is not passed then:

.is_valid() - Not available. .initial_data - Not available. .validated_data - Not available. .errors - Not available. .data - Available.

Expand source code

class MyTokenObtainPairSerializer(TokenObtainPairSerializer):
    @classmethod
    def get_token(cls, user):
        token = super(MyTokenObtainPairSerializer, cls).get_token(user)

        # Add custom claims
        token['username'] = user.username
        return token

Ancestors

• rest_framework_simplejwt.serializers.TokenObtainPairSerializer
• rest_framework_simplejwt.serializers.TokenObtainSerializer
• rest_framework.serializers.Serializer
• rest_framework.serializers.BaseSerializer
• rest_framework.fields.Field

Static methods

def get_token(user)

Expand source code

@classmethod
def get_token(cls, user):
    token = super(MyTokenObtainPairSerializer, cls).get_token(user)

    # Add custom claims
    token['username'] = user.username
    return token

class RegisterSerializer (instance=None, data=rest_framework.fields.empty, **kwargs)

A ModelSerializer is just a regular Serializer, except that:

• A set of default fields are automatically populated.
• A set of default validators are automatically populated.
• Default .create() and .update() implementations are provided.

The process of automatically determining a set of serializer fields based on the model fields is reasonably complex, but you almost certainly don't need to dig into the implementation.

If the ModelSerializer class doesn't generate the set of fields that you need you should either declare the extra/differing fields explicitly on the serializer class, or simply use a Serializer class.

Expand source code

class RegisterSerializer(serializers.ModelSerializer):
    # create new atributes for changing model validations.
    email = serializers.EmailField(
        required=True,
        validators=[UniqueValidator(queryset=User.objects.all())]
    )

    password = serializers.CharField(write_only=True, required=True, validators=[validate_password])
    password2 = serializers.CharField(write_only=True, required=True)

    class Meta:
        model = User
        fields = ('username', 'password', 'password2', 'email', 'first_name', 'last_name')
        extra_kwargs = {
            'first_name': {'required': True},
            'last_name': {'required': True}
        }

    def validate(self, attrs):
        if attrs['password'] != attrs['password2']:
            raise serializers.ValidationError({"password": "Password fields didn't match."})

        return attrs

    def create(self, validated_data):
        user = User.objects.create(
            username=validated_data['username'],
            email=validated_data['email'],
            first_name=validated_data['first_name'],
            last_name=validated_data['last_name']
        )

        user.set_password(validated_data['password'])
        user.save()

        return user

Ancestors

• rest_framework.serializers.ModelSerializer
• rest_framework.serializers.Serializer
• rest_framework.serializers.BaseSerializer
• rest_framework.fields.Field

Class variables

var Meta

Methods

def create(self, validated_data)

We have a bit of extra checking around this in order to provide descriptive messages when something goes wrong, but this method is essentially just:

return ExampleModel.objects.create(**validated_data)

If there are many to many fields present on the instance then they cannot be set until the model is instantiated, in which case the implementation is like so:

example_relationship = validated_data.pop('example_relationship')
instance = ExampleModel.objects.create(**validated_data)
instance.example_relationship = example_relationship
return instance

The default implementation also does not handle nested relationships. If you want to support writable nested relationships you'll need to write an explicit .create() method.

Expand source code

def create(self, validated_data):
    user = User.objects.create(
        username=validated_data['username'],
        email=validated_data['email'],
        first_name=validated_data['first_name'],
        last_name=validated_data['last_name']
    )

    user.set_password(validated_data['password'])
    user.save()

    return user

def validate(self, attrs)

Expand source code

def validate(self, attrs):
    if attrs['password'] != attrs['password2']:
        raise serializers.ValidationError({"password": "Password fields didn't match."})

    return attrs

class userSerializers (instance=None, data=rest_framework.fields.empty, **kwargs)

A ModelSerializer is just a regular Serializer, except that:

• A set of default fields are automatically populated.
• A set of default validators are automatically populated.
• Default .create() and .update() implementations are provided.

The process of automatically determining a set of serializer fields based on the model fields is reasonably complex, but you almost certainly don't need to dig into the implementation.

If the ModelSerializer class doesn't generate the set of fields that you need you should either declare the extra/differing fields explicitly on the serializer class, or simply use a Serializer class.

Expand source code

class userSerializers(serializers.ModelSerializer):
    #token = serializers.CharField(max_length=100, default='NA')
    class Meta:
        #token = Token.objects.get()
        model = User
        fields = ["id"]
        #fields = '__all__'
        extra_kwargs = {'password': {'write_only': True}}

    def create(self, validated_data):
        password = validated_data.pop('password')
        user = User(**validated_data)
        user.set_password(password)
        user.save()
        return user

Ancestors

• rest_framework.serializers.ModelSerializer
• rest_framework.serializers.Serializer
• rest_framework.serializers.BaseSerializer
• rest_framework.fields.Field

Class variables

var Meta

Methods

def create(self, validated_data)

We have a bit of extra checking around this in order to provide descriptive messages when something goes wrong, but this method is essentially just:

return ExampleModel.objects.create(**validated_data)

If there are many to many fields present on the instance then they cannot be set until the model is instantiated, in which case the implementation is like so:

example_relationship = validated_data.pop('example_relationship')
instance = ExampleModel.objects.create(**validated_data)
instance.example_relationship = example_relationship
return instance

The default implementation also does not handle nested relationships. If you want to support writable nested relationships you'll need to write an explicit .create() method.

Expand source code

def create(self, validated_data):
    password = validated_data.pop('password')
    user = User(**validated_data)
    user.set_password(password)
    user.save()
    return user