Bài 13: Model Forms

ModelForm Là Gì?

ModelForm là class kết hợp Django Form với Model, tự động tạo form từ model definition.

# Without ModelForm (manual form)class PostForm(forms.Form):    title = forms.CharField(max_length=200)    slug = forms.SlugField()    content = forms.CharField(widget=forms.Textarea)    published = forms.BooleanField(required=False)    author = forms.ModelChoiceField(queryset=User.objects.all())        def save(self):        post = Post.objects.create(            title=self.cleaned_data['title'],            slug=self.cleaned_data['slug'],            content=self.cleaned_data['content'],            published=self.cleaned_data['published'],            author=self.cleaned_data['author']        )        return post # With ModelForm (automatic)class PostForm(forms.ModelForm):    class Meta:        model = Post        fields = ['title', 'slug', 'content', 'published', 'author'] # Usage is same:form = PostForm(request.POST)if form.is_valid():    post = form.save()  # Automatically creates/updates Post

Lợi Ích của ModelForm

# Benefits:# 1. Automatic field generation from model# 2. Automatic validation based on model constraints# 3. Easy save() method# 4. Less code duplication# 5. Stays in sync with model changes# 6. Built-in support for relationships # Model:class Post(models.Model):    title = models.CharField(max_length=200)    slug = models.SlugField(unique=True)    content = models.TextField()    published = models.BooleanField(default=False)    author = models.ForeignKey(User, on_delete=models.CASCADE)    created = models.DateTimeField(auto_now_add=True) # ModelForm automatically:# - Creates CharField for title (max_length=200)# - Creates SlugField for slug (with unique validation)# - Creates Textarea for content# - Creates CheckboxInput for published# - Creates Select for author (ForeignKey)# - Excludes created (auto_now_add)

Creating ModelForms

Basic ModelForm

# models.pyclass Post(models.Model):    title = models.CharField(max_length=200)    slug = models.SlugField(unique=True)    content = models.TextField()    excerpt = models.CharField(max_length=300, blank=True)    published = models.BooleanField(default=False)    author = models.ForeignKey(User, on_delete=models.CASCADE)    category = models.ForeignKey(Category, on_delete=models.SET_NULL, null=True)    created = models.DateTimeField(auto_now_add=True)    updated = models.DateTimeField(auto_now=True) # forms.pyfrom django import formsfrom .models import Post class PostForm(forms.ModelForm):    class Meta:        model = Post        fields = '__all__'  # Include all fields # views.pydef create_post(request):    if request.method == 'POST':        form = PostForm(request.POST)        if form.is_valid():            post = form.save()            return redirect('post_detail', slug=post.slug)    else:        form = PostForm()        return render(request, 'create_post.html', {'form': form})

Specifying Fields

# Include specific fields onlyclass PostForm(forms.ModelForm):    class Meta:        model = Post        fields = ['title', 'slug', 'content', 'published', 'category'] # Exclude specific fieldsclass PostForm(forms.ModelForm):    class Meta:        model = Post        exclude = ['author', 'created', 'updated'] # Include all except someclass PostForm(forms.ModelForm):    class Meta:        model = Post        fields = '__all__'        exclude = ['created', 'updated'] # Field orderclass PostForm(forms.ModelForm):    class Meta:        model = Post        fields = ['title', 'category', 'content', 'excerpt', 'published', 'slug']        # Fields appear in this order

Custom Field Labels and Help Text

class PostForm(forms.ModelForm):    class Meta:        model = Post        fields = ['title', 'slug', 'content', 'published']                # Custom labels        labels = {            'title': 'Post Title',            'slug': 'URL Slug',            'content': 'Post Content',            'published': 'Publish Now?',        }                # Custom help text        help_texts = {            'slug': 'URL-friendly version of title. Leave blank to auto-generate.',            'content': 'Main content of your post. Supports Markdown.',            'published': 'Check this to make the post visible immediately.',        }                # Custom error messages        error_messages = {            'title': {                'max_length': 'Title is too long! Maximum 200 characters.',                'required': 'Please provide a title for your post.',            },            'slug': {                'unique': 'This slug is already taken. Please choose another.',            },        }

