class BaseDateListView

from django.views.generic.dates import BaseDateListView
Abstract base class for date-based views displaying a list of objects.

Attributes

  Defined in
allow_empty = False BaseDateListView
allow_empty = True MultipleObjectMixin
allow_future = False DateMixin
context_object_name = None MultipleObjectMixin
date_field = None DateMixin
date_list_period = 'year' BaseDateListView
http_method_names = [u'get', u'post', u'put', u'patch', u'delete', u'head', u'options', u'trace'] View
model = None MultipleObjectMixin
page_kwarg = 'page' MultipleObjectMixin
paginate_by = None MultipleObjectMixin
paginate_orphans = 0 MultipleObjectMixin
paginator_class = <class 'django.core.paginator.Paginator'> MultipleObjectMixin
queryset = None MultipleObjectMixin
uses_datetime_field = <django.utils.functional.cached_property object at 0x7fab32fee210> DateMixin
Expand Collapse

Methods

def __init__(self, **kwargs): View

Constructor. Called in the URLconf; can contain helpful extra
keyword arguments, and other things.
36
37
38
39
40
41
42
43
44
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 six.iteritems(kwargs):
        setattr(self, key, value)

def _allowed_methods(self): View

107
108
def _allowed_methods(self):
    return [m.upper() for m in self.http_method_names if hasattr(self, m)]

def _make_date_lookup_arg(self, value): DateMixin

Convert a date into a datetime when the date field is a DateTimeField.

When time zone support is enabled, `date` is assumed to be in the
current time zone, so that displayed items are consistent with the URL.
293
294
295
296
297
298
299
300
301
302
303
def _make_date_lookup_arg(self, value):
    """
    Convert a date into a datetime when the date field is a DateTimeField.
    When time zone support is enabled, `date` is assumed to be in the
    current time zone, so that displayed items are consistent with the URL.
    """
    if self.uses_datetime_field:
        value = datetime.datetime.combine(value, datetime.time.min)
        if settings.USE_TZ:
            value = timezone.make_aware(value, timezone.get_current_timezone())
    return value

def _make_single_date_lookup(self, date): DateMixin

Get the lookup kwargs for filtering on a single date.

If the date field is a DateTimeField, we can't just filter on
date_field=date because that doesn't take the time into account.
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
def _make_single_date_lookup(self, date):
    """
    Get the lookup kwargs for filtering on a single date.
    If the date field is a DateTimeField, we can't just filter on
    date_field=date because that doesn't take the time into account.
    """
    date_field = self.get_date_field()
    if self.uses_datetime_field:
        since = self._make_date_lookup_arg(date)
        until = self._make_date_lookup_arg(date + datetime.timedelta(days=1))
        return {
            '%s__gte' % date_field: since,
            '%s__lt' % date_field: until,
        }
    else:
        # Skip self._make_date_lookup_arg, it's a no-op in this branch.
        return {date_field: date}

def as_view(cls, **initkwargs): View

Main entry point for a request-response process.
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
@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("You tried to pass in the %s method name as a "
                            "keyword argument to %s(). Don't do that."
                            % (key, cls.__name__))
        if not hasattr(cls, key):
            raise TypeError("%s() received an invalid keyword %r. as_view "
                            "only accepts arguments that are already "
                            "attributes of the class." % (cls.__name__, key))
    def view(request, *args, **kwargs):
        self = cls(**initkwargs)
        if hasattr(self, 'get') and not hasattr(self, 'head'):
            self.head = self.get
        self.request = request
        self.args = args
        self.kwargs = kwargs
        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

79
80
81
82
83
84
85
86
87
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
    return handler(request, *args, **kwargs)

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

333
334
335
336
337
338
def get(self, request, *args, **kwargs):
    self.date_list, self.object_list, extra_context = self.get_dated_items()
    context = self.get_context_data(object_list=self.object_list,
                                    date_list=self.date_list)
    context.update(extra_context)
    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.
94
95
96
97
98
99
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_allow_future(self): DateMixin

Returns `True` if the view should be allowed to display objects from
the future.
273
274
275
276
277
278
def get_allow_future(self):
    """
    Returns `True` if the view should be allowed to display objects from
    the future.
    """
    return self.allow_future

def get_context_data(self, **kwargs):

MultipleObjectMixin

Get the context for this view.
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
def get_context_data(self, **kwargs):
    """
    Get the context for this view.
    """
    queryset = kwargs.pop('object_list', self.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
        }
    if context_object_name is not None:
        context[context_object_name] = queryset
    context.update(kwargs)
    return super(MultipleObjectMixin, self).get_context_data(**context)

ContextMixin

22
23
24
25
def get_context_data(self, **kwargs):
    if 'view' not in kwargs:
        kwargs['view'] = self
    return kwargs

def get_context_object_name(self, object_list): MultipleObjectMixin

Get the name of the item to be used in the context.
101
102
103
104
105
106
107
108
109
110
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 '%s_list' % object_list.model._meta.model_name
    else:
        return None

def get_date_field(self): DateMixin

Get the name of the date field to be used to filter by.
265
266
267
268
269
270
271
def get_date_field(self):
    """
    Get the name of the date field to be used to filter by.
    """
    if self.date_field is None:
        raise ImproperlyConfigured("%s.date_field is required." % self.__class__.__name__)
    return self.date_field

def get_date_list(self, queryset, date_type=None, ordering=u'ASC'): BaseDateListView

