My problem with Projects was that anyone could list projects that they were not a member of. I hate that.

thing.py

import things
from django.db import connection

from django.http import HttpResponse, Http404
from django.template import RequestContext
from things.fields import BaseField, AggregateBase, DESCENDING
from django.template.loader import select_template

class ProjectThing(things.Thing):
    created = things.OrderField(
        verbose_name_asc='Age', 
        verbose_name_desc='Age', 
        url_asc='oldest', 
        url_desc='newest', 
        field_url='date',
        reverse=True
    )
    name = things.OrderField(
        verbose_name_asc='Name', 
        verbose_name_desc='Name'
    )
    member_users = things.OrderCountField(
        verbose_name_asc='Member Count', 
        verbose_name_desc='Member Count', 
        url_asc='least-members', 
        url_desc='most-members', 
        field_url='members'
    )
    topics = things.OrderCountField(
        verbose_name_asc='Topic Count', 
        verbose_name_desc='Topic Count', 
        url_asc='least-topics', 
        url_desc='most-topics', 
        field_url='topics'
    )
    search = ('name', 'description')
    template_dir = 'projects'
    list_template_name = 'projects.html'
    
    def list_view(self, request, descending=False, field=None, template_object_name='objects', template_name=None, extra_context = {}, templates=[], **kwargs):
        if template_name is None:
            template_name = self.list_template_name
        items = self.get_query_set()
        terms = request.REQUEST.get('search', '')
        if terms and bool(self.search):
            kwargs = {}
            if isinstance(self.search, basestring):
                items = items.filter(**{"%s__icontains" % self.search: terms})
            else:
                q_list = [Q(**{'%s__icontains' % s: terms}) for s in self.search]
                items = items.filter(reduce(or_, q_list))
        if field is None:
            field = self.default_order_field
            descending = getattr(field, 'default_order_field', None) == DESCENDING
        if field is not None:
            reverse = descending ^ field.reverse
            pre = ''
            if reverse:
                pre = '-'
            if field.custom_aggregate_function is not None:
                caf = field.custom_aggregate_function
                vgetter = lambda val: val[1]
                items = [i[0] for i in sorted([(j, caf(request, j)) for j in items], 
                    key=vgetter, reverse=reverse)]
            elif field.custom_aggregate_dict_function is not None:
                pk_sort_dict = field.custom_aggregate_dict_function(request)
                items = list(items.filter(pk__in=pk_sort_dict.keys()))
                items.sort(key=lambda val: pk_sort_dict[val.id], reverse=reverse)
            elif isinstance(field, AggregateBase):
                items = items.order_by('%s%s' % (pre, field.get_aggregate_name()))
            else:
                items = items.order_by('%s%s' % (pre, field.field_name))
        if not templates:
            templates = ['%s/%s' % (self.template_dir, template_name,), '%s/list.html' % self.template_dir, 'things/list.html']
        
        filtered_items = []
        for i in items:
            if i.has_member(request.user):
                filtered_items.append(i)
        
        context = {
            template_object_name: filtered_items, 
            'fields': self.fields.values(), 
            'field': field,
            'descending': descending,
            'url_prefix': self.url_prefix,
            'name_prefix': self.name_prefix,
            'search_enabled': bool(self.search),
            'terms': terms,
        }
        context.update(extra_context)
        t = select_template(templates)
        c = RequestContext(request, context)
        return HttpResponse(t.render(c))