Bài 5.2: Field-Level & Object-Level Validation - Phần 2

**Series Navigation:** - [Bài 5.1: Serializer Fundamentals](/django-advance/serializers-advanced-phan-1) - **Bài 5.2 (bài này): Field-Level & Object-Level Validation** 👈 - [Bài 5.3: Nested Serializers](/django-advance/serializers-advanced-phan-3) - [Bài 5.4: Advanced Patterns & Performance](/django-advance/serializers-advanced-phan-4)

Mục Tiêu Bài 5.2

Sau khi hoàn thành Bài 5.2 này, bạn sẽ:

✅ Master field-level validation với validate_()
✅ Implement object-level validation với validate()
✅ Create custom validator functions và classes
✅ Handle ValidationError properly
✅ Implement multi-field validation
✅ Use conditional validation logic
✅ Build reusable validation patterns

Validation Fundamentals

Validation Flow trong DRF

Deserialization Flow:

Request Data    ↓1. Field Type Validation (built-in)    ↓2. Field Validators (validators=[...])    ↓3. Field-Level Validation (validate_<field>)    ↓4. Object-Level Validation (validate)    ↓validated_data    ↓save()

Example Data Flow:

# Inputdata = {'email': 'test@example.com', 'age': 25} # 1. Type validationemail = EmailField()  # ✅ Valid email format # 2. Field validatorsemail.validators = [UniqueValidator()]  # ✅ Email not in DB # 3. Field-leveldef validate_email(value): # ✅ Custom check    return value # 4. Object-leveldef validate(data):  # ✅ Cross-field checks    return data

Why Multiple Validation Levels?

1. Built-in Type Validation:

Basic type checking
Format validation (email, URL)
Min/max constraints

2. Field Validators:

Reusable validation logic
Database uniqueness
Regex patterns

3. Field-Level Methods:

Field-specific business logic
Context-dependent validation
Clean code organization

4. Object-Level Validation:

Multi-field relationships
Complex business rules
Cross-field dependencies

Field-Level Validation

Basic Pattern

Method Signature:

def validate_<field_name>(self, value):    """    Field-level validation method        Args:        value: The field value to validate        Returns:        The validated (and possibly transformed) value        Raises:        serializers.ValidationError: If validation fails    """    # Validation logic    if invalid_condition:        raise serializers.ValidationError('Error message')        return value  # Must return value!

Example:

class UserSerializer(serializers.ModelSerializer):    class Meta:        model = User        fields = ['username', 'email', 'age']        def validate_username(self, value):        """Validate username is alphanumeric and 3+ chars"""        if len(value) < 3:            raise serializers.ValidationError(                'Username must be at least 3 characters'            )                if not value.isalnum():            raise serializers.ValidationError(                'Username must be alphanumeric'            )                return value        def validate_age(self, value):        """Validate age is 18+"""        if value < 18:            raise serializers.ValidationError(                'Must be 18 or older'            )                return value

Common Validation Patterns

1. Length Validation:

def validate_password(self, value):    """Password must be 8-128 characters"""    if len(value) < 8:        raise serializers.ValidationError(            'Password must be at least 8 characters'        )        if len(value) > 128:        raise serializers.ValidationError(            'Password cannot exceed 128 characters'        )        return value

2. Pattern Validation:

import re def validate_phone(self, value):    """Validate phone number format"""    pattern = r'^\+?1?\d{9,15}$'        if not re.match(pattern, value):        raise serializers.ValidationError(            'Invalid phone number format. Use +1234567890'        )        return value

3. Uniqueness Check:

def validate_email(self, value):    """Ensure email is unique (for create)"""    # Check if updating existing instance    if self.instance:        # Allow same email for current instance        if self.instance.email == value:            return value        # Check uniqueness    if User.objects.filter(email=value).exists():        raise serializers.ValidationError(            'A user with this email already exists'        )        return value

4. Value Range:

def validate_rating(self, value):    """Rating must be 1-5"""    if not 1 <= value <= 5:        raise serializers.ValidationError(            'Rating must be between 1 and 5'        )        return value

5. Allowed Values:

