While building APIs, the primary thing to setup is the validations for the API. Validators can be pretty useful for writing validations but sometimes there are a lot of custom validations to be supported.
If you have custom validations, you can override the validate method in your serializer.
class SomeRandomSerializer(serializers.ModelSerializer):
class Meta:
model = SomeRandomModel
fields = [
'id',
'some_random_field_1',
'some_random_field_2',
'some_random_field_3',
]
def validate(self, data):
is_field_1_valid = data.get('some_random_field_1') == 100
if not is_field_1_valid:
raise serializers.ValidationError({
'some_random_field_1': [
'Some random field 1 should be equal to 100'
]
})
is_field_2_valid = data.get('some_random_field_2') == 200
if not is_field_2_valid:
raise serializers.ValidationError({
'some_random_field_2': [
'Some random field 2 should be equal to 200'
]
})
return data
def create(self, validated_data):
pass
def update(self, instance, validated_data):
pass
But the problem writing all your validations here is that if there are a lot of validations, your serializer will become very long. It will be better to move all our validations to a separate file so our serializer file will be clean.
Give me an example
Let's say we are building our Products API and our project's folder structure is shown below.
/ app
/ serializers
product.py
/ validations
product.py
/ viewsets
product.py
models.py
urls.py
We have 3 different folders for our serializers, validation files, and viewset files. Hence, we created product.py under each folder.
Our ProductSerializer would look something like this. Check the validation method, we have directly called the validate method from our custom-built ProductValidation class.
from app.models import Product
from app.validations.product import ProductValidation
class ProductSerializer(serializers.ModelSerializer):
class Meta:
model = Product
fields = [
'id',
'title',
'code',
'description',
'quantity'
]
def validate(self, data):
return ProductValidation(
data=data,
instance=self.instance).validate()
def create(self, validated_data):
pass
def update(self, instance, validated_data):
pass
The ProductValidation Class
class ProductValidation:
def __init__(self, data, instance):
self.data = data
self.instance = instance
self.is_update_case = instance is not None
def validate(self):
if self.is_update_case:
return self.__validate_UPDATE()
return self.__validate_CREATE()
def __validate_CREATE(self):
errors = {
**self.__validate_title_length(),
**self.__validate_code(),
**self.__validate_description_length(),
**self.__validate_quantity()
}
if errors:
raise serializers.ValidationError(errors)
return self.data
def __validate_UPDATE(self):
errors = {
**self.__validate_title_length(),
**self.__validate_code(),
**self.__validate_description_length(),
**self.__validate_quantity()
**self.__validate_JUST_FOR_UPDATE_CASE_1(),
**self.__validate_JUST_FOR_UPDATE_CASE_2(),
}
if errors:
raise serializers.ValidationError(errors)
return self.data
def __validate_title_length(self):
errors = dict()
title = self.data['title']
if len(title) <= 2:
errors.update({
'title': ['Title length should be greater than 2']
})
return errors
def __validate_code(self):
pass
def __validate_description_length(self):
pass
def __validate_quantity(self):
pass
def __validate_JUST_FOR_UPDATE_CASE_1(self):
pass
def __validate_JUST_FOR_UPDATE_CASE_2(self):
pass
- The constructor of
ProductValidation needs two values. The first one is the data passed as in the body of the API and the second is the actual instance.
- The instance will be None if it is a creation case else there will be the actual instance.
- Inside the constructor, the
is_update_case value is set on the same principle.
- The
validate method calls __validate_UPDATE or the __validate_CREATE method based on the is_update_case boolean.
** can be used inside a dictionary to merge multiple dictionaries.
- Inside the
__validate_CREATE method, we build a dictionary of errors.
- This dictionary calls multiple validations methods, each of them returning a dictionary of errors (if there are errors else an empty dictionary).
- If there are any errors, we raise
ValidationError passing our errors dictionary.
- The
__validate_UPDATE is the same as the __validate_CREATE method.
- We created the
__validate_UPDATE method because sometimes update APIs have some more validations than the create APIs.
This makes adding new validations, checking for validation errors, or removing any validations very easy. Trust me, if you have tons of validations, this technique makes it very easy to maintain.
Thanks for reading!
