Sending Emails with Django ModelForms

Based on Django's best practices, I'll analyze your options for sending emails after a successful form submission.

Option 2: Override form_valid in the View (Recommended)

Overriding form_valid in your CreateView is the most Django-idiomatic approach. However, your current implementation has the issue you identified - it sends the email before saving the object.

Here's an improved version:

PYTHONCopied
class BookingRequestView(CreateView):
    form_class = BookingRequestForm
    template_name = "booking/booking_request.html"
    success_url = reverse_lazy("booking-thanks")

    def form_valid(self, form):
        """If the form is valid, save the form and then send an email."""
        # First call the parent's form_valid() which saves the object
        response = super().form_valid(form)
        
        # Now the object is saved and available as self.object
        booking = self.object
        
        # Send email using data from the saved object
        send_mail(
            f"Booking Request: {booking.first_name} {booking.last_name}",
            f"New booking request received from {booking.email}",
            "from@example.com",
            ["to@example.com"],
            fail_silently=False,
        )
        
        return response

This approach:

1. Follows the separation of concerns principle - forms handle data validation and models handle data storage
2. Keeps email sending logic in the view layer where it belongs
3. Ensures the object is saved before sending the email
4. Makes it easier to test and maintain

Option 1: Override save() in ModelForm

While this works, it's generally not recommended to add non-form-related functionality to the form's save() method. The save() method should focus on saving data, not sending emails.

If you do use this approach, you should fix your implementation to handle the commit parameter:

PYTHONCopied
def save(self, commit=True):
    instance = super().save(commit=commit)
    if commit:
        send_mail(
            "Subject here",
            "Here is the message.",
            "from@example.com",
            ["to@example.com"],
            fail_silently=False,
        )
    return instance

Option 3: Signals

Using signals (like post_save) is a valid approach, especially if you need to send emails from multiple places when a booking is created. However, signals can make code flow harder to follow and debug.

Recommendation

Option 2 (with the corrected implementation) is the most Django-idiomatic approach. It:

1. Maintains clear separation of concerns
2. Ensures the object is saved before sending the email
3. Keeps related functionality together in the view
4. Is easier to test and maintain

This approach aligns with how Django's FormView is designed to work, as shown in the documentation examples where custom processing happens in the form_valid method.