def validate_status(self, value):    """Status must be valid"""    allowed = ['draft', 'published', 'archived']        if value not in allowed:        raise serializers.ValidationError(            f'Status must be one of: {", ".join(allowed)}'        )        return value

6. Transform Value:

def validate_email(self, value):    """Lowercase and strip email"""    return value.lower().strip() def validate_slug(self, value):    """Auto-generate slug from title if empty"""    if not value and 'title' in self.initial_data:        from django.utils.text import slugify        value = slugify(self.initial_data['title'])        return value

7. External API Validation:

def validate_address(self, value):    """Validate address via external API"""    import requests        response = requests.get(        'https://api.example.com/validate-address',        params={'address': value}    )        if not response.json()['is_valid']:        raise serializers.ValidationError(            'Invalid address. Please check and try again.'        )        return value

8. File Validation:

def validate_avatar(self, value):    """Validate image file"""    # Check file size (max 5MB)    if value.size > 5 * 1024 * 1024:        raise serializers.ValidationError(            'Image file too large. Max size is 5MB.'        )        # Check file type    allowed_types = ['image/jpeg', 'image/png', 'image/gif']    if value.content_type not in allowed_types:        raise serializers.ValidationError(            'Invalid file type. Allowed: JPEG, PNG, GIF'        )        return value

Accessing Context in Field Validation

Use self.context:

class ArticleSerializer(serializers.ModelSerializer):    class Meta:        model = Article        fields = ['title', 'content', 'status']        def validate_status(self, value):        """Only staff can publish"""        request = self.context.get('request')                if value == 'published':            if not request or not request.user.is_staff:                raise serializers.ValidationError(                    'Only staff members can publish articles'                )                return value

Pass context in view:

# views.pyserializer = ArticleSerializer(    data=request.data,    context={'request': request}  # Pass context)

Accessing Other Fields

Use self.initial_data:

def validate_end_date(self, value):    """End date must be after start date"""    start_date = self.initial_data.get('start_date')        if start_date:        from datetime import datetime        start = datetime.fromisoformat(start_date)                if value <= start.date():            raise serializers.ValidationError(                'End date must be after start date'            )        return value

⚠️ Note: initial_data contains raw, unvalidated data. Better to use object-level validation for cross-field checks.

Object-Level Validation

Basic Pattern

Method Signature:

def validate(self, data):    """    Object-level validation        Args:        data: Dictionary of validated field values        Returns:        The validated (and possibly modified) data dict        Raises:        serializers.ValidationError: If validation fails    """    # Validation logic    if invalid_condition:        raise serializers.ValidationError('Error message')        return data  # Must return data!

Multi-Field Validation

Example 1: Date Range:

class EventSerializer(serializers.ModelSerializer):    class Meta:        model = Event        fields = ['name', 'start_date', 'end_date']        def validate(self, data):        """Ensure end_date is after start_date"""        start = data.get('start_date')        end = data.get('end_date')                if start and end and end <= start:            raise serializers.ValidationError(                'End date must be after start date'            )                return data

Example 2: Password Confirmation:

class RegistrationSerializer(serializers.Serializer):    username = serializers.CharField()    email = serializers.EmailField()    password = serializers.CharField(write_only=True)    password_confirm = serializers.CharField(write_only=True)        def validate(self, data):        """Ensure passwords match"""        password = data.get('password')        password_confirm = data.get('password_confirm')                if password != password_confirm:            raise serializers.ValidationError({                'password_confirm': 'Passwords do not match'            })                # Remove password_confirm from validated data        data.pop('password_confirm')                return data

Example 3: Conditional Requirements:

class OrderSerializer(serializers.ModelSerializer):    class Meta:        model = Order        fields = ['shipping_method', 'shipping_address', 'total']        def validate(self, data):        """Require address if shipping method is delivery"""        shipping_method = data.get('shipping_method')        shipping_address = data.get('shipping_address')                if shipping_method == 'delivery' and not shipping_address:            raise serializers.ValidationError({                'shipping_address': 'Address required for delivery orders'            })                return data

Example 4: Business Logic:

