root/django/branches/0.90-bugfixes/django/contrib/admin/views/main.py

# Generic admin views, with admin templates created dynamically at runtime.

from django.contrib.admin.views.decorators import staff_member_required
from django.core import formfields, meta
from django.core.template import loader
from django.core.exceptions import Http404, ObjectDoesNotExist, PermissionDenied
from django.core.extensions import DjangoContext as Context
from django.core.extensions import get_object_or_404, render_to_response
from django.models.admin import log
from django.utils.html import strip_tags
from django.utils.httpwrappers import HttpResponse, HttpResponseRedirect
from django.utils.text import capfirst, get_text_list
from django.conf.settings import ADMIN_MEDIA_PREFIX
from django.utils.translation import get_date_formats
import operator

# Text to display within changelist table cells if the value is blank.
EMPTY_CHANGELIST_VALUE = '(None)'

def _get_mod_opts(app_label, module_name):
    "Helper function that returns a tuple of (module, opts), raising Http404 if necessary."
    try:
        mod = meta.get_module(app_label, module_name)
    except ImportError:
        raise Http404 # Invalid app or module name. Maybe it's not in INSTALLED_APPS.
    opts = mod.Klass._meta
    if not opts.admin:
        raise Http404 # This object is valid but has no admin interface.
    return mod, opts

def get_query_string(original_params, new_params={}, remove=[]):
    """
    >>> get_query_string({'first_name': 'adrian', 'last_name': 'smith'})
    '?first_name=adrian&last_name=smith'
    >>> get_query_string({'first_name': 'adrian', 'last_name': 'smith'}, {'first_name': 'john'})
    '?first_name=john&last_name=smith'
    >>> get_query_string({'test': 'yes'}, {'blah': 'no'}, ['te'])
    '?blah=no'
    """
    p = original_params.copy()
    for r in remove:
        for k in p.keys():
            if k.startswith(r):
                del p[k]
    for k, v in new_params.items():
        if p.has_key(k) and v is None:
            del p[k]
        elif v is not None:
            p[k] = v
    return '?' + '&'.join(['%s=%s' % (k, v) for k, v in p.items()]).replace(' ', '%20')

def index(request):
    return render_to_response('admin/index', {'title': 'Site administration'}, context_instance=Context(request))
index = staff_member_required(index)

