Form Validation and Processing

Real-World Example: Product Review System

Let's build a complete product review system with validation and processing:

# models.py
from django.db import models
from django.contrib.auth.models import User
from django.core.validators import MinValueValidator, MaxValueValidator

class Product(models.Model):
    name = models.CharField(max_length=200)
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)
    
    def __str__(self):
        return self.name

class Review(models.Model):
    product = models.ForeignKey(Product, on_delete=models.CASCADE, related_name='reviews')
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    rating = models.IntegerField(
        validators=[MinValueValidator(1), MaxValueValidator(5)]
    )
    title = models.CharField(max_length=100)
    comment = models.TextField()
    pros = models.TextField(blank=True)
    cons = models.TextField(blank=True)
    verified_purchase = models.BooleanField(default=False)
    created_at = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        unique_together = ('product', 'user')  # One review per user per product
    
    def __str__(self):
        return f"{self.rating} stars for {self.product.name} by {self.user.username}"
    
    def clean(self):
        super().clean()
        if self.pros and len(self.pros.split()) < 3:
            raise ValidationError({
                'pros': 'Please write at least 3 words for pros section'
            })
        
        if self.cons and len(self.cons.split()) < 3:
            raise ValidationError({
                'cons': 'Please write at least 3 words for cons section'
            })

# forms.py
from django import forms
from .models import Review
import datetime

class ReviewForm(forms.ModelForm):
    confirm_terms = forms.BooleanField(
        required=True,
        label="I confirm this is my honest opinion and I have used this product"
    )
    
    class Meta:
        model = Review
        fields = ['rating', 'title', 'comment', 'pros', 'cons']
        widgets = {
            'comment': forms.Textarea(attrs={'rows': 5}),
            'pros': forms.Textarea(attrs={'rows': 3, 'placeholder': 'What did you like about this product?'}),
            'cons': forms.Textarea(attrs={'rows': 3, 'placeholder': 'What could be improved?'}),
        }
        help_texts = {
            'rating': 'Rate this product from 1 to 5 stars',
            'title': 'Summarize your review in a short title',
        }
    
    def clean_title(self):
        title = self.cleaned_data.get('title')
        
        # Check for all caps titles
        if title and title.isupper():
            raise ValidationError("Please don't use ALL CAPS in your title")
        
        return title
    
    def clean_comment(self):
        comment = self.cleaned_data.get('comment')
        
        # Check minimum length
        if comment and len(comment.split()) < 10:
            raise ValidationError("Your review must be at least 10 words long")
        
        # Check for banned words (simplified example)
        banned_words = ['fake', 'scam', 'awful']
        for word in banned_words:
            if word in comment.lower():
                raise ValidationError(f"Your review contains inappropriate language ('{word}')")
        
        return comment
    
    def clean(self):
        cleaned_data = super().clean()
        rating = cleaned_data.get('rating')
        comment = cleaned_data.get('comment')
        cons = cleaned_data.get('cons')
        
        # If rating is low, make sure cons are provided
        if rating and rating <= 2 and not cons:
            self.add_error('cons', "Please explain what you didn't like about the product")
        
        # Check for review balance
        if rating and comment:
            if rating >= 4 and 'but' in comment.lower() and len(comment.split('but')[1].split()) > len(comment.split()) / 2:
                self.add_error(
                    'comment', 
                    "Your high rating doesn't seem to match your mostly negative comments"
                )
        
        return cleaned_data

# views.py
from django.shortcuts import render, redirect, get_object_or_404
from django.contrib.auth.decorators import login_required
from django.contrib import messages
from .models import Product, Review
from .forms import ReviewForm

@login_required
def add_review(request, product_id):
    product = get_object_or_404(Product, pk=product_id)
    
    # Check if user already reviewed this product
    existing_review = Review.objects.filter(product=product, user=request.user).first()
    if existing_review:
        messages.warning(request, "You've already reviewed this product. You can edit your existing review.")
        return redirect('edit_review', review_id=existing_review.id)
    
    # Check if user purchased the product (in a real system, this would check order history)
    verified_purchase = True  # Simplified for example
    
    if request.method == 'POST':
        form = ReviewForm(request.POST)
        if form.is_valid():
            review = form.save(commit=False)
            review.product = product
            review.user = request.user
            review.verified_purchase = verified_purchase
            review.save()
            
            messages.success(request, "Your review has been submitted. Thank you for your feedback!")
            return redirect('product_detail', product_id=product.id)
    else:
        form = ReviewForm()
    
    return render(request, 'reviews/add_review.html', {
        'form': form,
        'product': product,
        'verified_purchase': verified_purchase,
    })