掌握 Django 表單驗證：深入了解自定義驗證器

            # In a validators.py file within your Django app
from django.core.exceptions import ValidationError
from django.utils.translation import gettext_lazy as _
            

              
                Copy
              
            
          

            def validate_min_words(value):
    """Validates that the text has at least 10 words."""
    word_count = len(str(value).split())
    if word_count < 10:
        raise ValidationError(
            _('Please provide more detailed feedback. A minimum of 10 words is required.'),
            code='min_words'
        )

            

              
                Copy
              
            
          

            # In your forms.py
from django import forms
from .validators import validate_min_words

class FeedbackForm(forms.Form):
    email = forms.EmailField()
    feedback_text = forms.CharField(
        widget=forms.Textarea,
        validators=[validate_min_words] # Attaching the validator
    )

            

              
                Copy
              
            
          

            # In your validators.py
BANNED_USERNAMES = ['admin', 'root', 'support', 'contact', 'webmaster']

def validate_banned_username(value):
    """Raises a ValidationError if the username is in the banned list."""
    if value.lower() in BANNED_USERNAMES:
        raise ValidationError(
            _('This username is reserved and cannot be used.'),
            code='reserved_username'
        )

            

              
                Copy
              
            
          

            # In your validators.py
from datetime import date
from django.utils.deconstruct import deconstructible

@deconstructible
class MinimumAgeValidator:
    """Validates that the user is at least a certain age."""
    def __init__(self, min_age):
        self.min_age = min_age

    def __call__(self, value):
        today = date.today()
        # Calculate age based on the year difference, then adjust for birthday not yet passed this year
        age = today.year - value.year - ((today.month, today.day) < (value.month, value.day))
        if age < self.min_age:
            raise ValidationError(
                _('You must be at least %(min_age)s years old to register.'),
                params={'min_age': self.min_age},
                code='min_age'
            )

    def __eq__(self, other):
        return isinstance(other, MinimumAgeValidator) and self.min_age == other.min_age

            

              
                Copy
              
            
          

            # In your forms.py
from django import forms
from .validators import MinimumAgeValidator

class RegistrationForm(forms.Form):
    username = forms.CharField()
    # We can instantiate the validator with our desired age
    date_of_birth = forms.DateField(validators=[MinimumAgeValidator(18)])

            

              
                Copy
              
            
          

            # In your forms.py
from django import forms
from django.core.exceptions import ValidationError
from django.utils.translation import gettext_lazy as _

class InvitationForm(forms.Form):
    email = forms.EmailField()
    invitation_code = forms.CharField()

    def clean_invitation_code(self):
        # The data for the field is in self.cleaned_data
        data = self.cleaned_data['invitation_code']

        if "-PROMO-" not in data:
            raise ValidationError(
                _("Invalid invitation code. The code must be a promotional code."),
                code='not_promo_code'
            )
        
        # Always return the cleaned data!
        return data

            

              
                Copy
              
            
          

            # In your forms.py
class EventBookingForm(forms.Form):
    event_name = forms.CharField()
    start_date = forms.DateField()
    end_date = forms.DateField()

    def clean(self):
        # Super() is called first to get the cleaned_data from the parent.
        cleaned_data = super().clean()

        start_date = cleaned_data.get("start_date")
        end_date = cleaned_data.get("end_date")

        # Check if both fields are present before comparing
        if start_date and end_date:
            if end_date < start_date:
                # Associate the error with the 'end_date' field
                self.add_error('end_date', _("The end date cannot be before the start date."))
                # You can also associate it with the form in general (a non-field error)
                # self.add_error(None, _("Invalid date range provided."))
        
        return cleaned_data

            

              
                Copy
              
            
          

            # In your models.py
from django.db import models
from .validators import validate_banned_username

class UserProfile(models.Model):
    username = models.CharField(
        max_length=150,
        unique=True,
        validators=[validate_banned_username] # Validator applied here
    )
    # ... other fields

            

              
                Copy
              
            
          

            # In your test_validators.py
from django.test import TestCase
from django.core.exceptions import ValidationError
from .validators import validate_min_words, MinimumAgeValidator
from datetime import date, timedelta

class ValidatorTests(TestCase):

    def test_min_words_validator_valid(self):
        # This should not raise an error
        try:
            validate_min_words("This is a perfectly valid sentence with more than ten words.")
        except ValidationError:
            self.fail("validate_min_words() raised ValidationError unexpectedly!")

    def test_min_words_validator_invalid(self):
        # This should raise an error
        with self.assertRaises(ValidationError):
            validate_min_words("Too short.")

    def test_minimum_age_validator_valid(self):
        validator = MinimumAgeValidator(18)
        eighteen_years_ago = date.today() - timedelta(days=18*365 + 4) # Add leap years
        try:
            validator(eighteen_years_ago)
        except ValidationError:
            self.fail("MinimumAgeValidator raised ValidationError unexpectedly!")

    def test_minimum_age_validator_invalid(self):
        validator = MinimumAgeValidator(18)
        seventeen_years_ago = date.today() - timedelta(days=17*365)
        with self.assertRaises(ValidationError):
            validator(seventeen_years_ago)

            

              
                Copy
              
            
          

            class MyForm(forms.Form):
    email = forms.EmailField(
        error_messages={
            'required': _('Please enter your email address.'),
            'invalid': _('Please enter a valid email address format.')
        }
    )

            

              
                Copy