1 from django.contrib.admin.filterspecs import FilterSpec

     2 from django.contrib.admin.options import IncorrectLookupParameters

     3 from django.contrib.admin.util import quote

     4 from django.core.paginator import Paginator, InvalidPage

     5 from django.db import models

     6 from django.db.models.query import QuerySet

     7 from django.utils.encoding import force_unicode, smart_str

     8 from django.utils.translation import ugettext

     9 from django.utils.http import urlencode

    10 import operator

    11 

    12 try:

    13     set

    14 except NameError:

    15     from sets import Set as set   # Python 2.3 fallback

    16 

    17 # The system will display a "Show all" link on the change list only if the

    18 # total result count is less than or equal to this setting.

    19 MAX_SHOW_ALL_ALLOWED = 200

    20 

    21 # Changelist settings

    22 ALL_VAR = 'all'

    23 ORDER_VAR = 'o'

    24 ORDER_TYPE_VAR = 'ot'

    25 PAGE_VAR = 'p'

    26 SEARCH_VAR = 'q'

    27 TO_FIELD_VAR = 't'

    28 IS_POPUP_VAR = 'pop'

    29 ERROR_FLAG = 'e'

    30 

    31 # Text to display within change-list table cells if the value is blank.

    32 EMPTY_CHANGELIST_VALUE = '(None)'

    33 

    34 class ChangeList(object):

    35     def __init__(self, request, model, list_display, list_display_links, list_filter, date_hierarchy, search_fields, list_select_related, list_per_page, list_editable, model_admin):

    36         self.model = model

    37         self.opts = model._meta

    38         self.lookup_opts = self.opts

    39         self.root_query_set = model_admin.queryset(request)

    40         self.list_display = list_display

    41         self.list_display_links = list_display_links

    42         self.list_filter = list_filter

    43         self.date_hierarchy = date_hierarchy

    44         self.search_fields = search_fields

    45         self.list_select_related = list_select_related

    46         self.list_per_page = list_per_page

    47         self.list_editable = list_editable

    48         self.model_admin = model_admin

    49 

    50         # Get search parameters from the query string.

    51         try:

    52             self.page_num = int(request.GET.get(PAGE_VAR, 0))

    53         except ValueError:

    54             self.page_num = 0

    55         self.show_all = ALL_VAR in request.GET

    56         self.is_popup = IS_POPUP_VAR in request.GET

    57         self.to_field = request.GET.get(TO_FIELD_VAR)

    58         self.params = dict(request.GET.items())

    59         if PAGE_VAR in self.params:

    60             del self.params[PAGE_VAR]

    61         if TO_FIELD_VAR in self.params:

    62             del self.params[TO_FIELD_VAR]

    63         if ERROR_FLAG in self.params:

    64             del self.params[ERROR_FLAG]

    65 

    66         self.order_field, self.order_type = self.get_ordering()

    67         self.query = request.GET.get(SEARCH_VAR, '')

    68         self.query_set = self.get_query_set()

    69         self.get_results(request)

    70         self.title = (self.is_popup and ugettext('Select %s') % force_unicode(self.opts.verbose_name) or ugettext('Select %s to change') % force_unicode(self.opts.verbose_name))

    71         self.filter_specs, self.has_filters = self.get_filters(request)

    72         self.pk_attname = self.lookup_opts.pk.attname

    73 

    74     def get_filters(self, request):

    75         filter_specs = []

    76         if self.list_filter:

    77             filter_fields = [self.lookup_opts.get_field(field_name) for field_name in self.list_filter]

    78             for f in filter_fields:

    79                 spec = FilterSpec.create(f, request, self.params, self.model, self.model_admin)

    80                 if spec and spec.has_output():

    81                     filter_specs.append(spec)

    82         return filter_specs, bool(filter_specs)

    83 

    84     def get_query_string(self, new_params=None, remove=None):

    85         if new_params is None: new_params = {}

    86         if remove is None: remove = []

    87         p = self.params.copy()

    88         for r in remove:

    89             for k in p.keys():

    90                 if k.startswith(r):

    91                     del p[k]

    92         for k, v in new_params.items():

    93             if v is None:

    94                 if k in p:

    95                     del p[k]

    96             else:

    97                 p[k] = v

    98         return '?%s' % urlencode(p)

    99 

   100     def get_results(self, request):

   101         paginator = Paginator(self.query_set, self.list_per_page)

   102         # Get the number of objects, with admin filters applied.

   103         result_count = paginator.count

   104 

   105         # Get the total number of objects, with no admin filters applied.

   106         # Perform a slight optimization: Check to see whether any filters were

   107         # given. If not, use paginator.hits to calculate the number of objects,

   108         # because we've already done paginator.hits and the value is cached.

   109         if not self.query_set.query.where:

   110             full_result_count = result_count

   111         else:

   112             full_result_count = self.root_query_set.count()

   113 

   114         can_show_all = result_count <= MAX_SHOW_ALL_ALLOWED

   115         multi_page = result_count > self.list_per_page

   116 

   117         # Get the list of objects to display on this page.

   118         if (self.show_all and can_show_all) or not multi_page:

   119             result_list = self.query_set._clone()

   120         else:

   121             try:

   122                 result_list = paginator.page(self.page_num+1).object_list

   123             except InvalidPage:

   124                 result_list = ()

   125 

   126         self.result_count = result_count

   127         self.full_result_count = full_result_count

   128         self.result_list = result_list

   129         self.can_show_all = can_show_all

   130         self.multi_page = multi_page

   131         self.paginator = paginator

   132 

   133     def get_ordering(self):

   134         lookup_opts, params = self.lookup_opts, self.params

   135         # For ordering, first check the "ordering" parameter in the admin

   136         # options, then check the object's default ordering. If neither of

   137         # those exist, order descending by ID by default. Finally, look for

   138         # manually-specified ordering from the query string.

   139         ordering = self.model_admin.ordering or lookup_opts.ordering or ['-' + lookup_opts.pk.name]

   140 

   141         if ordering[0].startswith('-'):

   142             order_field, order_type = ordering[0][1:], 'desc'

   143         else:

   144             order_field, order_type = ordering[0], 'asc'

   145         if ORDER_VAR in params:

   146             try:

   147                 field_name = self.list_display[int(params[ORDER_VAR])]

   148                 try:

   149                     f = lookup_opts.get_field(field_name)

   150                 except models.FieldDoesNotExist:

   151                     # See whether field_name is a name of a non-field

   152                     # that allows sorting.

   153                     try:

   154                         if callable(field_name):

   155                             attr = field_name

   156                         elif hasattr(self.model_admin, field_name):

   157                             attr = getattr(self.model_admin, field_name)

   158                         else:

   159                             attr = getattr(self.model, field_name)

   160                         order_field = attr.admin_order_field

   161                     except AttributeError:

   162                         pass

   163                 else:

   164                     order_field = f.name

   165             except (IndexError, ValueError):

   166                 pass # Invalid ordering specified. Just use the default.

   167         if ORDER_TYPE_VAR in params and params[ORDER_TYPE_VAR] in ('asc', 'desc'):

   168             order_type = params[ORDER_TYPE_VAR]

   169         return order_field, order_type

   170 

   171     def get_query_set(self):

   172         qs = self.root_query_set

   173         lookup_params = self.params.copy() # a dictionary of the query string

   174         for i in (ALL_VAR, ORDER_VAR, ORDER_TYPE_VAR, SEARCH_VAR, IS_POPUP_VAR):

   175             if i in lookup_params:

   176                 del lookup_params[i]

   177         for key, value in lookup_params.items():

   178             if not isinstance(key, str):

   179                 # 'key' will be used as a keyword argument later, so Python

   180                 # requires it to be a string.

   181                 del lookup_params[key]

   182                 lookup_params[smart_str(key)] = value

   183 

   184             # if key ends with __in, split parameter into separate values

   185             if key.endswith('__in'):

   186                 lookup_params[key] = value.split(',')

   187 

   188         # Apply lookup parameters from the query string.

   189         try:

   190             qs = qs.filter(**lookup_params)

   191         # Naked except! Because we don't have any other way of validating "params".

   192         # They might be invalid if the keyword arguments are incorrect, or if the

   193         # values are not in the correct type, so we might get FieldError, ValueError,

   194         # ValicationError, or ? from a custom field that raises yet something else 

   195         # when handed impossible data.

   196         except:

   197             raise IncorrectLookupParameters

   198 

   199         # Use select_related() if one of the list_display options is a field

   200         # with a relationship and the provided queryset doesn't already have

   201         # select_related defined.

   202         if not qs.query.select_related:

   203             if self.list_select_related:

   204                 qs = qs.select_related()

   205             else:

   206                 for field_name in self.list_display:

   207                     try:

   208                         f = self.lookup_opts.get_field(field_name)

   209                     except models.FieldDoesNotExist:

   210                         pass

   211                     else:

   212                         if isinstance(f.rel, models.ManyToOneRel):

   213                             qs = qs.select_related()

   214                             break

   215 

   216         # Set ordering.

   217         if self.order_field:

   218             qs = qs.order_by('%s%s' % ((self.order_type == 'desc' and '-' or ''), self.order_field))

   219 

   220         # Apply keyword searches.

   221         def construct_search(field_name):

   222             if field_name.startswith('^'):

   223                 return "%s__istartswith" % field_name[1:]

   224             elif field_name.startswith('='):

   225                 return "%s__iexact" % field_name[1:]

   226             elif field_name.startswith('@'):

   227                 return "%s__search" % field_name[1:]

   228             else:

   229                 return "%s__icontains" % field_name

   230 

   231         if self.search_fields and self.query:

   232             for bit in self.query.split():

   233                 or_queries = [models.Q(**{construct_search(str(field_name)): bit}) for field_name in self.search_fields]

   234                 qs = qs.filter(reduce(operator.or_, or_queries))

   235             for field_name in self.search_fields:

   236                 if '__' in field_name:

   237                     qs = qs.distinct()

   238                     break

   239 

   240         return qs

   241 

   242     def url_for_result(self, result):

   243         return "%s/" % quote(getattr(result, self.pk_attname))