Dynamically get template name in bound Django form

Question

I am trying to render a Django contact form on any arbitrary page. I am doing it with a request context processor and a template include. This allows me to display the form fine anywhere I want. Then I have a special URL that accepts POST requests (on GET, I just redirect them). If the form is valid, I send an email, and redirect to a success page. On form invalid, I know to pass the form bound with errors, but...I don't know which template to specify because the form is an include and the parent template could be anywhere.

The only way to get something in a Django view is from the request. I can get the path, and with more work, probably the original view from where the POST came from, but that doesn't get me the template.

# urls.py
url(r'^services/$', 'website.views.services', name='services'),
url(r'^services/contact/$', 'website.views.services_contact', name='services_contact'),
url(r'^services/contact/done/$', 'website.views.services_contact_done', name='services_contact_done')


# views.py

class ServicesView(TemplateView):
    template_name = 'services/services.html'

services = ServicesView.as_view()

class ServicesContactView(View):

    def get(self, request, *args, **kwargs):
        return redirect('services')

    def post(self, request, *args, **kwargs):
        form = ContactForm(request.POST)
        if form.is_valid():
            form.send_email()
            return redirect('services_contact_done')
        else:
            return render(request, ????, {'contact_form': form})

services_contact = ServicesContactView.as_view()


# contact.html

<h2>Contact me</h2>
<p>Enter your email to receive your questionnaire</p>

<form action="{% url 'services_contact' %}" method="post">

    {% csrf_token %}

    {% if contact_form.non_field_errors %}
    {{ contact_form.non_field_errors }}
    {% endif %}

    {{ contact_form.as_p }}

    <button type="submit" name="submit">Send questionnaire</button>

</form>

# home.html

{% extends "base.html" %}
{% block content %}
<h1>{{ site.name }}</h1>
{% include "services/contact.html" %}
{% endblock %}

The typical Django form view is somewhat silent on form invalid in that its scenario is mostly similar to an unbound form, so it's all just render in the end. My scenario is different due to the template include.

Answer 1

If anybody needs this answer, I figured it out on my own. It's possible, but a different approach is required. First, a request context processor is not appropriate for this situation. They're fairly dumb because they just get something once and stick it in the context. Their only advantage is their global nature.

My context processor:

def contact_form(request):
    """
    Gets the contact form and adds it to the request context.
    You almost certainly don't want to do this.
    """
    form = ContactForm()

    return {'contact_form': form}

The nature of forms is that they act differently after being processed by Django's validation machinery, specifically ContactForm() is an unbound form and will always be. You don't want to do this (unless you want a form that simply displays but doesn't work). The TEMPLATE_CONTEXT_PROCESSORS should be edited to remove this processor.

Now the burden on displaying the form is back on the view, which also means just about any view must be able to handle POST requests as well. This means that editing each view that wants a contact form is required, but we can use the power of class-based views and mixins to handle most of the repetition.

ServicesView remains almost the same as a TemplateView, except with a mixin that will handle the form. This way, the template name always remains the same (my original problem), but with additional form power.

class ServicesView(ContactMixin, TemplateView):
    template_name = 'services/services.html'

services = ServicesView.as_view()

ContactMixin uses FormMixin, to create and display a form, and ProcessFormView to handle the GET and POST requests for the form. And because the form's nature changes with different kinds of requests (unsubmitted, submitted and invalid, submitted and valid), get_context_data needs to be updated with the correct form class instance. Lastly, we probably want to prefix (namespace) our form because it can can be used anywhere, and we want to avoid conflicts when another possible form can POST to the same view. Thus, the mixin is:

class ContactMixin(FormMixin, ProcessFormView):
    form_class = ContactForm
    success_url = reverse_lazy('contact_done')

    def get_form_kwargs(self):
        kwargs = super(ContactMixin, self).get_form_kwargs()
        kwargs['prefix'] = 'contact'
        return kwargs

    def get_context_data(self, **kwargs):
        context = super(ContactMixin, self).get_context_data(**kwargs)
        form_class = self.get_form_class()
        context['contact_form'] = self.get_form(form_class)
        return context

    def form_valid(self, form):
        form.send_email()
        return super(ContactMixin, self).form_valid(form)

The subtleties of self.get_form_class() were almost lost on me if it were not for an example in the docs (of what not to do, heh) and another StackOverflow answer, where I would've usually just said self.form_class, which ignores the processing of the form.

Now I simply add ContactMixin to any view and {% include "includes/contact.html" %} to any template.

Answer 2

You could set up a session variable every time you render a template and use it afterwards when you need it :

request.session['template']="nameOfTemplate"

.

return render(request, request.session.get('template', 'default.html'), {'contact_form': form})

I know it requires to write a line of code every time you render a template, but that's the best solution I could think of.