class BaseWeekArchiveView

from django.views.generic.dates import BaseWeekArchiveView
List of objects published in a given week.

Attributes

  Defined in
allow_empty = True MultipleObjectMixin
allow_empty = False BaseDateListView
allow_future = False DateMixin
context_object_name = None MultipleObjectMixin
date_field = None DateMixin
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
week = None WeekMixin
week_format = '%U' WeekMixin
year = None YearMixin
year_format = '%Y' YearMixin
Expand Collapse

Methods

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): BaseDateListView

171
172
173
174
175
176
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.
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_allow_future(self): DateMixin

Returns `True` if the view should be allowed to display objects from
the future.
157
158
159
160
161
162
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):

BaseDateListView

Get the context. Must return a Context (or subclass) instance.
220
221
222
223
224
225
226
227
def get_context_data(self, **kwargs):
    """
    Get the context. Must return a Context (or subclass) instance.
    """
    items = kwargs.pop('object_list')
    context = super(BaseDateListView, self).get_context_data(object_list=items)
    context.update(kwargs)
    return context

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_dated_items(self):

BaseWeekArchiveView

Return (date_list, items, extra_context) for this request.
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
def get_dated_items(self):
    """
    Return (date_list, items, extra_context) for this request.
    """
    year = self.get_year()
    week = self.get_week()
    date_field = self.get_date_field()
    week_format = self.get_week_format()
    week_start = {
        '%W': '1',
        '%U': '0',
    }[week_format]
    date = _date_from_string(year, self.get_year_format(),
                             week_start, '%w',
                             week, week_format)
    # Construct a date-range lookup.
    first_day = date
    last_day = date + datetime.timedelta(days=7)
    lookup_kwargs = {
        '%s__gte' % date_field: first_day,
        '%s__lt' % date_field: last_day,
    }
    qs = self.get_dated_queryset(**lookup_kwargs)
    return (None, qs, {'week': date})

BaseDateListView

Obtain the list of dates and itesm
178
179
180
181
182
def get_dated_items(self):
    """
    Obtain the list of dates and itesm
    """
    raise NotImplementedError('A DateView must provide an implementation of get_dated_items()')

def get_dated_queryset(self, **lookup): BaseDateListView

Get a queryset properly filtered according to `allow_future` and any
extra lookup kwargs.
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
def get_dated_queryset(self, **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()
    if not allow_future:
        qs = qs.filter(**{'%s__lte' % date_field: datetime.datetime.now()})
    if not allow_empty and not qs:
        raise Http404(_(u"No %(verbose_name_plural)s available") % {
                'verbose_name_plural': force_unicode(qs.model._meta.verbose_name_plural)
        })
    return qs

def get_date_field(self): DateMixin

Get the name of the date field to be used to filter by.
149
150
151
152
153
154
155
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(u"%s.date_field is required." % self.__class__.__name__)
    return self.date_field

def get_date_list(self, queryset, date_type): BaseDateListView

Get a date list by calling `queryset.dates()`, checking along the way
for empty lists that aren't allowed.
204
205
206
207
208
209
210
211
212
213
214
215
216
def get_date_list(self, queryset, date_type):
    """
    Get a date list by calling `queryset.dates()`, checking along the way
    for empty lists that aren't allowed.
    """
    date_field = self.get_date_field()
    allow_empty = self.get_allow_empty()
    date_list = queryset.dates(date_field, date_type)[::-1]
    if date_list is not None and not date_list and not allow_empty:
        name = force_unicode(queryset.model._meta.verbose_name_plural)
        raise Http404(_(u"No %(verbose_name_plural)s available") %
                      {'verbose_name_plural': name})
    return date_list

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_week(self): WeekMixin

Return the week for which this view should display data
128
129
130
131
132
133
134
135
136
137
138
139
def get_week(self):
    "Return the week for which this view should display data"
    week = self.week
    if week is None:
        try:
            week = self.kwargs['week']
        except KeyError:
            try:
                week = self.request.GET['week']
            except KeyError:
                raise Http404(_(u"No week specified"))
    return week

def get_week_format(self): WeekMixin

Get a week format string in strptime syntax to be used to parse the
week from url variables.
121
122
123
124
125
126
def get_week_format(self):
    """
    Get a week format string in strptime syntax to be used to parse the
    week from url variables.
    """
    return self.week_format

def get_year(self): YearMixin

Return the year for which this view should display data
23
24
25
26
27
28
29
30
31
32
33
34
def get_year(self):
    "Return the year for which this view should display data"
    year = self.year
    if year is None:
        try:
            year = self.kwargs['year']
        except KeyError:
            try:
                year = self.request.GET['year']
            except KeyError:
                raise Http404(_(u"No year specified"))
    return year

def get_year_format(self): YearMixin

Get a year format string in strptime syntax to be used to parse the
year from url variables.
16
17
18
19
20
21
def get_year_format(self):
    """
    Get a year format string in strptime syntax to be used to parse the
    year from url variables.
    """
    return self.year_format

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 __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 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
        })