class DiscountSerializer(serializers.ModelSerializer):    class Meta:        model = Discount        fields = ['code', 'percentage', 'fixed_amount', 'min_purchase']        def validate(self, data):        """Ensure only one discount type is set"""        percentage = data.get('percentage')        fixed_amount = data.get('fixed_amount')                if percentage and fixed_amount:            raise serializers.ValidationError(                'Cannot set both percentage and fixed amount discount'            )                if not percentage and not fixed_amount:            raise serializers.ValidationError(                'Must set either percentage or fixed amount discount'            )                # Validate discount limits        if percentage and percentage > 100:            raise serializers.ValidationError({                'percentage': 'Discount cannot exceed 100%'            })                min_purchase = data.get('min_purchase', 0)        if fixed_amount and fixed_amount > min_purchase:            raise serializers.ValidationError(                'Fixed discount cannot exceed minimum purchase amount'            )                return data

Example 5: Database Checks:

class EnrollmentSerializer(serializers.ModelSerializer):    class Meta:        model = Enrollment        fields = ['student', 'course', 'semester']        def validate(self, data):        """Check business rules"""        student = data.get('student')        course = data.get('course')                # Check if course is full        if course.enrollments.count() >= course.max_students:            raise serializers.ValidationError(                'Course is full. No seats available.'            )                # Check if student already enrolled        if Enrollment.objects.filter(            student=student,            course=course,            semester=data.get('semester')        ).exists():            raise serializers.ValidationError(                'Student is already enrolled in this course'            )                # Check prerequisites        prerequisites = course.prerequisites.all()        completed = student.completed_courses.all()                if not all(prereq in completed for prereq in prerequisites):            raise serializers.ValidationError(                f'Student has not completed prerequisites: '                f'{", ".join(p.name for p in prerequisites)}'            )                return data

Error Format Options

Simple String:

def validate(self, data):    if invalid:        raise serializers.ValidationError('General error message')    return data # Response:# {"non_field_errors": ["General error message"]}

Field-Specific Errors:

def validate(self, data):    if invalid:        raise serializers.ValidationError({            'field_name': 'Field-specific error',            'another_field': 'Another error'        })    return data # Response:# {#     "field_name": ["Field-specific error"],#     "another_field": ["Another error"]# }

Multiple Errors per Field:

def validate(self, data):    errors = {}        if condition1:        errors['field1'] = ['Error 1', 'Error 2']        if condition2:        errors['field2'] = 'Single error'        if errors:        raise serializers.ValidationError(errors)        return data

Accessing Instance in Validation

Differentiate Create vs Update:

class ArticleSerializer(serializers.ModelSerializer):    class Meta:        model = Article        fields = ['title', 'status', 'published_at']        def validate(self, data):        """Different rules for create vs update"""        status = data.get('status')                # Create: cannot start as published        if not self.instance and status == 'published':            raise serializers.ValidationError({                'status': 'New articles must start as draft'            })                # Update: track status changes        if self.instance:            old_status = self.instance.status            new_status = data.get('status', old_status)                        # Cannot unpublish            if old_status == 'published' and new_status != 'published':                raise serializers.ValidationError({                    'status': 'Cannot unpublish article'                })                        # Set published_at when publishing            if old_status != 'published' and new_status == 'published':                from django.utils import timezone                data['published_at'] = timezone.now()                return data

Custom Validators

Function Validators

Basic Pattern:

def validator_function(value):    """    Custom validator function        Args:        value: The value to validate        Raises:        serializers.ValidationError: If validation fails    """    if invalid_condition:        raise serializers.ValidationError('Error message') # Use in serializerclass MySerializer(serializers.Serializer):    field = serializers.CharField(validators=[validator_function])

Example 1: Even Number:

def validate_even(value):    """Ensure value is even"""    if value % 2 != 0:        raise serializers.ValidationError('Must be an even number') class TicketSerializer(serializers.Serializer):    quantity = serializers.IntegerField(validators=[validate_even])

Example 2: Profanity Filter:

def validate_no_profanity(value):    """Check for profanity in text"""    profanity_list = ['badword1', 'badword2', 'badword3']        value_lower = value.lower()    for word in profanity_list:        if word in value_lower:            raise serializers.ValidationError(                'Content contains inappropriate language'            ) class CommentSerializer(serializers.ModelSerializer):    text = serializers.CharField(validators=[validate_no_profanity])        class Meta:        model = Comment        fields = ['text', 'author']

Example 3: Future Date:

from django.utils import timezone def validate_future_date(value):    """Ensure date is in the future"""    if value <= timezone.now().date():        raise serializers.ValidationError(            'Date must be in the future'        ) class EventSerializer(serializers.ModelSerializer):    event_date = serializers.DateField(validators=[validate_future_date])        class Meta:        model = Event        fields = ['name', 'event_date']

Class-Based Validators

Pattern:

class CustomValidator:    """    Custom validator class    """    def __init__(self, param1, param2):        self.param1 = param1        self.param2 = param2        def __call__(self, value):        if invalid_condition:            raise serializers.ValidationError('Error message') # Use in serializerclass MySerializer(serializers.Serializer):    field = serializers.CharField(        validators=[CustomValidator(param1='value', param2='value')]    )

Example 1: Min Words:

class MinWordsValidator:    """Ensure text has minimum word count"""        def __init__(self, min_words):        self.min_words = min_words        def __call__(self, value):        word_count = len(value.split())                if word_count < self.min_words:            raise serializers.ValidationError(                f'Text must contain at least {self.min_words} words. '                f'Current: {word_count} words.'            ) class ArticleSerializer(serializers.ModelSerializer):    content = serializers.CharField(        validators=[MinWordsValidator(min_words=100)]    )        class Meta:        model = Article        fields = ['title', 'content']

Example 2: File Size Validator:

class MaxFileSizeValidator:    """Ensure file size doesn't exceed limit"""        def __init__(self, max_size_mb):        self.max_size_bytes = max_size_mb * 1024 * 1024        self.max_size_mb = max_size_mb        def __call__(self, value):        if value.size > self.max_size_bytes:            raise serializers.ValidationError(                f'File size cannot exceed {self.max_size_mb}MB. '                f'Current file: {value.size / 1024 / 1024:.2f}MB'            ) class DocumentSerializer(serializers.Serializer):    file = serializers.FileField(        validators=[MaxFileSizeValidator(max_size_mb=10)]    )

Example 3: Allowed Values:

class AllowedValuesValidator:    """Ensure value is in allowed list"""        def __init__(self, allowed_values):        self.allowed_values = allowed_values        def __call__(self, value):        if value not in self.allowed_values:            raise serializers.ValidationError(                f'Invalid value. Allowed: {", ".join(map(str, self.allowed_values))}'            ) class SettingsSerializer(serializers.Serializer):    theme = serializers.CharField(        validators=[AllowedValuesValidator(['light', 'dark', 'auto'])]    )    language = serializers.CharField(        validators=[AllowedValuesValidator(['en', 'es', 'fr', 'de'])]    )

Example 4: Database Uniqueness with Context:

class UniqueForUserValidator:    """Ensure value is unique for current user"""        def __init__(self, queryset, field_name):        self.queryset = queryset        self.field_name = field_name        def __call__(self, value):        # This needs to be set by serializer        user = getattr(self, 'user', None)                if user and self.queryset.filter(            **{self.field_name: value, 'user': user}        ).exists():            raise serializers.ValidationError(                f'You already have an item with this {self.field_name}'            )        def set_context(self, serializer):        """Called by serializer to provide context"""        self.user = serializer.context.get('request').user if serializer.context.get('request') else None class PlaylistSerializer(serializers.ModelSerializer):    name = serializers.CharField(        validators=[            UniqueForUserValidator(                queryset=Playlist.objects.all(),                field_name='name'            )        ]    )        class Meta:        model = Playlist        fields = ['name', 'description']

Reusable Validators Module

validators.py:

