Handling legacy URLs with Django

One of the great things about Django is its simple and flexible URL handling. If your Django work, like mine, includes converting existing sites, you’ll probably be doing some URL cleanup along the way. Django’s “generic views” system includes a view called “redirect_to” that handles cases like this. A rule might look like this:

urlpatterns = patterns('django.views.generic.simple',
    ('^foo/oldsite/BadOldUrl33247.blech$', 'redirect_to', {'url': '/bar/nice-new-url/'}),

But because the URL pattern building happens in Python, if you have many of these you can do better than filling your urls.py with variants of that line. Here’s the root urlconf for one of my sites:

urlpatterns = patterns('',
    # ...long list of patterns here
    (r'^admin/', include('django.contrib.admin.urls')),

legacy_urls = (
    ('^kawasaki/zx750f', '/bikes/kawasaki/zx750f/'),
    ('^pages/ktm_2wd_interview', '/bikes/ktm/2wd/'),
    ('^gear/[0-9]+/$', '/gear/'),

for urltuple in legacy_urls:
    oldurl, newurl = urltuple
    urlpatterns += patterns('', 
        (oldurl, 'django.views.generic.simple.redirect_to', {'url': newurl}))

The first block is my main set of patterns. The second is my list (OK, it’s a tuple) of old/new URL pairs. The third block just extends the urlpatterns object with rules for these pairs, using the generic “redirect_to” view.

I haven’t needed it for this project, but the documentation explains how the redirects can also be parameterized. For example, if you needed to translate all URLs like “/foo/99/” into “/bar/99/”, you’d add this pair to legacy_urls above:

('^foo/(?P<id>\d+)/$', '/bar/%(id)s/'),

Overall this approach is just minor syntax twiddling, but I find the simple tuple style easier to read and maintain.

Techniques like this may be obvious to Django users who grasp the beauty and power of its pure-Python approach – but I hope it can be helpful for some newcomers who are used to other frameworks where configuration files are brittle, fussy things.

Simon Willison commented on Fri Sep 29 10:06:32 2006:

There’s an even neater way of doing this, thanks to a feature that recently went in to Django that allows you to provide views as callable objects instead of as strings:

def redirect(url):
  def inner(request):
    return HttpResponseRedirect(url)
  return inner

urlpatterns = patterns('',
  ('^kawasaki/zx750f', redirect('/bikes/kawasaki/zx750f/'),
  ('^pages/ktm_2wd_interview', redirect('/bikes/ktm/2wd/'),
  ('^gear/[0-9]+/$', redirect('/gear/')

Paul commented on Fri Sep 29 10:28:47 2006:

Very cool, Simon, thanks! I’m actually using the callable-object syntax in most of my URLconfs, but I hadn’t thought to take advantage of it in that way.

Max Battcher commented on Fri Sep 29 22:04:49 2006:

Another suggestion, particularly for those with a lot of “dynamic” content (ie, converting from a major blog or cms application), is to use django.contrib.redirects. It installs just like Flatpages (add it to INSTALLED_APPS, add its middleware near flatpage’s, and syncdb) and keeps your redirect information in the database. I was able to populate my redirects table with legacy URLs as a part of the database conversion of my blog. By having it in the database it makes it really easy for me to slowly phase out legacy URLs as search engines adapt and I weed out legacy links.