Building Site Search And OpenSearch-plugin With Django

November 19, 2006

While browsing trough Technorati I saw this blue glow on the Firefox search bar. Firefox had autodiscovered an opensearch-plugin for Technorati. How could I implement this functionality on my own site? Turns out this is ridiculously easy to do with Django. The result for this blog looks like this:

Again, it’s very easy to do. (I know, because I could do it! :)

Start with search

First, you need to have a search function for your site. Unfortunately Django doesn’t have any generic search functionality built in (yet, search-api is on its way). There is however, very nice search functionality in Admin-app, which can be easily modified to a site search.

After a bit of tweaking, this is the view code that I eventually came up with:

from django.shortcuts import render_to_response
from django.db.models import Q
from django.db.models.query import QuerySet
from django.http import HttpResponseRedirect
from django.template import loader, Context
from unessanet.english.models import BlogEntry
import operator


def hoyci_search(request, terms=None): 
    if request.POST:
        return HttpResponseRedirect('/en/hoyci/search/%s/' % request.POST['query'].replace(" ","+"))
    elif terms:
        query = terms.replace("+"," ")       
        if query: 
            or_query=Q() 
            search_fields = ['title', 'strapline', 'excerpt', 'body'] # your search fields here

            for bit in query.split(): 
                or_queries = [Q(**{'%s__icontains' % field_name: bit}) for field_name in search_fields] 
                other_qs = QuerySet(BlogEntry) # your class here
                other_qs = other_qs.filter(reduce(operator.or_, or_queries)) 
                search_results = other_qs.filter(is_draft=False)
        else:
            search_results = None
        return render_to_response('english/search.html', locals())
    else:
        return render_to_response('english/search.html')

Let’s chew it up a bit. Firstly, in my urls.py I have a line

(r'^search/(?P<terms>\S+)/$', 'hoyci_search'),

which passes the terms variable to the search function. When the function is called, it checks whether the request was POST or GET. Searches via web-form are done with POST, while other searches (like Firefoxes opensearch) are GET. If request is POST, it redirects it to a new URL, which is also the result page.

All the heavy lifting is done when prosessing the GET-request. If you want to use this code, modify the search_fields-variable and the first instance of other_qs-variable to set up right model class and its fields. After that (and after spitting up the necessary template files), everything should just work! You don’t have to worry for example about SQL-injections because Django db-api takes care of things like that for you. How convenient :)

(The locals()-trick was found from the Django Book, btw.)

Implementing OpenSearch With Django

Mozilla developer center has a good article about creating OpenSearch plugins for Firefox. Basically, the “plugin” is just an XML-file and a rel-link to notify the browser about it. I basically copied the example XML to a Django template and filled in the data. My description file looks like this:

<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/"
                       xmlns:moz="http://www.mozilla.org/2006/browser/search/">
<ShortName>Same Con To Hoyci</ShortName>
<Description>Search entries from Hoyci</Description>
<InputEncoding>UTF-8</InputEncoding>
<Image width="16" height="16" type="image/png">http://kuvat.unessa.net/stuff/unessa_ulogo_16px.png</Image>
<Url type="text/html" method="GET" template="http://www.unessa.net/en/hoyci/search/{searchTerms}"></Url>
<moz:SearchForm>http://www.unessa.net/en/hoyci/search/{searchTerms}</moz:SearchForm>
<Language>en-us</Language>
</OpenSearchDescription>

This file needs to be fed to the browser, so we need another line in urlconf and another view. The easiest way to do it would be to call django.views.generic.simple.direct_to_template, but because Django is for perfectionists, we’ll do it with a custom view to get right mime-type. Like this:

def hoyci_opensearch(request):
    response = HttpResponse(mimetype='application/opensearchdescription+xml')
    t = loader.get_template('english/hoyci_opensearchxml.html')
    response.write(t.render(''))
    return response

Quite painless. Now the only thing missing is the autodiscovery link to the template. It looks like this: <link rel="search" type="application/opensearchdescription+xml" title="Hoyci Search" href="http://www.unessa.net/en/hoyci/opensearch/">. And that’s it. Now you can search your site from Firefox search bar!

Final notes

This was yet another “hack together something interesting in half an hour”-type of hack. It’s not 100% optimized or fully tested, but for me it works like a charm.

The search functionality has some known limitations (aka “features”):

  • It only searches from one class. It would be nice to be able to search multiple classes.
  • Due to URL-limitations, my solution breaks with Firefox with characters like ‘/’, because Firefox encodes them and Django doesn’t seem to comprehend it. Django chokes for example on “foo%2Fbar”, which is not nice.

The Firefox OpenSearch implementation has a nice suggestion feature. It would be quite easy to built one with Django using a simple searches-class and json output to the browser. Maybe a sequal to this howto?-)

Any tips on the limitations, and any other comments and suggestions, are appreciated!

Tagged with , , , ,
Proudly Powered by Django
Unessa.net © 2000-2019 Ville Säävuori. All lefts reversed.