from rest_framework import serializers class MinMaxValidator:    """Validate value is between min and max"""        def __init__(self, min_value=None, max_value=None):        self.min_value = min_value        self.max_value = max_value        def __call__(self, value):        if self.min_value is not None and value < self.min_value:            raise serializers.ValidationError(                f'Value must be at least {self.min_value}'            )                if self.max_value is not None and value > self.max_value:            raise serializers.ValidationError(                f'Value cannot exceed {self.max_value}'            ) class RegexValidator:    """Validate value matches regex pattern"""        def __init__(self, pattern, message=None):        import re        self.pattern = re.compile(pattern)        self.message = message or f'Value must match pattern: {pattern}'        def __call__(self, value):        if not self.pattern.match(value):            raise serializers.ValidationError(self.message) class BlacklistValidator:    """Ensure value is not in blacklist"""        def __init__(self, blacklist):        self.blacklist = [item.lower() for item in blacklist]        def __call__(self, value):        if value.lower() in self.blacklist:            raise serializers.ValidationError(                'This value is not allowed'            ) # Usageclass UserSerializer(serializers.ModelSerializer):    username = serializers.CharField(        validators=[            RegexValidator(r'^[a-zA-Z0-9_]+$', 'Username must be alphanumeric'),            BlacklistValidator(['admin', 'root', 'system'])        ]    )    age = serializers.IntegerField(        validators=[MinMaxValidator(min_value=18, max_value=120)]    )        class Meta:        model = User        fields = ['username', 'age']

Conditional Validation

Based on Field Values

Example 1: Required if Another Field Set:

class ProfileSerializer(serializers.ModelSerializer):    company_name = serializers.CharField(required=False, allow_blank=True)    job_title = serializers.CharField(required=False, allow_blank=True)        class Meta:        model = Profile        fields = ['company_name', 'job_title']        def validate(self, data):        """If company_name is set, job_title is required"""        company = data.get('company_name')        job_title = data.get('job_title')                if company and not job_title:            raise serializers.ValidationError({                'job_title': 'Job title is required when company name is provided'            })                return data

Example 2: Different Rules by Status:

class ArticleSerializer(serializers.ModelSerializer):    class Meta:        model = Article        fields = ['title', 'content', 'status', 'featured_image']        def validate(self, data):        """Published articles require featured image"""        status = data.get('status')        featured_image = data.get('featured_image')                if status == 'published' and not featured_image:            raise serializers.ValidationError({                'featured_image': 'Featured image required for published articles'            })                return data

Based on User Context

Example:

class ArticleSerializer(serializers.ModelSerializer):    class Meta:        model = Article        fields = ['title', 'content', 'status']        def validate_status(self, value):        """Only staff can set status to published"""        request = self.context.get('request')                if value == 'published':            if not request or not request.user.is_staff:                raise serializers.ValidationError(                    'Only staff can publish articles'                )                return value

Based on Action (Create vs Update)

Example:

class ProductSerializer(serializers.ModelSerializer):    class Meta:        model = Product        fields = ['name', 'price', 'sku']        def validate_sku(self, value):        """SKU can only be set on creation"""        if self.instance and self.instance.sku != value:            raise serializers.ValidationError(                'SKU cannot be changed after creation'            )                return value        def validate(self, data):        """Different price rules for create vs update"""        price = data.get('price')                if not self.instance:            # Create: price must be > 0            if price <= 0:                raise serializers.ValidationError({                    'price': 'Price must be greater than 0'                })        else:            # Update: price can't decrease by more than 50%            old_price = self.instance.price            if price < old_price * 0.5:                raise serializers.ValidationError({                    'price': 'Price cannot be reduced by more than 50%'                })                return data

Example:

class OrderItemSerializer(serializers.ModelSerializer):    class Meta:        model = OrderItem        fields = ['product', 'quantity']        def validate(self, data):        """Check product stock availability"""        product = data.get('product')        quantity = data.get('quantity')                if product and quantity:            if quantity > product.stock:                raise serializers.ValidationError({                    'quantity': f'Only {product.stock} items available in stock'                })                return data

Validation Error Handling

Catching Validation Errors in Views

Basic Handling:

from rest_framework.views import APIViewfrom rest_framework.response import Responsefrom rest_framework import status class CreateArticleView(APIView):    def post(self, request):        serializer = ArticleSerializer(data=request.data)                if serializer.is_valid():            article = serializer.save()            return Response(                ArticleSerializer(article).data,                status=status.HTTP_201_CREATED            )                # Return validation errors        return Response(            serializer.errors,            status=status.HTTP_400_BAD_REQUEST        )

