class ListView

from django.views.generic import ListView
Render some list of objects, set by `self.model` or `self.queryset`.
`self.queryset` can actually be any iterable of items, not just a queryset.

Attributes

  Defined in
allow_empty = True MultipleObjectMixin
context_object_name = None MultipleObjectMixin
http_method_names = ['get', 'post', 'put', 'delete', 'head', 'options', 'trace'] View
model = None MultipleObjectMixin
paginate_by = None MultipleObjectMixin
paginator_class = <class 'django.core.paginator.Paginator'> MultipleObjectMixin
queryset = None MultipleObjectMixin
response_class = <class 'django.template.response.TemplateResponse'> TemplateResponseMixin
template_name = None TemplateResponseMixin
template_name_suffix = '_list' MultipleObjectTemplateResponseMixin
Expand Collapse

Methods

def __init__(self, **kwargs): View

Constructor. Called in the URLconf; can contain helpful extra
keyword arguments, and other things.
20
21
22
23
24
25
26
27
28
def __init__(self, **kwargs):
    """
    Constructor. Called in the URLconf; can contain helpful extra
    keyword arguments, and other things.
    """
    # Go through keyword arguments, and either save their values to our
    # instance, or raise an error.
    for key, value in kwargs.iteritems():
        setattr(self, key, value)

def as_view(cls, **initkwargs): View

Main entry point for a request-response process.
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
@classonlymethod
def as_view(cls, **initkwargs):
    """
    Main entry point for a request-response process.
    """
    # sanitize keyword arguments
    for key in initkwargs:
        if key in cls.http_method_names:
            raise TypeError(u"You tried to pass in the %s method name as a "
                            u"keyword argument to %s(). Don't do that."
                            % (key, cls.__name__))
        if not hasattr(cls, key):
            raise TypeError(u"%s() received an invalid keyword %r" % (
                cls.__name__, key))
    def view(request, *args, **kwargs):
        self = cls(**initkwargs)
        return self.dispatch(request, *args, **kwargs)
    # take name and docstring from class
    update_wrapper(view, cls, updated=())
    # and possible attributes set by decorators
    # like csrf_exempt from dispatch
    update_wrapper(view, cls.dispatch, assigned=())
    return view

def dispatch(self, request, *args, **kwargs): View

57
58
59
60
61
62
63
64
65
66
67
68
def dispatch(self, request, *args, **kwargs):
    # Try to dispatch to the right method; if a method doesn't exist,
    # defer to the error handler. Also defer to the error handler if the
    # request method isn't on the approved list.
    if request.method.lower() in self.http_method_names:
        handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
    else:
        handler = self.http_method_not_allowed
    self.request = request
    self.args = args
    self.kwargs = kwargs
    return handler(request, *args, **kwargs)

def get(self, request, *args, **kwargs): BaseListView

115
116
117
118
119
120
121
122
def get(self, request, *args, **kwargs):
    self.object_list = self.get_queryset()
    allow_empty = self.get_allow_empty()
    if not allow_empty and len(self.object_list) == 0:
        raise Http404(_(u"Empty list and '%(class_name)s.allow_empty' is False.")
                      % {'class_name': self.__class__.__name__})
    context = self.get_context_data(object_list=self.object_list)
    return self.render_to_response(context)

def get_allow_empty(self): MultipleObjectMixin

Returns ``True`` if the view should display empty lists, and ``False``
if a 404 should be raised instead.
68
69
70
71
72
73
def get_allow_empty(self):
    """
    Returns ``True`` if the view should display empty lists, and ``False``
    if a 404 should be raised instead.
    """
    return self.allow_empty

def get_context_data(self, **kwargs): MultipleObjectMixin

Get the context for this view.
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
def get_context_data(self, **kwargs):
    """
    Get the context for this view.
    """
    queryset = kwargs.pop('object_list')
    page_size = self.get_paginate_by(queryset)
    context_object_name = self.get_context_object_name(queryset)
    if page_size:
        paginator, page, queryset, is_paginated = self.paginate_queryset(queryset, page_size)
        context = {
            'paginator': paginator,
            'page_obj': page,
            'is_paginated': is_paginated,
            'object_list': queryset
        }
    else:
        context = {
            'paginator': None,
            'page_obj': None,
            'is_paginated': False,
            'object_list': queryset
        }
    context.update(kwargs)
    if context_object_name is not None:
        context[context_object_name] = queryset
    return context

def get_context_object_name(self, object_list): MultipleObjectMixin

Get the name of the item to be used in the context.
75
76
77
78
79
80
81
82
83
84
def get_context_object_name(self, object_list):
    """
    Get the name of the item to be used in the context.
    """
    if self.context_object_name:
        return self.context_object_name
    elif hasattr(object_list, 'model'):
        return smart_str('%s_list' % object_list.model._meta.object_name.lower())
    else:
        return None

