在表单中使用Django上下文处理器

Question

I have multiple forms to be shown everywhere in my project and hence I read that having a context_processor was the best way to do it. So, I created one inside my app and it looks something like this:

def forms_processor(request):

    name_form = NewNameForm()
    work_form = NewWorkForm()
    address_form = NewAddressForm()

    context = {'name_form': name_form,
           'work_form': work_form,
           'address_form': work_form,
           }
    return context

This works great, I can just use {{name_form}} anywhere in my templates and that renders the form.

Now my question is, where do I validate the form? In my views.py or the context_processors.py ? Right now my views for name_form looks something like this:

def user_profile(request):
    if request.method == 'POST':
        name_form = NewNameForm(request.POST)

        if name_form.is_valid():
            form.save()

    else:
        ctx = {'title': 'Profile', 'active_tab': 'Profile'}

    return render (request, 'user_profile.html', ctx)

This isn't working actually, if I submit an invalid form, it just comes back to the same page and won't show a populated form.

If someone could guide me or redirect me to some docs on this topic, that'd be awesome! Thanks!

Answer 1

The problem is that your processor instantiates the form on each render. Each time you call render, your processor is called, which instantiates a new form and displays THAT form, not the form instance that you created in the view. Therefore, the form being rendered is a blank instance but the form that contains the input and errors was destroyed by garbage collection after finishing your view.

A way I would do this, is passing the form you create in the view back to context before rendering. Pass it in to a context key such as "name_form_filled". Then if that variable is present in the context, don't render "name_form", instead render "name_form_filled".

views.py

def user_profile(request):
    ctx = {}
    if request.method == 'POST':
        name_form = NewNameForm(request.POST)

        if name_form.is_valid():
            name_form.save() # you named this named_form, not form.
            # If you want to redirect to another view when the form is saved successfuly, do it here.
        else:
            ctx["name_form_filled"] = form

    else:
        ctx.update({'title': 'Profile', 'active_tab': 'Profile'})

    return render (request, 'user_profile.html', ctx)

user_profile.html

<div id="form_container">
    {% if name_form_filled %}
    <!-- Render form that has input and errors from previous POST. -->
    {{ name_form_filled }}
    {% else %}
    <!-- render empty initial form. User has not attempted to submit yet. -->
    {{ name_form }}
    {% endif %}
</div>

===========================================================================

Another way you could do this is turn this view into a class based view and inherit a base class based view. This base class will override the get_context_data method and add your three forms. Note that you won't be using the context processor with this methodology so you could get rid of it if wanted in this case.

All views that use your form will extend the base view class. Then, after evaluating your form, if it is invalid, overwrite your name_form context key with the invalid form instance, which will be in your context.

views.py

class BaseView(View):
    def get_context_data(self, *args, **kwargs):
        context = {
            "name_form": NewNameForm(),
            "work_form": NewWorkForm(),
            "address_form": NewAddressForm()
        }
        return context


class UserProfileView(BaseView):
    def get(self, request, *args, **kwargs):
        # Do GET logic here.
        ctx = self.get_context_data(*args, **kwargs) # BaseView.get_context_data will be called here unless you override it in this class.
        ctx.update({'title': 'Profile', 'active_tab': 'Profile'})
        return render (request, 'user_profile.html', ctx)

    def post(self, request, *args, **kwargs):
        # Do POST logic here.
        ctx = self.get_context_data(*args, **kwargs) # BaseView.get_context_data will be called here unless you override it in this class.

        name_form = NewNameForm(request.POST)

        if name_form.is_valid():
            name_form.save()
        else:
            ctx["name_form"] = name_form # will replace the empty form in context with the form instance created in name_form that has input and errors.
        return render (request, 'user_profile.html', ctx)

user_profile.html

<div id="form_container">
    <!-- Will render whatever is in name_form. If this is after the
    user has submitted an invalid form, this form will be populated with input and errors because we overwrote it in the view. -->
    {{ name_form }}
</div>

===========================================================================

I personally think that the first solution is the best but when you start getting more complex, you should probably switch over to the second solution as class based views make complex views way easier.

Answer 2

Direct answer: you validate the form in views.py with is_valid() method. What you need is to populate context with bound form if the form is invalid:

def user_profile(request):
    ctx = {'title': 'Profile', 'active_tab': 'Profile'}

    if request.method == 'POST':
        name_form = NewNameForm(request.POST)
        if name_form.is_valid():
            form.save()
            return redirect(YOUR_REDIRECT_URL) # Always redirect after successful POST
        ctx['form'] = form  # if form is invalid return it with context

    return render (request, 'user_profile.html', ctx)

Read more in documentation .