code.random() » django 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 Send javascript errors by mail http://code.pui.ch/2007/10/06/send-javascript-errors-by-mail/ http://code.pui.ch/2007/10/06/send-javascript-errors-by-mail/#comments Sat, 06 Oct 2007 12:33:42 +0000 philipp.keller http://code.pui.ch/2007/10/06/send-javascript-errors-by-mail/ I'm running a Django-powered site for a closed user group and added a bit of JavaScript magic here and there (mainly Prototype and Tooltip).

Now Django sends me a mail whenever a 404 or 500 error occurs. But when one of my users encounters a JavaScript-Error, I'm not informed. I thought anyone in the web has solved this problem but didn't find anything, so here's my take: Just send any error using Ajax (here: using Prototypes Ajax abstraction) to the server

PLAIN TEXT
JAVASCRIPT:
  1. onerror = Extranet.mailError;
  2. function mailError(msg, url, line) {
  3.   var postBody = 'url=' + url + '&line=' + line + '&message=' + escape(msg) + '&useragent=' + escape(navigator.userAgent) + '&user=' + escape(user_name);
  4.   var myAjax = new Ajax.Request('/api/jserror/', {method: 'post', postBody: postBody});
  5. }

user_name is a JavaScript variable holding the Django username (so I know whom I can inform when the error is fixed).

On the server side, I just send me mails containing the JavaScript error message, the username and the user agent:

PLAIN TEXT
PYTHON:
  1. def jserror(request):
  2.   from django.core.mail import mail_admins
  3.   omit_messages = ['pointerobj is not defined', 'tipobj is not defined', 'ns6 is not defined', 'enabletip is not defined']
  4.   if request.POST.get('message', '') not in omit_messages:
  5.     message = """url: %s (%s)
  6. %s
  7. user-agent: %s
  8. username: %s
  9. """ % (request.POST.get('url', ''), request.POST.get('line', ''), request.POST.get('message', ''), request.POST.get('useragent', ''), request.POST.get('user', ''))
  10.     mail_admins("javascript error", urldecode(message))
  11.   return HttpResponse()

Yeah, that's all very trivial but I wonder what other solutions exist for this problem...

]]> http://code.pui.ch/2007/10/06/send-javascript-errors-by-mail/feed/ 2 Django: Serve big files via fcgid http://code.pui.ch/2007/10/03/django-serve-big-files-via-fcgid/ http://code.pui.ch/2007/10/03/django-serve-big-files-via-fcgid/#comments Wed, 03 Oct 2007 07:14:28 +0000 philipp.keller http://code.pui.ch/2007/10/03/django-serve-big-files-via-fcgid/ I've got a django project running which requires you to login to access files.
That means that I have to serve the files via python, like this:

PLAIN TEXT
PYTHON:
  1. @login_required
  2. def download(request, filename):
  3.     # ... some code specific to my site ...
  4.     response = HttpResponse(mimetype=postUpload.mimetype)
  5.     response['Content-Disposition'] = "attachment; filename=" + original_filename
  6.     response['Content-Length'] = os.path.getsize(filename_path)
  7.     response.write(open(filename_path).read())
  8.     return response

The problem: If the download of a file exceeded 5 minutes (big files and/or low bandwidth) the download was canceled on the server side by a timeout. This Apache configuration for mod_fcgid solved the problem (see mod_fcgid documentation for BusyTimeout)

PLAIN TEXT
CODE:
  1. <IfModule mod_fcgid.c>
  2.   BusyTimeout 1200
  3. </IfModule>

The problem was that the apache module scanned every minute for processes that run for more than BusyTimeout seconds. These processes are potentially in bad health (infinite loop et al.) and have to be killed. Not so with my processes (since I know what I'm doing..). The setting of the busy timeout to 1200 seconds now lets my processes run for a maximum of one hour.

As this setting can't by overwritten in a htaccess file by default I needed to bug my web hosting provider with the request, which was handled in 24 hours, so thanks for that one!

PS: If you know of another way how to serve protected static files via a single sign on (no HTTP basic auth), please let me know.

]]> http://code.pui.ch/2007/10/03/django-serve-big-files-via-fcgid/feed/ 2 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