Customizing Widgets

class PostForm(forms.ModelForm):    class Meta:        model = Post        fields = ['title', 'slug', 'content', 'excerpt', 'published']                # Customize widgets        widgets = {            'title': forms.TextInput(attrs={                'class': 'form-control',                'placeholder': 'Enter post title'            }),            'slug': forms.TextInput(attrs={                'class': 'form-control',                'placeholder': 'post-slug'            }),            'content': forms.Textarea(attrs={                'class': 'form-control',                'rows': 10,                'placeholder': 'Write your content here...'            }),            'excerpt': forms.Textarea(attrs={                'class': 'form-control',                'rows': 3,                'placeholder': 'Short excerpt (optional)'            }),            'published': forms.CheckboxInput(attrs={                'class': 'form-check-input'            }),        }

from django.forms import widgets class ArticleForm(forms.ModelForm):    class Meta:        model = Article        fields = '__all__'        widgets = {            # Date/Time widgets            'publish_date': widgets.DateInput(attrs={                'type': 'date',                'class': 'form-control'            }),            'publish_time': widgets.TimeInput(attrs={                'type': 'time',                'class': 'form-control'            }),                        # Choice widgets            'status': widgets.RadioSelect(),  # Radio buttons            'categories': widgets.CheckboxSelectMultiple(),  # Checkboxes                        # File widgets            'thumbnail': widgets.ClearableFileInput(attrs={                'class': 'form-control'            }),                        # Hidden widget            'author': widgets.HiddenInput(),                        # Rich text editor (with custom widget)            'content': widgets.Textarea(attrs={                'class': 'tinymce',  # For TinyMCE integration                'rows': 20            }),                        # Password widget            'password': widgets.PasswordInput(attrs={                'class': 'form-control'            }),        }

from django.forms import widgets class ColorPickerWidget(widgets.TextInput):    input_type = 'color'    template_name = 'widgets/color_picker.html' class TagWidget(widgets.TextInput):    """Widget for comma-separated tags"""    def __init__(self, attrs=None):        default_attrs = {'placeholder': 'tag1, tag2, tag3'}        if attrs:            default_attrs.update(attrs)        super().__init__(default_attrs) class PostForm(forms.ModelForm):    class Meta:        model = Post        fields = ['title', 'content', 'color', 'tags']        widgets = {            'color': ColorPickerWidget(),            'tags': TagWidget(attrs={'class': 'form-control'}),        }

Field Customization

Overriding Fields

class PostForm(forms.ModelForm):    # Override field completely    title = forms.CharField(        max_length=150,  # Different from model        widget=forms.TextInput(attrs={'class': 'form-control'}),        help_text='Enter a catchy title'    )        # Add field not in model    send_notification = forms.BooleanField(        required=False,        help_text='Notify followers about this post'    )        # Override with different field type    content = forms.CharField(        widget=forms.Textarea(attrs={            'class': 'markdown-editor',            'data-provide': 'markdown'        })    )        class Meta:        model = Post        fields = ['title', 'slug', 'content', 'published']        def save(self, commit=True):        post = super().save(commit=False)                # Handle custom field        if self.cleaned_data.get('send_notification'):            notify_followers(post)                if commit:            post.save()                return post

Dynamic Field Modification

class PostForm(forms.ModelForm):    class Meta:        model = Post        fields = ['title', 'content', 'category', 'published']        def __init__(self, *args, **kwargs):        # Get user from kwargs        user = kwargs.pop('user', None)        super().__init__(*args, **kwargs)                # Modify queryset based on user        if user:            # Only show user's categories            self.fields['category'].queryset = Category.objects.filter(                owner=user            )                # Make field required conditionally        if self.instance.pk:  # Editing existing            self.fields['slug'].required = False                # Add CSS classes to all fields        for field_name, field in self.fields.items():            field.widget.attrs['class'] = 'form-control'                # Disable field for non-admin users        if user and not user.is_staff:            self.fields['published'].disabled = True # Usage in view:def create_post(request):    if request.method == 'POST':        form = PostForm(request.POST, user=request.user)        if form.is_valid():            post = form.save()            return redirect('post_detail', slug=post.slug)    else:        form = PostForm(user=request.user)        return render(request, 'create_post.html', {'form': form})

Saving ModelForms

Basic Save

# Create new objectform = PostForm(request.POST)if form.is_valid():    post = form.save()  # Creates and returns Post object # Update existing objectpost = Post.objects.get(pk=1)form = PostForm(request.POST, instance=post)if form.is_valid():    post = form.save()  # Updates existing Post

Save with commit=False

def create_post(request):    if request.method == 'POST':        form = PostForm(request.POST)        if form.is_valid():            # Save without committing to database            post = form.save(commit=False)                        # Modify before saving            post.author = request.user            post.slug = slugify(post.title)                        # Now save to database            post.save()                        # Save many-to-many relationships            form.save_m2m()                        return redirect('post_detail', slug=post.slug)    else:        form = PostForm()        return render(request, 'create_post.html', {'form': form})

Custom Save Method

class PostForm(forms.ModelForm):    class Meta:        model = Post        fields = ['title', 'content', 'category', 'published']        def save(self, commit=True):        post = super().save(commit=False)                # Auto-generate slug        if not post.slug:            post.slug = slugify(post.title)                # Auto-generate excerpt if empty        if not post.excerpt:            post.excerpt = post.content[:200]                if commit:            post.save()            self.save_m2m()                return post # With additional processingclass ArticleForm(forms.ModelForm):    class Meta:        model = Article        fields = ['title', 'content', 'tags']        def save(self, commit=True):        article = super().save(commit=False)        article.word_count = len(article.content.split())        article.reading_time = article.word_count // 200  # Words per minute                if commit:            article.save()            self.save_m2m()                        # Additional post-save processing            article.generate_thumbnail()            article.notify_subscribers()                return article

ModelForm Validation

Model Validation

# Model with validatorsfrom django.core.validators import MinValueValidator, MaxValueValidator class Product(models.Model):    name = models.CharField(max_length=200)    price = models.DecimalField(        max_digits=10,        decimal_places=2,        validators=[MinValueValidator(0.01)]    )    stock = models.IntegerField(        validators=[MinValueValidator(0), MaxValueValidator(10000)]    ) # ModelForm automatically uses model validatorsclass ProductForm(forms.ModelForm):    class Meta:        model = Product        fields = ['name', 'price', 'stock']        # Model validators are automatically applied    # No need to repeat validation logic

Custom Validation in ModelForm

class PostForm(forms.ModelForm):    class Meta:        model = Post        fields = ['title', 'slug', 'content', 'published']        def clean_slug(self):        slug = self.cleaned_data['slug']                # Check if slug already exists (excluding current instance)        qs = Post.objects.filter(slug=slug)        if self.instance.pk:            qs = qs.exclude(pk=self.instance.pk)                if qs.exists():            raise forms.ValidationError('This slug is already taken.')                return slug        def clean_title(self):        title = self.cleaned_data['title']                # Check for profanity        if contains_profanity(title):            raise forms.ValidationError('Title contains inappropriate content.')                return title        def clean(self):        cleaned_data = super().clean()        title = cleaned_data.get('title')        content = cleaned_data.get('content')                # Cross-field validation        if title and content:            if title.lower() in content.lower():                self.add_error('title', 'Title should not appear in content.')                # Validate published posts        if cleaned_data.get('published'):            if not content or len(content) < 100:                raise forms.ValidationError(                    'Published posts must have at least 100 characters.'                )                return cleaned_data

Unique Validation

# Model with unique constraintclass Post(models.Model):    slug = models.SlugField(unique=True)    title = models.CharField(max_length=200)        class Meta:        unique_together = [['title', 'author']] # ModelForm handles unique validationclass PostForm(forms.ModelForm):    class Meta:        model = Post        fields = ['title', 'slug', 'author']        # Automatically validates:    # - slug is unique    # - title+author combination is unique        # For custom unique validation:    def clean(self):        cleaned_data = super().clean()                # Custom unique check        title = cleaned_data.get('title')        author = cleaned_data.get('author')                if title and author:            qs = Post.objects.filter(title=title, author=author)            if self.instance.pk:                qs = qs.exclude(pk=self.instance.pk)                        if qs.exists():                raise forms.ValidationError(                    'You already have a post with this title.'                )                return cleaned_data

Working with Relationships

ForeignKey Fields

class Post(models.Model):    title = models.CharField(max_length=200)    author = models.ForeignKey(User, on_delete=models.CASCADE)    category = models.ForeignKey(Category, on_delete=models.SET_NULL, null=True) class PostForm(forms.ModelForm):    class Meta:        model = Post        fields = ['title', 'author', 'category']                # Customize ForeignKey widget        widgets = {            'author': forms.Select(attrs={'class': 'form-control'}),            'category': forms.RadioSelect(),  # Radio buttons instead of dropdown        }        def __init__(self, *args, **kwargs):        super().__init__(*args, **kwargs)                # Filter choices        self.fields['category'].queryset = Category.objects.filter(active=True)                # Set empty label        self.fields['category'].empty_label = "Select Category"                # Make optional with better label        self.fields['category'].required = False        self.fields['category'].empty_label = "No Category"

ManyToMany Fields

class Post(models.Model):    title = models.CharField(max_length=200)    tags = models.ManyToManyField(Tag) class PostForm(forms.ModelForm):    class Meta:        model = Post        fields = ['title', 'tags']        widgets = {            'tags': forms.CheckboxSelectMultiple(),        }        def __init__(self, *args, **kwargs):        super().__init__(*args, **kwargs)                # Order tags alphabetically        self.fields['tags'].queryset = Tag.objects.order_by('name')                # Set help text        self.fields['tags'].help_text = 'Select all that apply' # Handling ManyToMany with commit=Falsedef create_post(request):    if request.method == 'POST':        form = PostForm(request.POST)        if form.is_valid():            post = form.save(commit=False)            post.author = request.user            post.save()                        # IMPORTANT: Must save m2m after object is saved            form.save_m2m()                        return redirect('post_detail', slug=post.slug)    else:        form = PostForm()        return render(request, 'create_post.html', {'form': form})

Custom ManyToMany Handling

class PostForm(forms.ModelForm):    # Override ManyToMany field    tags = forms.CharField(        required=False,        help_text='Enter tags separated by commas',        widget=forms.TextInput(attrs={'placeholder': 'python, django, web'})    )        class Meta:        model = Post        fields = ['title', 'content', 'tags']        def __init__(self, *args, **kwargs):        super().__init__(*args, **kwargs)                # Set initial value from existing tags        if self.instance.pk:            self.initial['tags'] = ', '.join(                self.instance.tags.values_list('name', flat=True)            )        def save(self, commit=True):        post = super().save(commit=False)                if commit:            post.save()                # Handle tags        if self.cleaned_data.get('tags'):            tag_names = [                name.strip()                 for name in self.cleaned_data['tags'].split(',')                if name.strip()            ]                        # Get or create tags            tags = []            for name in tag_names:                tag, created = Tag.objects.get_or_create(                    name=name,                    defaults={'slug': slugify(name)}                )                tags.append(tag)                        # Set tags            post.tags.set(tags)                return post

Inline Formsets

Basic Inline Formset

from django.forms import inlineformset_factory # Modelsclass Author(models.Model):    name = models.CharField(max_length=100) class Book(models.Model):    author = models.ForeignKey(Author, on_delete=models.CASCADE)    title = models.CharField(max_length=200)    isbn = models.CharField(max_length=13)    published_date = models.DateField() # Create formsetBookFormSet = inlineformset_factory(    Author,  # Parent model    Book,    # Child model    fields=['title', 'isbn', 'published_date'],    extra=3,  # Number of empty forms to display    can_delete=True) # Viewdef edit_author(request, author_id):    author = get_object_or_404(Author, pk=author_id)        if request.method == 'POST':        formset = BookFormSet(request.POST, instance=author)        if formset.is_valid():            formset.save()            return redirect('author_detail', pk=author_id)    else:        formset = BookFormSet(instance=author)        return render(request, 'edit_author.html', {        'author': author,        'formset': formset    })

Formset Template

<!-- edit_author.html --><form method="post">    {% csrf_token %}        <h2>Books by {{ author.name }}</h2>        {{ formset.management_form }}        {% for form in formset %}        <div class="formset-form">            {{ form.id }}                        {% if form.instance.pk %}                <h4>{{ form.instance.title }}</h4>            {% else %}                <h4>New Book</h4>            {% endif %}                        {{ form.as_p }}                        {% if formset.can_delete %}                {{ form.DELETE }}                <label>                    Delete this book                </label>            {% endif %}        </div>    {% endfor %}        <button type="submit">Save Books</button></form>

Bài Tập

Bài 1: Basic ModelForm

Task: Tạo ModelForm cho Product:

# Model:class Product(models.Model):    name = models.CharField(max_length=200)    sku = models.CharField(max_length=50, unique=True)    description = models.TextField()    price = models.DecimalField(max_digits=10, decimal_places=2)    stock = models.IntegerField(default=0)    category = models.ForeignKey(Category, on_delete=models.CASCADE)    active = models.BooleanField(default=True)    created = models.DateTimeField(auto_now_add=True) # Tasks:# 1. Create ProductForm with all fields except 'created'# 2. Customize widgets: description as Textarea with 5 rows# 3. Add custom labels and help text# 4. Auto-generate SKU if not provided (in save method)# 5. Validate price > 0 and stock >= 0

Bài 2: Form with Relationships

Task: Tạo ModelForm cho Order với items:

# Models:class Order(models.Model):    customer = models.ForeignKey(User, on_delete=models.CASCADE)    status = models.CharField(max_length=20, choices=STATUS_CHOICES)    created = models.DateTimeField(auto_now_add=True) class OrderItem(models.Model):    order = models.ForeignKey(Order, on_delete=models.CASCADE)    product = models.ForeignKey(Product, on_delete=models.CASCADE)    quantity = models.IntegerField()    price = models.DecimalField(max_digits=10, decimal_places=2) # Tasks:# 1. Create OrderForm and OrderItemForm# 2. Create inline formset for OrderItems# 3. Validate: quantity > 0, price matches product price# 4. Auto-calculate total in save method# 5. Check product stock availability

Bài 3: Advanced Validation

Task: Tạo event booking form:

# Model:class Event(models.Model):    title = models.CharField(max_length=200)    date = models.DateField()    time = models.TimeField()    venue = models.CharField(max_length=200)    capacity = models.IntegerField()    price = models.DecimalField(max_digits=8, decimal_places=2) class Booking(models.Model):    event = models.ForeignKey(Event, on_delete=models.CASCADE)    customer = models.ForeignKey(User, on_delete=models.CASCADE)    tickets = models.IntegerField()    booking_date = models.DateTimeField(auto_now_add=True) # Tasks:# 1. Create BookingForm# 2. Validate: event date not in past# 3. Check available capacity# 4. Prevent duplicate bookings (same user, same event)# 5. Calculate total price based on tickets# 6. Send confirmation email after booking

Bài 4: Dynamic Form

Task: Tạo profile form với conditional fields:

# Model:class Profile(models.Model):    user = models.OneToOneField(User, on_delete=models.CASCADE)    account_type = models.CharField(        max_length=20,        choices=[('personal', 'Personal'), ('business', 'Business')]    )    bio = models.TextField(blank=True)    # Personal fields    birth_date = models.DateField(null=True, blank=True)    # Business fields    company_name = models.CharField(max_length=200, blank=True)    tax_id = models.CharField(max_length=50, blank=True) # Tasks:# 1. Create ProfileForm# 2. Show birth_date only for personal accounts# 3. Show company_name and tax_id only for business accounts# 4. Make conditional fields required based on account_type# 5. Validate tax_id format for business accounts

Tài Liệu Tham Khảo

Previous: Bài 12: Forms | Next: Bài 14: User Authentication

#modelform

Django Model Forms