django design pattern/best practice: filtering a queryset

Question

I have a page where I'm displaying the results of a queryset to the user. What i'd like to do is allow the user to click on a link in order to apply a filter.

Currently what I do is have the links pass "get" parameters to the page in order to apply filters. The filters can be references to other models or custom filters (e.g. an unassigned filter)

In order to provide a decent user experience the implementation needs to do a few things

• in the view:
  1. check that the filter parameter passed is valid
  2. check what type of filter it is (based on other models or a custom filter) in order to apply the correct condition to the queryset
  3. (optional) a way to make the filters cumulative (i.e. you can keep adding filters)
• in the Template:
  1. display the correct resultset based on the filter choosen
  2. when displaying the filters, recognize which filter we have applied so that the current applied filter is displayed as text not a hyperlink.

I'm thinking this must be common enough that someone must have like a design pattern or best practice figured out for this other than the obvious whack of if/else statements in the view and the template.

is there?

Answer 1

I find the way the Django admin handles this kind of functionality a great pattern. If you're not familiar, check out the list_filter option in the admin. It's similar to what you're describing, but yours is a bit more generic. Perhaps this will help you ponder some ideas?

• First, for the actual querystring chunk, you're simply passing the Django-ORM lookup key and value pair. e.g., ?sites__id__exact=1, tags__in=words, etc. Since you want to allow for cross-model lookups, you'd need to provide another parts in the string to include the model name, not too tough.

• For checking if the filter is valid, you can simply ensure that the model/field lookup is valid. By splitting the parts of each QS chunk, you can identify the model, the fieldname, the lookup, and the value. Then, use Django's built-in functionality to validate that fieldname exists on model. You can do this with ForeignKey's too. Here's how Django does it

• You can keep adding filters pretty easily to this. You'll be providing your view and the form that's displaying these filters with some context, so it'll persist and re-populate for the user. Also, you could just as easily persist the query string. Basically, you'd have the same read / parsing functionality here at all times, nothing really different.

I think the keys are automating and keeping it as DRY as possible. Don't succumb to a bunch of if statements. It's really easy to pass these lookups into the ORM, safely too, and it's really easy to catch bad lookups and provide the user with a meaningful error message.

I hope that helps you on your path! :)