Hello site
[auf_framonde.git] / eggs / Django-1.4.5-py2.7.egg / django / contrib / admin / views / main.py
1 import operator
2
3 from django.core.exceptions import SuspiciousOperation, ImproperlyConfigured
4 from django.core.paginator import InvalidPage
5 from django.db import models
6 from django.db.models.fields import FieldDoesNotExist
7 from django.utils.datastructures import SortedDict
8 from django.utils.encoding import force_unicode, smart_str
9 from django.utils.translation import ugettext, ugettext_lazy
10 from django.utils.http import urlencode
11
12 from django.contrib.admin import FieldListFilter
13 from django.contrib.admin.options import IncorrectLookupParameters
14 from django.contrib.admin.util import (quote, get_fields_from_path,
15 lookup_needs_distinct, prepare_lookup_value)
16
17 # Changelist settings
18 ALL_VAR = 'all'
19 ORDER_VAR = 'o'
20 ORDER_TYPE_VAR = 'ot'
21 PAGE_VAR = 'p'
22 SEARCH_VAR = 'q'
23 TO_FIELD_VAR = 't'
24 IS_POPUP_VAR = 'pop'
25 ERROR_FLAG = 'e'
26
27 IGNORED_PARAMS = (
28 ALL_VAR, ORDER_VAR, ORDER_TYPE_VAR, SEARCH_VAR, IS_POPUP_VAR, TO_FIELD_VAR)
29
30 # Text to display within change-list table cells if the value is blank.
31 EMPTY_CHANGELIST_VALUE = ugettext_lazy('(None)')
32
33
34 class ChangeList(object):
35 def __init__(self, request, model, list_display, list_display_links,
36 list_filter, date_hierarchy, search_fields, list_select_related,
37 list_per_page, list_max_show_all, list_editable, model_admin):
38 self.model = model
39 self.opts = model._meta
40 self.lookup_opts = self.opts
41 self.root_query_set = model_admin.queryset(request)
42 self.list_display = list_display
43 self.list_display_links = list_display_links
44 self.list_filter = list_filter
45 self.date_hierarchy = date_hierarchy
46 self.search_fields = search_fields
47 self.list_select_related = list_select_related
48 self.list_per_page = list_per_page
49 self.list_max_show_all = list_max_show_all
50 self.model_admin = model_admin
51
52 # Get search parameters from the query string.
53 try:
54 self.page_num = int(request.GET.get(PAGE_VAR, 0))
55 except ValueError:
56 self.page_num = 0
57 self.show_all = ALL_VAR in request.GET
58 self.is_popup = IS_POPUP_VAR in request.GET
59 self.to_field = request.GET.get(TO_FIELD_VAR)
60 self.params = dict(request.GET.items())
61 if PAGE_VAR in self.params:
62 del self.params[PAGE_VAR]
63 if ERROR_FLAG in self.params:
64 del self.params[ERROR_FLAG]
65
66 if self.is_popup:
67 self.list_editable = ()
68 else:
69 self.list_editable = list_editable
70 self.query = request.GET.get(SEARCH_VAR, '')
71 self.query_set = self.get_query_set(request)
72 self.get_results(request)
73 if self.is_popup:
74 title = ugettext('Select %s')
75 else:
76 title = ugettext('Select %s to change')
77 self.title = title % force_unicode(self.opts.verbose_name)
78 self.pk_attname = self.lookup_opts.pk.attname
79
80 def get_filters(self, request):
81 lookup_params = self.params.copy() # a dictionary of the query string
82 use_distinct = False
83
84 # Remove all the parameters that are globally and systematically
85 # ignored.
86 for ignored in IGNORED_PARAMS:
87 if ignored in lookup_params:
88 del lookup_params[ignored]
89
90 # Normalize the types of keys
91 for key, value in lookup_params.items():
92 if not isinstance(key, str):
93 # 'key' will be used as a keyword argument later, so Python
94 # requires it to be a string.
95 del lookup_params[key]
96 lookup_params[smart_str(key)] = value
97
98 if not self.model_admin.lookup_allowed(key, value):
99 raise SuspiciousOperation("Filtering by %s not allowed" % key)
100
101 filter_specs = []
102 if self.list_filter:
103 for list_filter in self.list_filter:
104 if callable(list_filter):
105 # This is simply a custom list filter class.
106 spec = list_filter(request, lookup_params,
107 self.model, self.model_admin)
108 else:
109 field_path = None
110 if isinstance(list_filter, (tuple, list)):
111 # This is a custom FieldListFilter class for a given field.
112 field, field_list_filter_class = list_filter
113 else:
114 # This is simply a field name, so use the default
115 # FieldListFilter class that has been registered for
116 # the type of the given field.
117 field, field_list_filter_class = list_filter, FieldListFilter.create
118 if not isinstance(field, models.Field):
119 field_path = field
120 field = get_fields_from_path(self.model, field_path)[-1]
121 spec = field_list_filter_class(field, request, lookup_params,
122 self.model, self.model_admin, field_path=field_path)
123 # Check if we need to use distinct()
124 use_distinct = (use_distinct or
125 lookup_needs_distinct(self.lookup_opts,
126 field_path))
127 if spec and spec.has_output():
128 filter_specs.append(spec)
129
130 # At this point, all the parameters used by the various ListFilters
131 # have been removed from lookup_params, which now only contains other
132 # parameters passed via the query string. We now loop through the
133 # remaining parameters both to ensure that all the parameters are valid
134 # fields and to determine if at least one of them needs distinct(). If
135 # the lookup parameters aren't real fields, then bail out.
136 try:
137 for key, value in lookup_params.items():
138 lookup_params[key] = prepare_lookup_value(key, value)
139 use_distinct = (use_distinct or
140 lookup_needs_distinct(self.lookup_opts, key))
141 return filter_specs, bool(filter_specs), lookup_params, use_distinct
142 except FieldDoesNotExist, e:
143 raise IncorrectLookupParameters(e)
144
145 def get_query_string(self, new_params=None, remove=None):
146 if new_params is None: new_params = {}
147 if remove is None: remove = []
148 p = self.params.copy()
149 for r in remove:
150 for k in p.keys():
151 if k.startswith(r):
152 del p[k]
153 for k, v in new_params.items():
154 if v is None:
155 if k in p:
156 del p[k]
157 else:
158 p[k] = v
159 return '?%s' % urlencode(p)
160
161 def get_results(self, request):
162 paginator = self.model_admin.get_paginator(request, self.query_set, self.list_per_page)
163 # Get the number of objects, with admin filters applied.
164 result_count = paginator.count
165
166 # Get the total number of objects, with no admin filters applied.
167 # Perform a slight optimization: Check to see whether any filters were
168 # given. If not, use paginator.hits to calculate the number of objects,
169 # because we've already done paginator.hits and the value is cached.
170 if not self.query_set.query.where:
171 full_result_count = result_count
172 else:
173 full_result_count = self.root_query_set.count()
174
175 can_show_all = result_count <= self.list_max_show_all
176 multi_page = result_count > self.list_per_page
177
178 # Get the list of objects to display on this page.
179 if (self.show_all and can_show_all) or not multi_page:
180 result_list = self.query_set._clone()
181 else:
182 try:
183 result_list = paginator.page(self.page_num+1).object_list
184 except InvalidPage:
185 raise IncorrectLookupParameters
186
187 self.result_count = result_count
188 self.full_result_count = full_result_count
189 self.result_list = result_list
190 self.can_show_all = can_show_all
191 self.multi_page = multi_page
192 self.paginator = paginator
193
194 def _get_default_ordering(self):
195 ordering = []
196 if self.model_admin.ordering:
197 ordering = self.model_admin.ordering
198 elif self.lookup_opts.ordering:
199 ordering = self.lookup_opts.ordering
200 return ordering
201
202 def get_ordering_field(self, field_name):
203 """
204 Returns the proper model field name corresponding to the given
205 field_name to use for ordering. field_name may either be the name of a
206 proper model field or the name of a method (on the admin or model) or a
207 callable with the 'admin_order_field' attribute. Returns None if no
208 proper model field name can be matched.
209 """
210 try:
211 field = self.lookup_opts.get_field(field_name)
212 return field.name
213 except models.FieldDoesNotExist:
214 # See whether field_name is a name of a non-field
215 # that allows sorting.
216 if callable(field_name):
217 attr = field_name
218 elif hasattr(self.model_admin, field_name):
219 attr = getattr(self.model_admin, field_name)
220 else:
221 attr = getattr(self.model, field_name)
222 return getattr(attr, 'admin_order_field', None)
223
224 def get_ordering(self, request, queryset):
225 """
226 Returns the list of ordering fields for the change list.
227 First we check the get_ordering() method in model admin, then we check
228 the object's default ordering. Then, any manually-specified ordering
229 from the query string overrides anything. Finally, a deterministic
230 order is guaranteed by ensuring the primary key is used as the last
231 ordering field.
232 """
233 params = self.params
234 ordering = list(self.model_admin.get_ordering(request)
235 or self._get_default_ordering())
236 if ORDER_VAR in params:
237 # Clear ordering and used params
238 ordering = []
239 order_params = params[ORDER_VAR].split('.')
240 for p in order_params:
241 try:
242 none, pfx, idx = p.rpartition('-')
243 field_name = self.list_display[int(idx)]
244 order_field = self.get_ordering_field(field_name)
245 if not order_field:
246 continue # No 'admin_order_field', skip it
247 ordering.append(pfx + order_field)
248 except (IndexError, ValueError):
249 continue # Invalid ordering specified, skip it.
250
251 # Add the given query's ordering fields, if any.
252 ordering.extend(queryset.query.order_by)
253
254 # Ensure that the primary key is systematically present in the list of
255 # ordering fields so we can guarantee a deterministic order across all
256 # database backends.
257 pk_name = self.lookup_opts.pk.name
258 if not (set(ordering) & set(['pk', '-pk', pk_name, '-' + pk_name])):
259 # The two sets do not intersect, meaning the pk isn't present. So
260 # we add it.
261 ordering.append('-pk')
262
263 return ordering
264
265 def get_ordering_field_columns(self):
266 """
267 Returns a SortedDict of ordering field column numbers and asc/desc
268 """
269
270 # We must cope with more than one column having the same underlying sort
271 # field, so we base things on column numbers.
272 ordering = self._get_default_ordering()
273 ordering_fields = SortedDict()
274 if ORDER_VAR not in self.params:
275 # for ordering specified on ModelAdmin or model Meta, we don't know
276 # the right column numbers absolutely, because there might be more
277 # than one column associated with that ordering, so we guess.
278 for field in ordering:
279 if field.startswith('-'):
280 field = field[1:]
281 order_type = 'desc'
282 else:
283 order_type = 'asc'
284 for index, attr in enumerate(self.list_display):
285 if self.get_ordering_field(attr) == field:
286 ordering_fields[index] = order_type
287 break
288 else:
289 for p in self.params[ORDER_VAR].split('.'):
290 none, pfx, idx = p.rpartition('-')
291 try:
292 idx = int(idx)
293 except ValueError:
294 continue # skip it
295 ordering_fields[idx] = 'desc' if pfx == '-' else 'asc'
296 return ordering_fields
297
298 def get_query_set(self, request):
299 # First, we collect all the declared list filters.
300 (self.filter_specs, self.has_filters, remaining_lookup_params,
301 use_distinct) = self.get_filters(request)
302
303 # Then, we let every list filter modify the queryset to its liking.
304 qs = self.root_query_set
305 for filter_spec in self.filter_specs:
306 new_qs = filter_spec.queryset(request, qs)
307 if new_qs is not None:
308 qs = new_qs
309
310 try:
311 # Finally, we apply the remaining lookup parameters from the query
312 # string (i.e. those that haven't already been processed by the
313 # filters).
314 qs = qs.filter(**remaining_lookup_params)
315 except (SuspiciousOperation, ImproperlyConfigured):
316 # Allow certain types of errors to be re-raised as-is so that the
317 # caller can treat them in a special way.
318 raise
319 except Exception, e:
320 # Every other error is caught with a naked except, because we don't
321 # have any other way of validating lookup parameters. They might be
322 # invalid if the keyword arguments are incorrect, or if the values
323 # are not in the correct type, so we might get FieldError,
324 # ValueError, ValidationError, or ?.
325 raise IncorrectLookupParameters(e)
326
327 # Use select_related() if one of the list_display options is a field
328 # with a relationship and the provided queryset doesn't already have
329 # select_related defined.
330 if not qs.query.select_related:
331 if self.list_select_related:
332 qs = qs.select_related()
333 else:
334 for field_name in self.list_display:
335 try:
336 field = self.lookup_opts.get_field(field_name)
337 except models.FieldDoesNotExist:
338 pass
339 else:
340 if isinstance(field.rel, models.ManyToOneRel):
341 qs = qs.select_related()
342 break
343
344 # Set ordering.
345 ordering = self.get_ordering(request, qs)
346 qs = qs.order_by(*ordering)
347
348 # Apply keyword searches.
349 def construct_search(field_name):
350 if field_name.startswith('^'):
351 return "%s__istartswith" % field_name[1:]
352 elif field_name.startswith('='):
353 return "%s__iexact" % field_name[1:]
354 elif field_name.startswith('@'):
355 return "%s__search" % field_name[1:]
356 else:
357 return "%s__icontains" % field_name
358
359 if self.search_fields and self.query:
360 orm_lookups = [construct_search(str(search_field))
361 for search_field in self.search_fields]
362 for bit in self.query.split():
363 or_queries = [models.Q(**{orm_lookup: bit})
364 for orm_lookup in orm_lookups]
365 qs = qs.filter(reduce(operator.or_, or_queries))
366 if not use_distinct:
367 for search_spec in orm_lookups:
368 if lookup_needs_distinct(self.lookup_opts, search_spec):
369 use_distinct = True
370 break
371
372 if use_distinct:
373 return qs.distinct()
374 else:
375 return qs
376
377 def url_for_result(self, result):
378 return "%s/" % quote(getattr(result, self.pk_attname))