Source Code for Module django.contrib.admin.filterspecs

  1  """ 
  2  FilterSpec encapsulates the logic for displaying filters in the Django admin. 
  3  Filters are specified in models with the "list_filter" option. 
  4   
  5  Each filter subclass knows how to display a filter for a field that passes a 
  6  certain test -- e.g. being a DateField or ForeignKey. 
  7  """ 
  8   
  9  from django.db import models 
 10  from django.utils.encoding import smart_unicode, iri_to_uri 
 11  from django.utils.translation import ugettext as _ 
 12  from django.utils.html import escape 
 13  from django.utils.safestring import mark_safe 
 14  import datetime 
 15   
 16 -class FilterSpec(object): 
 17      filter_specs = [] 
 18 -    def __init__(self, f, request, params, model): 
 19          self.field = f 
 20          self.params = params 
 21   
 22 -    def register(cls, test, factory): 
 23          cls.filter_specs.append((test, factory)) 
 24      register = classmethod(register) 
 25   
 26 -    def create(cls, f, request, params, model): 
 27          for test, factory in cls.filter_specs: 
 28              if test(f): 
 29                  return factory(f, request, params, model) 
 30      create = classmethod(create) 
 31   
 32 -    def has_output(self): 
 33          return True 
 34   
 35 -    def choices(self, cl): 
 36          raise NotImplementedError() 
 37   
 38 -    def title(self): 
 39          return self.field.verbose_name 
 40   
 41 -    def output(self, cl): 
 42          t = [] 
 43          if self.has_output(): 
 44              t.append(_(u'<h3>By %s:</h3>\n<ul>\n') % escape(self.title())) 
 45   
 46              for choice in self.choices(cl): 
 47                  t.append(u'<li%s><a href="%s">%s</a></li>\n' % \ 
 48                      ((choice['selected'] and ' class="selected"' or ''), 
 49                       iri_to_uri(choice['query_string']), 
 50                       choice['display'])) 
 51              t.append('</ul>\n\n') 
 52          return mark_safe("".join(t)) 
 53   
 54 -class RelatedFilterSpec(FilterSpec): 
 55 -    def __init__(self, f, request, params, model): 
 56          super(RelatedFilterSpec, self).__init__(f, request, params, model) 
 57          if isinstance(f, models.ManyToManyField): 
 58              self.lookup_title = f.rel.to._meta.verbose_name 
 59          else: 
 60              self.lookup_title = f.verbose_name 
 61          self.lookup_kwarg = '%s__%s__exact' % (f.name, f.rel.to._meta.pk.name) 
 62          self.lookup_val = request.GET.get(self.lookup_kwarg, None) 
 63          self.lookup_choices = f.rel.to._default_manager.all() 
 64   
 65 -    def has_output(self): 
 66          return len(self.lookup_choices) > 1 
 67   
 68 -    def title(self): 
 69          return self.lookup_title 
 70   
 71 -    def choices(self, cl): 
 72          yield {'selected': self.lookup_val is None, 
 73                 'query_string': cl.get_query_string({}, [self.lookup_kwarg]), 
 74                 'display': _('All')} 
 75          for val in self.lookup_choices: 
 76              pk_val = getattr(val, self.field.rel.to._meta.pk.attname) 
 77              yield {'selected': self.lookup_val == smart_unicode(pk_val), 
 78                     'query_string': cl.get_query_string({self.lookup_kwarg: pk_val}), 
 79                     'display': val} 
 80   
 81  FilterSpec.register(lambda f: bool(f.rel), RelatedFilterSpec) 
 82   
 83 -class ChoicesFilterSpec(FilterSpec): 
 84 -    def __init__(self, f, request, params, model): 
 85          super(ChoicesFilterSpec, self).__init__(f, request, params, model) 
 86          self.lookup_kwarg = '%s__exact' % f.name 
 87          self.lookup_val = request.GET.get(self.lookup_kwarg, None) 
 88   
 89 -    def choices(self, cl): 
 90          yield {'selected': self.lookup_val is None, 
 91                 'query_string': cl.get_query_string({}, [self.lookup_kwarg]), 
 92                 'display': _('All')} 
 93          for k, v in self.field.choices: 
 94              yield {'selected': smart_unicode(k) == self.lookup_val, 
 95                      'query_string': cl.get_query_string({self.lookup_kwarg: k}), 
 96                      'display': v} 
 97   
 98  FilterSpec.register(lambda f: bool(f.choices), ChoicesFilterSpec) 
 99   
