code.random() » newforms http://code.pui.ch Random code-snippets and tips Thu, 19 Jan 2012 07:09:51 +0000 http://wordpress.org/?v=2.9.2 en hourly 1 Using djangos newforms http://code.pui.ch/2007/01/07/using-djangos-newforms/ http://code.pui.ch/2007/01/07/using-djangos-newforms/#comments Sun, 07 Jan 2007 20:34:31 +0000 philipp.keller http://code.pui.ch/2007/01/07/using-djangos-newforms/ If you start a django-app just now (January 2007) you are in a dilemma since using the old form engine is discouraged:

If you're starting from scratch, we strongly encourage you not to waste your time learning this

But then, the documentation of new form engine, called "newforms", isn't complete at all.

You may argue «take a framework above 1.0», and you'd probably be right. As I wanted to stick with django, I implemented form handling the hard way by figuring out how to use newforms.

Anyway, as I finally got formhandling working with newforms, I thought I'd share this with you, my fellow readers..

The following code..

screenshot of the form
this examples' form after validating user input
  • ..displays a form
  • ..validates user input
  • ..shows validation errors
  • ..writes the user data into the database


Update: Newforms has been added to Django 0.96 and the api has itself proved to be quite stable. The following examples work out of the box with Django 0.96 so you don't need the patches I mentioned before.

Model

PLAIN TEXT
PYTHON:
  1. class Entry(models.Model):
  2.     title = models.CharField("Titel", maxlength=100)
  3.     detail = models.TextField()
  4.     owner = models.ForeignKey(User, verbose_name="Verfasser", editable=False)
  5.     added = models.DateTimeField("hinzugefügt am", editable=False)
  6.     changed = models.DateTimeField("geändert am", editable=False)
  7.     public = models.BooleanField("Öffentlich")
  8.     category = models.ForeignKey(Category, verbose_name="Kategorie")
  9.  
  10.     def save(self):
  11.         if not self.id:
  12.             self.added = datetime.date.today()
  13.         self.changed = datetime.datetime.today()
  14.         return super(Entry, self).save()

Note that with the editable parameter I define which fields can be edited

Create

PLAIN TEXT
PYTHON:
  1. from django import newforms as forms
  2. from django.newforms import widgets
  3.  
  4. def add_entry(request):
  5.     EntryForm = forms.models.form_for_model(Entry)
  6.     EntryForm.base_fields['detail'].widget = TinyMCE()
  7.  
  8.     if request.method == 'POST':
  9.         form = EntryForm(request.POST)
  10.         if form.is_valid():
  11.             entry = form.save(commit=False)
  12.             entry.owner = request.user
  13.             entry.save()
  14.             return HttpResponseRedirect("/")
  15.  
  16.     else:
  17.         form = EntryForm()
  18.  
  19.     t = loader.get_template('add_entry.html')
  20.  
  21.     c = Context({
  22.         'form': form,
  23.         'html_head': '<script src="/media/tiny_mce/tiny_mce_src.js" type="text/javascript"></script>'
  24.     })
  25.     return HttpResponse(t.render(c))

This code displays the form if called by GET, otherwise its inserting the data (that is: creates an entry) in the database.

A few explanations:

  • line 5: the model is converted into a form class by calling forms.model.form_for_model.
  • line 6: I explicitely want to turn the detail form field into a richtext field (the widget code is taken from here). In future version, there might be the possibility to specify the widget in the model by setting a form_widget= argument.
  • line 11: to alter/extend the data before writing it into the db, use form.clean_data use commit=False and alter the returned model instance and save this instance into the db.
    form.save() returns a model instance also without setting commit to False, this comes in handy if you want to access the just generated primary key.

The rest should be very straightforward.

Update

PLAIN TEXT
PYTHON:
  1. def edit_entry(request, id=None):
  2.     entry = Entry.objects.get(id=id)
  3.     EntryForm = forms.models.form_for_instance(entry)
  4.     EntryForm.fields['detail'].widget = TinyMCE()
  5.  
  6.     if request.method == 'POST':
  7.         form = EntryForm(request.POST)
  8.         if form.is_valid():
  9.             form.save()
  10.             return HttpResponseRedirect("/")
  11.     else:
  12.         form = EntryForm()
  13.  
  14.     t = loader.get_template('add_entry.html')
  15.  
  16.     c = Context({
  17.         'form': form,
  18.         'html_head': '<script src="/media/tiny_mce/tiny_mce_src.js" type="text/javascript"></script>'
  19.     })
  20.     return HttpResponse(t.render(c))

Notice that the only differences to the create view are in line 2/3 (form_for_model becomes form_for_instance) and in omitting the detour via commit=False (since we don't want to set the owner when updating the entry).
Since that's not DRY at all, lets merge those two functions into one.

Create and Update together freehand without a net

PLAIN TEXT
PYTHON:
  1. def add_edit_entry(request, id=None):
  2.     if id is None:
  3.         EntryForm = forms.models.form_for_model(Entry)
  4.     else:
  5.         entry = Entry.objects.get(id=id)
  6.         EntryForm = forms.models.form_for_instance(entry)
  7.  
  8.     EntryForm.fields['detail'].widget = TinyMCE()
  9.  
  10.     if request.method == 'POST':
  11.         form = EntryForm(request.POST)
  12.         if form.is_valid():
  13.             entry = form.save(commit=False)
  14.             if id is None:
  15.                 entry.owner = request.user
  16.             entry.save()
  17.  
  18.             return HttpResponseRedirect("/")
  19.     else:
  20.         form = EntryForm()
  21.  
  22.     t = loader.get_template('add_entry.html')
  23.  
  24.     c = Context({
  25.         'form': form,
  26.         'html_head': '<script src="/media/tiny_mce/tiny_mce_src.js" type="text/javascript"></script>'
  27.     })
  28.     return HttpResponse(t.render(c))

That's it. This code is all you need to display an empty form, a form populated with the data from the db, validating user input, displaying an error page and writing the user input into db. And furthermore you have complete control over the whole process so you could add a bell or whistle here and there as I did with setting the owner of an entry.

I bet this gives an idea how powerful and yet simple newforms is. I'm looking forward to the implementation in Django 1.0!

P.S. For completeness, the template that displays the form:

PLAIN TEXT
CODE:
  1. {% extends "base.html" %}
  2.  
  3. {% block content %}
  4. <form action="." method="post">
  5.   <table class="form">
  6.     {{ form }}
  7.   </table>
  8.   <input type="submit" value="speichern" />
  9. </form>
  10. {% endblock %}

]]> http://code.pui.ch/2007/01/07/using-djangos-newforms/feed/ 63