Class Based Views

While django-polymorphic provides full admin integration, you might want to build front-end views that allow users to create polymorphic objects. Since a single URL cannot easily handle different form fields for different models, the best approach is a two-step process:

1. Step 1: Let the user choose the desired type.

2. Step 2: Display the form for that specific type.

Tip

The code for this example can be found here.

This example uses model labels (e.g., app.ModelName) to identify the selected type. Assume we have the following models:

from django.db import models
from polymorphic.models import PolymorphicModel


class Project(PolymorphicModel):
    topic = models.CharField(max_length=30)


class ArtProject(Project):
    artist = models.CharField(max_length=30)


class ResearchProject(Project):
    supervisor = models.CharField(max_length=30)

Step 1: Selecting the Type

Create a form that allows users select the desired model type. You can use a simple choice field for this.

from django.apps import apps
from django.shortcuts import redirect
from django.urls import reverse
from django.views.generic import FormView, CreateView
from .models import Project, ArtProject, ResearchProject

from django import forms
from django.utils.translation import gettext_lazy as _


class ProjectTypeChoiceForm(forms.Form):
    model_type = forms.ChoiceField(
        label=_("Project Type"),
        widget=forms.RadioSelect(attrs={"class": "radiolist"}),
    )


class ProjectTypeSelectView(FormView):
    form_class = ProjectTypeChoiceForm
    template_name = "project_type_select.html"

    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        # Build choices using model labels: [(model_label, verbose_name), ...]
        choices = [
            (model._meta.label, model._meta.verbose_name)
            for model in [ArtProject, ResearchProject]
        ]
        kwargs["initial"] = {"model_type": choices[0][0] if choices else None}
        return kwargs

    def get_form(self, form_class=None):
        form = super().get_form(form_class)
        # Populate the choices for the form using model labels
        choices = [
            (model._meta.label, model._meta.verbose_name)
            for model in [ArtProject, ResearchProject]
        ]
        form.fields["model_type"].choices = choices
        return form

    def form_valid(self, form):
        model_label = form.cleaned_data["model_type"]
        return redirect(f"{reverse('project-create')}?model={model_label}")

Your template project_type_select.html, might look like this:

<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Next</button>
</form>

Step 2: Displaying the Form

The creation view needs to dynamically select the correct form class based on the chosen model label.

class ProjectCreateView(CreateView):
    model = Project
    template_name = "project_form.html"

    def get_success_url(self):
        return reverse("project-select")

    def get_form_class(self):
        # Get the requested model label from query parameter
        model_label = self.request.GET.get("model")
        if not model_label:
            # Fallback or redirect to selection view
            return super().get_form_class()

        # Get the model class using the app registry
        model_class = apps.get_model(model_label)

        # Create a form for this model
        # You can also use a factory or a dict mapping if you have custom forms
        class SpecificForm(forms.ModelForm):
            class Meta:
                model = model_class
                fields = "__all__"  # Or specify fields

        return SpecificForm

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        # Pass the model label to the template so it can be preserved
        # in the form action
        context["model_label"] = self.request.GET.get("model")
        return context

In your template project_form.html, make sure to preserve the model parameter:

<form method="post" action=".?model={{ model_label }}">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Save</button>
</form>

And our urls might look like this:

from django.urls import path
from .views import ProjectTypeSelectView, ProjectCreateView

urlpatterns = [
    path("select/", ProjectTypeSelectView.as_view(), name="project-select"),
    path("create/", ProjectCreateView.as_view(), name="project-create"),
]

Using extra_views

If you are using django-extra-views, django-polymorphic provides mixins to help with formsets. See polymorphic.contrib.extra_views for more details.