def get_paginate_by(self, queryset): MultipleObjectMixin

Get the number of items to paginate by, or ``None`` for no pagination.
56
57
58
59
60
def get_paginate_by(self, queryset):
    """
    Get the number of items to paginate by, or ``None`` for no pagination.
    """
    return self.paginate_by

def get_paginator(self, queryset, per_page, orphans=0, allow_empty_first_page=True): MultipleObjectMixin

Return an instance of the paginator for this view.
62
63
64
65
66
def get_paginator(self, queryset, per_page, orphans=0, allow_empty_first_page=True):
    """
    Return an instance of the paginator for this view.
    """
    return self.paginator_class(queryset, per_page, orphans=orphans, allow_empty_first_page=allow_empty_first_page)

def get_queryset(self): MultipleObjectMixin

Get the list of items for this view. This must be an interable, and may
be a queryset (in which qs-specific behavior will be enabled).
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
def get_queryset(self):
    """
    Get the list of items for this view. This must be an interable, and may
    be a queryset (in which qs-specific behavior will be enabled).
    """
    if self.queryset is not None:
        queryset = self.queryset
        if hasattr(queryset, '_clone'):
            queryset = queryset._clone()
    elif self.model is not None:
        queryset = self.model._default_manager.all()
    else:
        raise ImproperlyConfigured(u"'%s' must define 'queryset' or 'model'"
                                   % self.__class__.__name__)
    return queryset

def get_template_names(self):

MultipleObjectTemplateResponseMixin

Return a list of template names to be used for the request. Must return
a list. May not be called if get_template is overridden.
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
def get_template_names(self):
    """
    Return a list of template names to be used for the request. Must return
    a list. May not be called if get_template is overridden.
    """
    try:
        names = super(MultipleObjectTemplateResponseMixin, self).get_template_names()
    except ImproperlyConfigured:
        # If template_name isn't specified, it's not a problem --
        # we just start with an empty list.
        names = []
    # If the list is a queryset, we'll invent a template name based on the
    # app and model name. This name gets put at the end of the template
    # name list so that user-supplied names override the automatically-
    # generated ones.
    if hasattr(self.object_list, 'model'):
        opts = self.object_list.model._meta
        names.append("%s/%s%s.html" % (opts.app_label, opts.object_name.lower(), self.template_name_suffix))
    return names

TemplateResponseMixin

Returns a list of template names to be used for the request. Must return
a list. May not be called if render_to_response is overridden.
 99
100
101
102
103
104
105
106
107
108
109
def get_template_names(self):
    """
    Returns a list of template names to be used for the request. Must return
    a list. May not be called if render_to_response is overridden.
    """
    if self.template_name is None:
        raise ImproperlyConfigured(
            "TemplateResponseMixin requires either a definition of "
            "'template_name' or an implementation of 'get_template_names()'")
    else:
        return [self.template_name]

def http_method_not_allowed(self, request, *args, **kwargs): View

70
71
72
73
74
75
76
77
78
def http_method_not_allowed(self, request, *args, **kwargs):
    allowed_methods = [m for m in self.http_method_names if hasattr(self, m)]
    logger.warning('Method Not Allowed (%s): %s' % (request.method, request.path),
        extra={
            'status_code': 405,
            'request': self.request
        }
    )
    return http.HttpResponseNotAllowed(allowed_methods)

def paginate_queryset(self, queryset, page_size): MultipleObjectMixin

Paginate the queryset, if needed.
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
def paginate_queryset(self, queryset, page_size):
    """
    Paginate the queryset, if needed.
    """
    paginator = self.get_paginator(queryset, page_size, allow_empty_first_page=self.get_allow_empty())
    page = self.kwargs.get('page') or self.request.GET.get('page') or 1
    try:
        page_number = int(page)
    except ValueError:
        if page == 'last':
            page_number = paginator.num_pages
        else:
            raise Http404(_(u"Page is not 'last', nor can it be converted to an int."))
    try:
        page = paginator.page(page_number)
        return (paginator, page, page.object_list, page.has_other_pages())
    except InvalidPage:
        raise Http404(_(u'Invalid page (%(page_number)s)') % {
                            'page_number': page_number
        })

def render_to_response(self, context, **response_kwargs): TemplateResponseMixin

Returns a response with a template rendered with the given context.
88
89
90
91
92
93
94
95
96
97
def render_to_response(self, context, **response_kwargs):
    """
    Returns a response with a template rendered with the given context.
    """
    return self.response_class(
        request = self.request,
        template = self.get_template_names(),
        context = context,
        **response_kwargs
    )