Custom Error Response:

class CreateArticleView(APIView):    def post(self, request):        serializer = ArticleSerializer(data=request.data)                if serializer.is_valid():            article = serializer.save()            return Response(                {                    'success': True,                    'data': ArticleSerializer(article).data                },                status=status.HTTP_201_CREATED            )                # Custom error format        return Response(            {                'success': False,                'errors': serializer.errors,                'message': 'Validation failed'            },            status=status.HTTP_400_BAD_REQUEST        )

Error Response Format

Standard DRF Format:

{    "field1": ["Error message 1", "Error message 2"],    "field2": ["Error message"],    "non_field_errors": ["General error"]}

Custom Format:

def format_errors(serializer_errors):    """Convert DRF errors to custom format"""    errors = []        for field, messages in serializer_errors.items():        for message in messages if isinstance(messages, list) else [messages]:            errors.append({                'field': field,                'message': message,                'code': 'validation_error'            })        return errors # Usage in viewif not serializer.is_valid():    return Response(        {            'success': False,            'errors': format_errors(serializer.errors)        },        status=status.HTTP_400_BAD_REQUEST    )

Raising ValidationError Manually

In View:

from rest_framework.exceptions import ValidationError class CreateOrderView(APIView):    def post(self, request):        serializer = OrderSerializer(data=request.data)                if serializer.is_valid():            # Additional business logic validation            if not request.user.profile.is_verified:                raise ValidationError({                    'user': 'Account must be verified to place orders'                })                        order = serializer.save()            return Response(OrderSerializer(order).data)                return Response(serializer.errors, status=400)

Advanced Validation Patterns

Async Validation (External API)

Example:

import requestsfrom rest_framework import serializers class AddressSerializer(serializers.Serializer):    street = serializers.CharField()    city = serializers.CharField()    zip_code = serializers.CharField()        def validate(self, data):        """Validate address with external API"""        # Call address validation API        try:            response = requests.post(                'https://api.address-validator.com/validate',                json=data,                timeout=5            )                        if response.status_code == 200:                result = response.json()                if not result['is_valid']:                    raise serializers.ValidationError(                        'Address could not be verified. Please check and try again.'                    )                                # Optionally update data with standardized address                data['street'] = result['standardized']['street']                data['city'] = result['standardized']['city']                data['zip_code'] = result['standardized']['zip_code']            else:                # API error - decide whether to fail or allow                pass                except requests.RequestException:            # Network error - decide whether to fail or allow            pass                return data

Batch Validation

Example:

class BulkArticleSerializer(serializers.Serializer):    articles = ArticleSerializer(many=True)        def validate_articles(self, value):        """Validate batch constraints"""        # Max 100 articles per batch        if len(value) > 100:            raise serializers.ValidationError(                'Maximum 100 articles per batch'            )                # Check for duplicate titles        titles = [article['title'] for article in value]        if len(titles) != len(set(titles)):            raise serializers.ValidationError(                'Duplicate titles found in batch'            )                return value

Staged Validation

Example:

class OrderSerializer(serializers.ModelSerializer):    class Meta:        model = Order        fields = ['items', 'shipping_address', 'payment_method']        def validate(self, data):        """Multi-stage validation"""        errors = {}                # Stage 1: Basic field validation        if not data.get('items'):            errors['items'] = 'At least one item required'                # Stage 2: Business logic validation        items = data.get('items', [])        total = sum(item.price * item.quantity for item in items)                if total < 10:            errors['items'] = 'Minimum order total is $10'                # Stage 3: Availability checks        for item in items:            if item.quantity > item.product.stock:                errors['items'] = f'Insufficient stock for {item.product.name}'                break                # Stage 4: Payment validation        payment_method = data.get('payment_method')        if payment_method == 'credit_card':            # Would validate credit card details            pass                if errors:            raise serializers.ValidationError(errors)                return data

Tóm Tắt Bài 5.2