def change_list(request, app_label, module_name):
    from django.core import paginator
    from django.utils import dateformat
    from django.utils.dates import MONTHS
    from django.utils.html import escape
    import datetime

    # The system will display a "Show all" link only if the total result count
    # is less than or equal to this setting.
    MAX_SHOW_ALL_ALLOWED = 200

    DEFAULT_RESULTS_PER_PAGE = 100

    ALL_VAR = 'all'
    ORDER_VAR = 'o'
    ORDER_TYPE_VAR = 'ot'
    PAGE_VAR = 'p'
    SEARCH_VAR = 'q'
    IS_POPUP_VAR = 'pop'

    mod, opts = _get_mod_opts(app_label, module_name)
    if not request.user.has_perm(app_label + '.' + opts.get_change_permission()):
        raise PermissionDenied

    lookup_mod, lookup_opts = mod, opts

    if opts.one_to_one_field:
        lookup_mod = opts.one_to_one_field.rel.to.get_model_module()
        lookup_opts = lookup_mod.Klass._meta
        # If lookup_opts doesn't have admin set, give it the default meta.Admin().
        if not lookup_opts.admin:
            lookup_opts.admin = meta.Admin()

    # Get search parameters from the query string.
    try:
        page_num = int(request.GET.get(PAGE_VAR, 0))
    except ValueError:
        page_num = 0
    show_all = request.GET.has_key(ALL_VAR)
    is_popup = request.GET.has_key(IS_POPUP_VAR)
    params = dict(request.GET.copy())
    if params.has_key(PAGE_VAR):
        del params[PAGE_VAR]
    # For ordering, first check the "ordering" parameter in the admin options,
    # then check the object's default ordering. If neither of those exist,
    # order descending by ID by default. Finally, look for manually-specified
    # ordering from the query string.
    ordering = lookup_opts.admin.ordering or lookup_opts.ordering or ['-' + lookup_opts.pk.name]

    # Normalize it to new-style ordering.
    ordering = meta.handle_legacy_orderlist(ordering)

    if ordering[0].startswith('-'):
        order_field, order_type = ordering[0][1:], 'desc'
    else:
        order_field, order_type = ordering[0], 'asc'
    if params.has_key(ORDER_VAR):
        try:
            try:
                f = lookup_opts.get_field(lookup_opts.admin.list_display[int(params[ORDER_VAR])])
            except meta.FieldDoesNotExist:
                pass
            else:
                if not isinstance(f.rel, meta.ManyToOne) or not f.null:
                    order_field = f.name
        except (IndexError, ValueError):
            pass # Invalid ordering specified. Just use the default.
    if params.has_key(ORDER_TYPE_VAR) and params[ORDER_TYPE_VAR] in ('asc', 'desc'):
        order_type = params[ORDER_TYPE_VAR]
    query = request.GET.get(SEARCH_VAR, '')

    # Prepare the lookup parameters for the API lookup.
    lookup_params = params.copy()
    for i in (ALL_VAR, ORDER_VAR, ORDER_TYPE_VAR, SEARCH_VAR, IS_POPUP_VAR):
        if lookup_params.has_key(i):
            del lookup_params[i]
    # If the order-by field is a field with a relationship, order by the value
    # in the related table.
    lookup_order_field = order_field
    if isinstance(lookup_opts.get_field(order_field).rel, meta.ManyToOne):
        f = lookup_opts.get_field(order_field)
        rel_ordering = f.rel.to.ordering and f.rel.to.ordering[0] or f.rel.to.pk.column
        lookup_order_field = '%s.%s' % (f.rel.to.db_table, rel_ordering)
    if lookup_opts.admin.list_select_related:
        lookup_params['select_related'] = True
    else:
        # Use select_related if one of the list_display options is a field with
        # a relationship.
        for field_name in lookup_opts.admin.list_display:
            try:
                f = lookup_opts.get_field(field_name)
            except meta.FieldDoesNotExist:
                pass
            else:
                if isinstance(f.rel, meta.ManyToOne):
                    lookup_params['select_related'] = True
                    break
    lookup_params['order_by'] = ((order_type == 'desc' and '-' or '') + lookup_order_field,)
    if lookup_opts.admin.search_fields and query:
        or_queries = []
        for bit in query.split():
            or_query = []
            for field_name in lookup_opts.admin.search_fields:
                or_query.append(('%s__icontains' % field_name, bit))
            or_queries.append(or_query)
        lookup_params['_or'] = or_queries

    if opts.one_to_one_field:
        lookup_params.update(opts.one_to_one_field.rel.limit_choices_to)

    # Get the results.
    try:
        p = paginator.ObjectPaginator(lookup_mod, lookup_params, DEFAULT_RESULTS_PER_PAGE)
    # Naked except! Because we don't have any other way of validating "params".
    # They might be invalid if the keyword arguments are incorrect, or if the
    # values are not in the correct type (which would result in a database
    # error).
    except:
        return HttpResponseRedirect(request.path)

    # Get the total number of objects, with no filters applied.
    real_lookup_params = lookup_params.copy()
    del real_lookup_params['order_by']
    if real_lookup_params:
        full_result_count = lookup_mod.get_count()
    else:
        full_result_count = p.hits
    del real_lookup_params
    result_count = p.hits
    can_show_all = result_count <= MAX_SHOW_ALL_ALLOWED
    multi_page = result_count > DEFAULT_RESULTS_PER_PAGE

    # Get the list of objects to display on this page.
    if (show_all and can_show_all) or not multi_page:
        result_list = lookup_mod.get_list(**lookup_params)
    else:
        try:
            result_list = p.get_page(page_num)
        except paginator.InvalidPage:
            result_list = []

    # Calculate filters first, because a CSS class high in the document depends
    # on whether they are available.
    filter_template = []
    if lookup_opts.admin.list_filter and not opts.one_to_one_field:
        filter_fields = [lookup_opts.get_field(field_name) for field_name in lookup_opts.admin.list_filter]
        for f in filter_fields:
            # Many-to-many or many-to-one filter.
            if f.rel:
                if isinstance(f, meta.ManyToManyField):
                    lookup_title = f.rel.to.verbose_name
                else:
                    lookup_title = f.verbose_name
                lookup_kwarg = '%s__%s__exact' % (f.name, f.rel.to.pk.name)
                lookup_val = request.GET.get(lookup_kwarg, None)
                lookup_choices = f.rel.to.get_model_module().get_list()
                if len(lookup_choices) > 1:
                    filter_template.append('<h3>By %s:</h3>\n<ul>\n' % lookup_title)
                    filter_template.append('<li%s><a href="%s">All</a></li>\n' % \
                        ((lookup_val is None and ' class="selected"' or ''),
                        get_query_string(params, {}, [lookup_kwarg])))
                    for val in lookup_choices:
                        pk_val = getattr(val, f.rel.to.pk.attname)
                        filter_template.append('<li%s><a href="%s">%r</a></li>\n' % \
                            ((lookup_val == str(pk_val) and ' class="selected"' or ''),
                            get_query_string(params, {lookup_kwarg: pk_val}), val))
                    filter_template.append('</ul>\n\n')
            # Field with choices.
            elif f.choices:
                lookup_kwarg = '%s__exact' % f.name
                lookup_val = request.GET.get(lookup_kwarg, None)
                filter_template.append('<h3>By %s:</h3><ul>\n' % f.verbose_name)
                filter_template.append('<li%s><a href="%s">All</a></li>\n' % \
                    ((lookup_val is None and ' class="selected"' or ''),
                    get_query_string(params, {}, [lookup_kwarg])))
                for k, v in f.choices:
                    filter_template.append('<li%s><a href="%s">%s</a></li>' % \
                        ((str(k) == lookup_val) and ' class="selected"' or '',
                        get_query_string(params, {lookup_kwarg: k}), v))
                filter_template.append('</ul>\n\n')
            # Date filter.
            elif isinstance(f, meta.DateField):
                today = datetime.date.today()
                one_week_ago = today - datetime.timedelta(days=7)
                field_generic = '%s__' % f.name
                filter_template.append('<h3>By %s:</h3><ul>\n' % f.verbose_name)
                date_params = dict([(k, v) for k, v in params.items() if k.startswith(field_generic)])
                today_str = isinstance(f, meta.DateTimeField) and today.strftime('%Y-%m-%d 23:59:59') or today.strftime('%Y-%m-%d')
                for title, param_dict in (
                    ('Any date', {}),
                    ('Today', {'%s__year' % f.name: str(today.year), '%s__month' % f.name: str(today.month), '%s__day' % f.name: str(today.day)}),
                    ('Past 7 days', {'%s__gte' % f.name: one_week_ago.strftime('%Y-%m-%d'), '%s__lte' % f.name: today_str}),
                    ('This month', {'%s__year' % f.name: str(today.year), '%s__month' % f.name: str(today.month)}),
                    ('This year', {'%s__year' % f.name: str(today.year)})
                ):
                    filter_template.append('<li%s><a href="%s">%s</a></li>\n' % \
                        ((date_params == param_dict) and ' class="selected"' or '',
                        get_query_string(params, param_dict, field_generic), title))
                filter_template.append('</ul>\n\n')
            elif isinstance(f, meta.BooleanField) or isinstance(f, meta.NullBooleanField):
                lookup_kwarg = '%s__exact' % f.name
                lookup_kwarg2 = '%s__isnull' % f.name
                lookup_val = request.GET.get(lookup_kwarg, None)
                lookup_val2 = request.GET.get(lookup_kwarg2, None)
                filter_template.append('<h3>By %s:</h3><ul>\n' % f.verbose_name)
                for k, v in (('All', None), ('Yes', '1'), ('No', '0')):
                    filter_template.append('<li%s><a href="%s">%s</a></li>\n' % \
                        (((lookup_val == v and not lookup_val2) and ' class="selected"' or ''),
                        get_query_string(params, {lookup_kwarg: v}, [lookup_kwarg2]), k))
                if isinstance(f, meta.NullBooleanField):
                    filter_template.append('<li%s><a href="%s">%s</a></li>\n' % \
                        (((lookup_val2 == 'True') and ' class="selected"' or ''),
                        get_query_string(params, {lookup_kwarg2: 'True'}, [lookup_kwarg]), 'Unknown'))
                filter_template.append('</ul>\n\n')
            else:
                pass # Invalid argument to "list_filter"

    raw_template = ['{% extends "admin/base_site" %}\n']
    raw_template.append('{% block bodyclass %}change-list{% endblock %}\n')
    if not is_popup:
        raw_template.append('{%% block breadcrumbs %%}<div class="breadcrumbs"><a href="../../">Home</a> &rsaquo; %s</div>{%% endblock %%}\n' % capfirst(opts.verbose_name_plural))
    raw_template.append('{% block coltype %}flex{% endblock %}')
    raw_template.append('{% block content %}\n')
    raw_template.append('<div id="content-main">\n')
    if request.user.has_perm(app_label + '.' + lookup_opts.get_add_permission()):
        raw_template.append('<ul class="object-tools"><li><a href="add/%s" class="addlink">Add %s</a></li></ul>\n' % ((is_popup and '?_popup=1' or ''), opts.verbose_name))
    raw_template.append('<div class="module%s" id="changelist">\n' % (filter_template and ' filtered' or ''))

    # Search form.
    if lookup_opts.admin.search_fields:
        raw_template.append('<div id="toolbar">\n<form id="changelist-search" action="" method="get">\n')
        raw_template.append('<label><img src="%simg/admin/icon_searchbox.png" /></label> ' % ADMIN_MEDIA_PREFIX)
        raw_template.append('<input type="text" size="40" name="%s" value="%s" id="searchbar" /> ' % \
            (SEARCH_VAR, escape(query)))
        raw_template.append('<input type="submit" value="Go" /> ')
        if result_count != full_result_count and not opts.one_to_one_field:
            raw_template.append('<span class="small quiet">%s result%s (<a href="?">%s total</a>)</span>' % \
                (result_count, (result_count != 1 and 's' or ''), full_result_count))
        for k, v in params.items():
            if k != SEARCH_VAR:
                raw_template.append('<input type="hidden" name="%s" value="%s" />' % (escape(k), escape(v)))
        raw_template.append('</form></div>\n')
        raw_template.append('<script type="text/javascript">document.getElementById("searchbar").focus();</script>')

    # Date-based navigation.
    if lookup_opts.admin.date_hierarchy:
        field_name = lookup_opts.admin.date_hierarchy

        year_field = '%s__year' % field_name
        month_field = '%s__month' % field_name
        day_field = '%s__day' % field_name
        field_generic = '%s__' % field_name
        year_lookup = params.get(year_field)
        month_lookup = params.get(month_field)
        day_lookup = params.get(day_field)

        raw_template.append('<div class="xfull">\n<ul class="toplinks">\n')
        if year_lookup and month_lookup and day_lookup:
            raw_template.append('<li class="date-back"><a href="%s">&lsaquo; %s %s </a></li>' % \
                (get_query_string(params, {year_field: year_lookup, month_field: month_lookup}, [field_generic]), MONTHS[int(month_lookup)], year_lookup))
            raw_template.append('<li>%s %s</li>' % (MONTHS[int(month_lookup)], day_lookup))
        elif year_lookup and month_lookup:
            raw_template.append('<li class="date-back"><a href="%s">&lsaquo; %s</a></li>' % \
                (get_query_string(params, {year_field: year_lookup}, [field_generic]), year_lookup))
            date_lookup_params = lookup_params.copy()
            date_lookup_params.update({year_field: year_lookup, month_field: month_lookup})
            for day in getattr(lookup_mod, 'get_%s_list' % field_name)('day', **date_lookup_params):
                raw_template.append('<li><a href="%s">%s</a></li>' % \
                    (get_query_string(params, {year_field: year_lookup, month_field: month_lookup, day_field: day.day}, [field_generic]), day.strftime('%B %d')))
        elif year_lookup:
            raw_template.append('<li class="date-back"><a href="%s">&lsaquo; All dates</a></li>' % \
                get_query_string(params, {}, [year_field]))
            date_lookup_params = lookup_params.copy()
            date_lookup_params.update({year_field: year_lookup})
            for month in getattr(lookup_mod, 'get_%s_list' % field_name)('month', **date_lookup_params):
                raw_template.append('<li><a href="%s">%s %s</a></li>' % \
                    (get_query_string(params, {year_field: year_lookup, month_field: month.month}, [field_generic]), month.strftime('%B'), month.year))
        else:
            for year in getattr(lookup_mod, 'get_%s_list' % field_name)('year', **lookup_params):
                raw_template.append('<li><a href="%s">%s</a></li>\n' % \
                    (get_query_string(params, {year_field: year.year}, [field_generic]), year.year))
        raw_template.append('</ul><br class="clear" />\n</div>\n')

    # Filters.
    if filter_template:
        raw_template.append('<div id="changelist-filter">\n<h2>Filter</h2>\n')
        raw_template.extend(filter_template)
        raw_template.append('</div>')
    del filter_template

    # Result table.
    if result_list:
        # Table headers.
        raw_template.append('<table cellspacing="0">\n<thead>\n<tr>\n')
        for i, field_name in enumerate(lookup_opts.admin.list_display):
            try:
                f = lookup_opts.get_field(field_name)
            except meta.FieldDoesNotExist:
                # For non-field list_display values, check for the function
                # attribute "short_description". If that doesn't exist, fall
                # back to the method name. And __repr__ is a special-case.
                if field_name == '__repr__':
                    header = lookup_opts.verbose_name
                else:
                    func = getattr(mod.Klass, field_name) # Let AttributeErrors propogate.
                    try:
                        header = func.short_description
                    except AttributeError:
                        header = func.__name__
                # Non-field list_display values don't get ordering capability.
                raw_template.append('<th>%s</th>' % capfirst(header))
            else:
                if isinstance(f.rel, meta.ManyToOne) and f.null:
                    raw_template.append('<th>%s</th>' % capfirst(f.verbose_name))
                else:
                    th_classes = []
                    new_order_type = 'asc'
                    if field_name == order_field:
                        th_classes.append('sorted %sending' % order_type.lower())
                        new_order_type = {'asc': 'desc', 'desc': 'asc'}[order_type.lower()]
                    raw_template.append('<th%s><a href="%s">%s</a></th>' % \
                        ((th_classes and ' class="%s"' % ' '.join(th_classes) or ''),
                        get_query_string(params, {ORDER_VAR: i, ORDER_TYPE_VAR: new_order_type}),
                        capfirst(f.verbose_name)))
        raw_template.append('</tr>\n</thead>\n')
        # Result rows.
        pk = lookup_opts.pk.attname
        for i, result in enumerate(result_list):
            raw_template.append('<tr class="row%s">\n' % (i % 2 + 1))
            for j, field_name in enumerate(lookup_opts.admin.list_display):
                row_class = ''
                try:
                    f = lookup_opts.</