Extending ModelAdmin Views with Arbitrary Forms
Ever needed to set up a django admin form with extra validation? For example, you might be creating a form to create multiple objects at once. Perhaps your Client model needs to create a User during the Add view.
Perhaps your Affiliate model needs to generate a Client model and User in the Add view, and allow the user to edit those same models from one Change view.
All of the above can be accomplished with a custom admin form.
Overriding the admin form
ModelAdmins can specify a “form” attribute that overrides the default ModelForm used by the admin add/change views.
We can use this override to set up a ModelForm that intelligently validates the extra non model fields and also saves the related models correctly.
Adding an extra field
class MyForm(forms.ModelForm):
extra_field = forms.CharField()
class Meta:
model = MyModel
class MyAdmin(admin.ModelAdmin):
form = MyForm
Our admin form now contains an extra required field – “extra_field”.
Adding and editing a related model
To add or edit a related model, we need to modify the form to do a useful __init__ and a useful save().
In our __init__ function we need to fill the initial dict with the existing model fields. In our save function we need to write the data to our related model.
You will need to adapt the code to your specific scenario, as a related model can be “related” in any number of ways. A simple foreign key? A reverse relation? It could even be a relation not specified in the model.
class MyForm(forms.ModelForm):
related_model_field1 = forms.CharField()
related_model_field2 = forms.CharField()
class Meta:
model = MyModel
def __init__(self, *args, **kwargs):
super(MyForm, self).__init__(*args, **kwargs)
if self.instance.id:
related_model = get_related_model() # pull related model somehow
self.initial.update({
'related_model_field1': related_model.field1,
'related_model_field2': related_model.field2,
})
def save(self, *args, **kwargs):
if self.instance.id:
related_model = self.instance.related_model
else:
related_model = RelatedModel()
related_model.related_model_field1 = self.cleaned_data.get('related_model_field1')
related_model.related_model_field2 = self.cleaned_data.get('related_model_field2')
related_model.save()
self.instance.related_model = related_model # adapt to your relation
super(MyForm, self).save(*args, **kwargs)
class MyAdmin(admin.ModelAdmin):
form = MyForm
We’re only doing a few things: validating the new fields in your ModelForm, automatically creating the related model OR updating it if it already exists, and finally populating the initial data if the model is being edited.
Shorten the code – use list comprehensions
As we use more and more fields, explicitly specifying each field and value in the __init__ and save function takes more and more lines of code.
I tend to use a dictionary mapping local form field names to the related object field names so that I can simply use a few list comprehensions to handle the __init__ and save() code.
class MyForm(forms.ModelForm):
related_model_field1 = forms.CharField()
related_model_field2 = forms.CharField()
RELATED_FIELD_MAP = {
# map local field names to the object field names.
'related_model_field1': 'field1',
'related_model_field2': 'field2',
}
class Meta:
model = MyModel
def __init__(self, *args, **kwargs):
super(MyForm, self).__init__(*args, **kwargs)
if self.instance.id:
related_model = get_related_model() # pull related model somehow
self.initial.update(
dict([(field, getattr(related_model, target_field) for field, target_field in self.RELATED_FIELD_MAP.iteritems())]))
def save(self, *args, **kwargs):
related_model = self.instance.related_model if self.instance.id else RelatedModel()
[setattr(related_model, target_field, self.cleaned_data.get(field) for
field, target_field in self.RELATED_FIELD_MAP.iteritems()]
related_model.save()
self.instance.related_model = related_model # adapt to your relation..
super(MyForm, self).save(*args, **kwargs)
class MyAdmin(admin.ModelAdmin):
form = MyForm
You can be even more DRY by setting up your RELATED_FIELD_MAP to contain “target_field, forms.CharField()” values and instantiate the form manually with the fields.
Using the concepts from this post, you can use the django admin application to generate much more complex, multi-object edit/add forms that appear as one form.
It’s supremely useful when you still want to use the admin interface for 90% of what you do.
Yuji Tomita 