Form-Handling CBVs: Create and Update

From Manual Logic to Generic Views

Remember the form-handling pattern from our last lesson?

# The pattern we used in our function-based view
def create_project(request):
    if request.method == 'POST':
        form = ProjectForm(request.POST) 
        if form.is_valid():
            form.save()
            return redirect('some_success_url') 
    else:
        form = ProjectForm()

    context = {'form': form}
    return render(request, 'portfolio/project_form.html', context)

This "display form on GET, process data on POST" cycle is extremely common. The Django core developers recognized this and created a set of generic views to handle it automatically.

CreateView and UpdateView are two of the most important "generic editing views".

Let's dive into how to use them.

1. Creating Objects with CreateView

CreateView is designed for one specific job: presenting a blank form to create a new object and saving that object to the database upon submission. It handles the entire GET/POST cycle for you.

To see how CreateView simplifies the process compared to a FormView (which is conceptually similar to our manual function-based view), watch the following video.

Implementing ProjectCreateView

Let's refactor our create_project function from the last lesson into a CreateView. In your views.py, you would write:

# portfolio/views.py
from django.urls import reverse_lazy
from django.views.generic.edit import CreateView
from .models import Project
from .forms import ProjectForm  # Assuming you have a ProjectForm

class ProjectCreateView(CreateView):
    model = Project
    form_class = ProjectForm
    template_name = 'portfolio/project_form.html'
    success_url = reverse_lazy('project-list') # URL name for your project list page

That's it! This class replaces the entire create_project function. Let's break down the attributes:

• model = Project: Tells the view which model it will be creating instances of.
• form_class = ProjectForm: Specifies the ModelForm to use. Alternatively, you can omit form_class and use fields = ['title', 'description', ...] to have Django create a ModelForm for you on the fly. Since we already created ProjectForm, using form_class is appropriate.
• template_name = 'portfolio/project_form.html': Specifies which template to render. If you omit this, Django will look for a template named project_form.html (the model's name in lowercase, followed by _form.html).
• success_url = reverse_lazy('project-list'): Defines where to redirect the user after the form is successfully submitted. reverse_lazy is used instead of reverse because the URL patterns might not be loaded yet when this class is defined.

Your URLconf would point to this view like so:

# portfolio/urls.py
from django.urls import path
from .views import ProjectCreateView

urlpatterns = [
    # ... other urls
    path('project/create/', ProjectCreateView.as_view(), name='project-create'),
]

Notice the .as_view() method, which is required to use a class-based view in a URL pattern.

2. Editing Objects with UpdateView

UpdateView is the sibling of CreateView. It's designed to display a form pre-filled with an existing object's data and to save the changes upon submission.

The main difference is that UpdateView needs to know which specific object to edit. This is typically done by passing a primary key (pk) or a slug in the URL.

The following video explains this core difference and walks through a full implementation.

Implementing ProjectUpdateView

An UpdateView is configured almost identically to a CreateView, but it's linked to a URL that captures the object's identifier.

Step 1: The URL
Your URL pattern needs to capture the primary key of the project you want to edit.

# portfolio/urls.py
path('project/<int:pk>/update/', ProjectUpdateView.as_view(), name='project-update'),

The <int:pk> part is crucial. It tells Django to match an integer in the URL and pass it to the view as a keyword argument named pk. The view uses this pk to fetch the correct Project object.

Step 2: The View
The view itself looks very familiar.

# portfolio/views.py
from django.views.generic.edit import UpdateView

class ProjectUpdateView(UpdateView):
    model = Project
    form_class = ProjectForm
    template_name = 'portfolio/project_form.html'
    success_url = reverse_lazy('project-list')

This view will:

1. On a GET request, use the pk from the URL to retrieve the corresponding Project object.
2. Populate an instance of ProjectForm with this object's data.
3. Render the project_form.html template with the pre-filled form.
4. On a POST request, it does the same, but also validates the submitted data and saves the changes to the existing object before redirecting.

One of the most elegant parts of this system is that you can use the exact same template (project_form.html) for both creating and updating objects. CreateView passes an empty form to it, while UpdateView passes a pre-filled one.

3. A Complete Text-Based Example

Videos are great for seeing things in action, but a complete, documented code example is essential for reference. The MDN web docs provide an excellent tutorial that puts all these pieces together.

4. A More DRY Approach: get_absolute_url()

You might have noticed that we repeated the success_url in both ProjectCreateView and ProjectUpdateView. Django provides a more elegant way to handle this, adhering to the "Don't Repeat Yourself" (DRY) principle.

You can define a get_absolute_url() method on your model. This method tells Django how to calculate the canonical URL for an object. CreateView and UpdateView will automatically use this URL for redirection upon success, allowing you to remove the success_url attribute from your views.

Here's how you'd apply it to our Project model:

# portfolio/models.py
from django.db import models
from django.urls import reverse

class Project(models.Model):
    # ... your fields ...

    def get_absolute_url(self):
        """Returns the URL to access a detail record for this project."""
        return reverse('project-detail', args=[str(self.id)])

With this method on your model, your views become even leaner:

# portfolio/views.py

class ProjectCreateView(CreateView):
    model = Project
    form_class = ProjectForm
    template_name = 'portfolio/project_form.html'
    # success_url is no longer needed!

class ProjectUpdateView(UpdateView):
    model = Project
    form_class = ProjectForm
    template_name = 'portfolio/project_form.html'
    # success_url is also no longer needed! It will redirect to the object's detail page.

Conclusion

In this lesson, you've moved from manual form processing to leveraging Django's powerful generic editing views. This is a significant step toward writing professional, maintainable Django code.

Key Takeaways:

• CreateView and UpdateView abstract away the common logic for handling form submissions.
• They are configured via class attributes like model, form_class (or fields), and template_name.
• UpdateView requires an identifier (like <int:pk>) in the URL pattern to fetch the correct object for editing.
• You can often use the same template for both CreateView and UpdateView.
• Defining a get_absolute_url() method on your model is a best practice that makes your views more concise by automatically handling the success redirect.

You now have a solid foundation for creating and updating data. In our next lesson, we will explore how to process form submissions and handle validation within CBVs, which allows you to run custom logic when a form is saved, such as associating the newly created object with the currently logged-in user.