Get a date list by calling `queryset.dates/datetimes()`, checking
along the way for empty lists that aren't allowed.
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
def get_date_list(self, queryset, date_type=None, ordering='ASC'):
    """
    Get a date list by calling `queryset.dates/datetimes()`, checking
    along the way for empty lists that aren't allowed.
    """
    date_field = self.get_date_field()
    allow_empty = self.get_allow_empty()
    if date_type is None:
        date_type = self.get_date_list_period()
    if self.uses_datetime_field:
        date_list = queryset.datetimes(date_field, date_type, ordering)
    else:
        date_list = queryset.dates(date_field, date_type, ordering)
    if date_list is not None and not date_list and not allow_empty:
        name = force_text(queryset.model._meta.verbose_name_plural)
        raise Http404(_("No %(verbose_name_plural)s available") %
                      {'verbose_name_plural': name})
    return date_list

def get_date_list_period(self): BaseDateListView

Get the aggregation period for the list of dates: 'year', 'month', or 'day'.
375
376
377
378
379
def get_date_list_period(self):
    """
    Get the aggregation period for the list of dates: 'year', 'month', or 'day'.
    """
    return self.date_list_period

def get_dated_items(self): BaseDateListView

Obtain the list of dates and items.
340
341
342
343
344
def get_dated_items(self):
    """
    Obtain the list of dates and items.
    """
    raise NotImplementedError('A DateView must provide an implementation of get_dated_items()')

def get_dated_queryset(self, ordering=None, **lookup): BaseDateListView

Get a queryset properly filtered according to `allow_future` and any
extra lookup kwargs.
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
def get_dated_queryset(self, ordering=None, **lookup):
    """
    Get a queryset properly filtered according to `allow_future` and any
    extra lookup kwargs.
    """
    qs = self.get_queryset().filter(**lookup)
    date_field = self.get_date_field()
    allow_future = self.get_allow_future()
    allow_empty = self.get_allow_empty()
    paginate_by = self.get_paginate_by(qs)
    if ordering is not None:
        qs = qs.order_by(ordering)
    if not allow_future:
        now = timezone.now() if self.uses_datetime_field else timezone_today()
        qs = qs.filter(**{'%s__lte' % date_field: now})
    if not allow_empty:
        # When pagination is enabled, it's better to do a cheap query
        # than to load the unpaginated queryset in memory.
        is_empty = len(qs) == 0 if paginate_by is None else not qs.exists()
        if is_empty:
            raise Http404(_("No %(verbose_name_plural)s available") % {
                'verbose_name_plural': force_text(qs.model._meta.verbose_name_plural)
            })
    return qs

def get_paginate_by(self, queryset): MultipleObjectMixin

Get the number of items to paginate by, or ``None`` for no pagination.
72
73
74
75
76
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_paginate_orphans(self): MultipleObjectMixin

Returns the maximum number of orphans extend the last page by when
paginating.
87
88
89
90
91
92
def get_paginate_orphans(self):
    """
    Returns the maximum number of orphans extend the last page by when
    paginating.
    """
    return self.paginate_orphans

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

Return an instance of the paginator for this view.
78
79
80
81
82
83
84
85
def get_paginator(self, queryset, per_page, orphans=0,
                  allow_empty_first_page=True, **kwargs):
    """
    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, **kwargs)

def get_queryset(self): MultipleObjectMixin

Return the list of items for this view.

The return value must be an iterable and may be an instance of
`QuerySet` in which case `QuerySet` specific behavior will be enabled.
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
def get_queryset(self):
    """
    Return the list of items for this view.
    The return value must be an iterable and may be an instance of
    `QuerySet` in which case `QuerySet` specific behavior will be enabled.
    """
    if self.queryset is not None:
        queryset = self.queryset
        if isinstance(queryset, QuerySet):
            queryset = queryset.all()
    elif self.model is not None:
        queryset = self.model._default_manager.all()
    else:
        raise ImproperlyConfigured(
            "%(cls)s is missing a QuerySet. Define "
            "%(cls)s.model, %(cls)s.queryset, or override "
            "%(cls)s.get_queryset()." % {
                'cls': self.__class__.__name__
            }
        )
    return queryset

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

89
90
91
92
93
94
95
96
def http_method_not_allowed(self, request, *args, **kwargs):
    logger.warning('Method Not Allowed (%s): %s', request.method, request.path,
        extra={
            'status_code': 405,
            'request': request
        }
    )
    return http.HttpResponseNotAllowed(self._allowed_methods())

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

Handles responding to requests for the OPTIONS HTTP verb.
 98
 99
100
101
102
103
104
105
def options(self, request, *args, **kwargs):
    """
    Handles responding to requests for the OPTIONS HTTP verb.
    """
    response = http.HttpResponse()
    response['Allow'] = ', '.join(self._allowed_methods())
    response['Content-Length'] = '0'
    return response

def paginate_queryset(self, queryset, page_size): MultipleObjectMixin

Paginate the queryset, if needed.
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
def paginate_queryset(self, queryset, page_size):
    """
    Paginate the queryset, if needed.
    """
    paginator = self.get_paginator(
        queryset, page_size, orphans=self.get_paginate_orphans(),
        allow_empty_first_page=self.get_allow_empty())
    page_kwarg = self.page_kwarg
    page = self.kwargs.get(page_kwarg) or self.request.GET.get(page_kwarg) or 1
    try:
        page_number = int(page)
    except ValueError:
        if page == 'last':
            page_number = paginator.num_pages
        else:
            raise Http404(_("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 as e:
        raise Http404(_('Invalid page (%(page_number)s): %(message)s') % {
            'page_number': page_number,
            'message': str(e)
        })