Trong Bài 5.2 này, bạn đã học:

✅ Validation Flow:

4 levels: Type → Field Validators → Field-Level → Object-Level
Each level serves specific purpose
Order matters for performance

✅ Field-Level Validation:

validate_() pattern
Common patterns: length, pattern, uniqueness, range
Transform values during validation
Access context and other fields

✅ Object-Level Validation:

validate() method for cross-field validation
Multi-field relationships
Business logic validation
Differentiate create vs update

✅ Custom Validators:

Function validators for simple cases
Class-based validators for reusability
Validator parameters and configuration
Reusable validator modules

✅ Conditional Validation:

Based on field values
Based on user context
Based on action (create/update)
Based on related objects

✅ Error Handling:

Standard error format
Custom error responses
Raising ValidationError manually
Format validation errors

✅ Advanced Patterns:

External API validation
Batch validation
Staged validation
Async considerations

Exercises

Exercise 1: User Registration Validator

Create RegistrationSerializer with:

username: alphanumeric, 3-20 chars, not in blacklist ['admin', 'root']
email: valid format, unique, company domain only (@company.com)
password: min 8 chars, must contain uppercase, lowercase, digit
password_confirm: must match password
age: 18-120
phone: validate format +XX-XXX-XXX-XXXX
terms_accepted: must be True

Exercise 2: Event Booking System

Models:

class Event(models.Model):    name = models.CharField(max_length=200)    max_attendees = models.IntegerField()    event_date = models.DateTimeField()    class Booking(models.Model):    event = models.ForeignKey(Event, related_name='bookings')    user = models.ForeignKey(User)    num_tickets = models.IntegerField()

Create BookingSerializer with validation:

Event must be in the future
Check available seats (max_attendees - current bookings)
User can't book same event twice
Max 10 tickets per booking
Booking must be at least 24 hours before event

Exercise 3: Product Discount Validator

Create DiscountSerializer:

class Discount(models.Model):    code = models.CharField(max_length=20)    discount_type = models.CharField(choices=[('percentage', '%'), ('fixed', '$')])    value = models.DecimalField(max_digits=10, decimal_places=2)    min_purchase = models.DecimalField(max_digits=10, decimal_places=2)    max_discount = models.DecimalField(max_digits=10, decimal_places=2, null=True)    valid_from = models.DateTimeField()    valid_until = models.DateTimeField()

Validation rules:

code: uppercase, alphanumeric only
If percentage: value must be 1-100
If fixed: value must be > 0 and < min_purchase
max_discount required if percentage type
valid_until must be after valid_from
Cannot create discount valid for more than 1 year

Exercise 4: Custom Validator Classes

Create these reusable validators:

PasswordStrengthValidator(min_length, require_uppercase, require_digit, require_special)
FileSizeValidator(max_size_mb, allowed_extensions)
DateRangeValidator(min_days_future, max_days_future)
UniqueForUserValidator(model, field_name)

Use them in a serializer of your choice.

Exercise 5: Multi-Step Form Validation

Create wizard-style serializer for job application:

class JobApplicationSerializer(serializers.Serializer):    step = serializers.IntegerField()        # Step 1: Personal Info    full_name = serializers.CharField(required=False)    email = serializers.EmailField(required=False)    phone = serializers.CharField(required=False)        # Step 2: Work Experience    years_experience = serializers.IntegerField(required=False)    current_position = serializers.CharField(required=False)        # Step 3: Documents    resume = serializers.FileField(required=False)    cover_letter = serializers.CharField(required=False)

Validation:

Validate only fields relevant to current step
Step 1 fields required when step=1
Step 2 fields required when step=2
Step 3 fields required when step=3

Next Steps

Trong Bài 5.3, bạn sẽ học:

Nested serializers (relationships)
Writable nested serializers
Depth parameter
Creating/updating nested objects
Many-to-many relationships
Reverse relationships
Performance optimization for nested data

Navigation:

← Bài 5.1: Serializer Fundamentals
Bài 5.2: Field-Level & Object-Level Validation (current)
Bài 5.3: Nested Serializers →

#custom-validators

Field-Level & Object-Level Validation - Phần 2