100 -class DateFieldFilterSpec(FilterSpec): 
101 -    def __init__(self, f, request, params, model): 
102          super(DateFieldFilterSpec, self).__init__(f, request, params, model) 
103   
104          self.field_generic = '%s__' % self.field.name 
105   
106          self.date_params = dict([(k, v) for k, v in params.items() if k.startswith(self.field_generic)]) 
107   
108          today = datetime.date.today() 
109          one_week_ago = today - datetime.timedelta(days=7) 
110          today_str = isinstance(self.field, models.DateTimeField) and today.strftime('%Y-%m-%d 23:59:59') or today.strftime('%Y-%m-%d') 
111   
112          self.links = ( 
113              (_('Any date'), {}), 
114              (_('Today'), {'%s__year' % self.field.name: str(today.year), 
115                         '%s__month' % self.field.name: str(today.month), 
116                         '%s__day' % self.field.name: str(today.day)}), 
117              (_('Past 7 days'), {'%s__gte' % self.field.name: one_week_ago.strftime('%Y-%m-%d'), 
118                               '%s__lte' % f.name: today_str}), 
119              (_('This month'), {'%s__year' % self.field.name: str(today.year), 
120                               '%s__month' % f.name: str(today.month)}), 
121              (_('This year'), {'%s__year' % self.field.name: str(today.year)}) 
122          ) 
123   
124 -    def title(self): 
125          return self.field.verbose_name 
126   
127 -    def choices(self, cl): 
128          for title, param_dict in self.links: 
129              yield {'selected': self.date_params == param_dict, 
130                     'query_string': cl.get_query_string(param_dict, [self.field_generic]), 
131                     'display': title} 
132   
133  FilterSpec.register(lambda f: isinstance(f, models.DateField), DateFieldFilterSpec) 
134   
135 -class BooleanFieldFilterSpec(FilterSpec): 
136 -    def __init__(self, f, request, params, model): 
137          super(BooleanFieldFilterSpec, self).__init__(f, request, params, model) 
138          self.lookup_kwarg = '%s__exact' % f.name 
139          self.lookup_kwarg2 = '%s__isnull' % f.name 
140          self.lookup_val = request.GET.get(self.lookup_kwarg, None) 
141          self.lookup_val2 = request.GET.get(self.lookup_kwarg2, None) 
142   
143 -    def title(self): 
144          return self.field.verbose_name 
145   
146 -    def choices(self, cl): 
147          for k, v in ((_('All'), None), (_('Yes'), '1'), (_('No'), '0')): 
148              yield {'selected': self.lookup_val == v and not self.lookup_val2, 
149                     'query_string': cl.get_query_string({self.lookup_kwarg: v}, [self.lookup_kwarg2]), 
150                     'display': k} 
151          if isinstance(self.field, models.NullBooleanField): 
152              yield {'selected': self.lookup_val2 == 'True', 
153                     'query_string': cl.get_query_string({self.lookup_kwarg2: 'True'}, [self.lookup_kwarg]), 
154                     'display': _('Unknown')} 
155   
156  FilterSpec.register(lambda f: isinstance(f, models.BooleanField) or isinstance(f, models.NullBooleanField), BooleanFieldFilterSpec) 
157   
158  # This should be registered last, because it's a last resort. For example, 
159  # if a field is eligible to use the BooleanFieldFilterSpec, that'd be much 
160  # more appropriate, and the AllValuesFilterSpec won't get used for it. 
161 -class AllValuesFilterSpec(FilterSpec): 
162 -    def __init__(self, f, request, params, model): 
163          super(AllValuesFilterSpec, self).__init__(f, request, params, model) 
164          self.lookup_val = request.GET.get(f.name, None) 
165          self.lookup_choices = model._meta.admin.manager.distinct().order_by(f.name).values(f.name) 
166   
167 -    def title(self): 
168          return self.field.verbose_name 
169   
170 -    def choices(self, cl): 
171          yield {'selected': self.lookup_val is None, 
172                 'query_string': cl.get_query_string({}, [self.field.name]), 
173                 'display': _('All')} 
174          for val in self.lookup_choices: 
175              val = smart_unicode(val[self.field.name]) 
176              yield {'selected': self.lookup_val == val, 
177                     'query_string': cl.get_query_string({self.field.name: val}), 
178                     'display': val} 
179  FilterSpec.register(lambda f: True, AllValuesFilterSpec) 
180