class BaseDateDetailView

from django.views.generic.dates import BaseDateDetailView
Detail view of a single object on a single date; this differs from the
standard DetailView by accepting a year/month/day in the URL.

Attributes

  Defined in
allow_future = False DateMixin
context_object_name = None SingleObjectMixin
date_field = None DateMixin
day = None DayMixin
day_format = '%d' DayMixin
http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace'] View
model = None SingleObjectMixin
month = None MonthMixin
month_format = '%b' MonthMixin
pk_url_kwarg = 'pk' SingleObjectMixin
query_pk_and_slug = False SingleObjectMixin
queryset = None SingleObjectMixin
slug_field = 'slug' SingleObjectMixin
slug_url_kwarg = 'slug' SingleObjectMixin
uses_datetime_field = <django.utils.functional.cached_property object at 0x7f8299fbb3c8> DateMixin
year = None YearMixin
year_format = '%Y' YearMixin
Expand Collapse

Methods

def __init__(self, **kwargs): View

Constructor. Called in the URLconf; can contain helpful extra
keyword arguments, and other things.
39
40
41
42
43
44
45
46
47
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

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

def _get_current_day(self, date): DayMixin

Return the start date of the current interval.
186
187
188
189
190
def _get_current_day(self, date):
    """
    Return the start date of the current interval.
    """
    return date

def _get_current_month(self, date): MonthMixin

Return the start date of the previous interval.
130
131
132
133
134
def _get_current_month(self, date):
    """
    Return the start date of the previous interval.
    """
    return date.replace(day=1)

def _get_current_year(self, date): YearMixin

Return the start date of the current interval.
71
72
73
74
75
def _get_current_year(self, date):
    """
    Return the start date of the current interval.
    """
    return date.replace(month=1, day=1)

def _get_next_day(self, date): DayMixin

Return the start date of the next interval.

The interval is defined by start date <= item date < next start date.
178
179
180
181
182
183
def _get_next_day(self, date):
    """
    Return the start date of the next interval.
    The interval is defined by start date <= item date < next start date.
    """
    return date + datetime.timedelta(days=1)

def _get_next_month(self, date): MonthMixin

Return the start date of the next interval.

The interval is defined by start date <= item date < next start date.
119
120
121
122
123
124
125
126
127
def _get_next_month(self, date):
    """
    Return the start date of the next interval.
    The interval is defined by start date <= item date < next start date.
    """
    if date.month == 12:
        return date.replace(year=date.year + 1, month=1, day=1)
    else:
        return date.replace(month=date.month + 1, day=1)

def _get_next_year(self, date): YearMixin

Return the start date of the next interval.

The interval is defined by start date <= item date < next start date.
63
64
65
66
67
68
def _get_next_year(self, date):
    """
    Return the start date of the next interval.
    The interval is defined by start date <= item date < next start date.
    """
    return date.replace(year=date.year + 1, month=1, day=1)

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.
298
299
300
301
302
303
304
305
306
307
308
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.
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
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.
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
75
76
@classonlymethod
def as_view(cls, **initkwargs):
    """
    Main entry point for a request-response process.
    """
    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

81
82
83
84
85
86
87
88
89
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): BaseDetailView

114
115
116
117
def get(self, request, *args, **kwargs):
    self.object = self.get_object()
    context = self.get_context_data(object=self.object)
    return self.render_to_response(context)

def get_allow_future(self): DateMixin

Returns `True` if the view should be allowed to display objects from
the future.
278
279
280
281
282
283
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):

SingleObjectMixin

Insert the single object into the context dict.
 96
 97
 98
 99
100
101
102
103
104
105
106
107
def get_context_data(self, **kwargs):
    """
    Insert the single object into the context dict.
    """
    context = {}
    if self.object:
        context['object'] = self.object
        context_object_name = self.get_context_object_name(self.object)
        if context_object_name:
            context[context_object_name] = self.object
    context.update(kwargs)
    return super(SingleObjectMixin, self).get_context_data(**context)

ContextMixin

25
26
27
28
def get_context_data(self, **kwargs):
    if 'view' not in kwargs:
        kwargs['view'] = self
    return kwargs

def get_context_object_name(self, obj): SingleObjectMixin

Get the name to use for the object.
85
86
87
88
89
90
91
92
93
94
def get_context_object_name(self, obj):
    """
    Get the name to use for the object.
    """
    if self.context_object_name:
        return self.context_object_name
    elif isinstance(obj, models.Model):
        return obj._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.
270
271
272
273
274
275
276
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_day(self): DayMixin

Return the day for which this view should display data.
151
152
153
154
155
156
157
158
159
160
161
162
163
164
def get_day(self):
    """
    Return the day for which this view should display data.
    """
    day = self.day
    if day is None:
        try:
            day = self.kwargs['day']
        except KeyError:
            try:
                day = self.request.GET['day']
            except KeyError:
                raise Http404(_("No day specified"))
    return day

def get_day_format(self): DayMixin

Get a day format string in strptime syntax to be used to parse the day
from url variables.
144
145
146
147
148
149
def get_day_format(self):
    """
    Get a day format string in strptime syntax to be used to parse the day
    from url variables.
    """
    return self.day_format

def get_month(self): MonthMixin

Return the month for which this view should display data.
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
def get_month(self):
    """
    Return the month for which this view should display data.
    """
    month = self.month
    if month is None:
        try:
            month = self.kwargs['month']
        except KeyError:
            try:
                month = self.request.GET['month']
            except KeyError:
                raise Http404(_("No month specified"))
    return month

def get_month_format(self): MonthMixin

Get a month format string in strptime syntax to be used to parse the
month from url variables.
85
86
87
88
89
90
def get_month_format(self):
    """
    Get a month format string in strptime syntax to be used to parse the
    month from url variables.
    """
    return self.month_format

def get_next_day(self, date): DayMixin

Get the next valid day.
166
167
168
169
170
def get_next_day(self, date):
    """
    Get the next valid day.
    """
    return _get_next_prev(self, date, is_previous=False, period='day')

def get_next_month(self, date): MonthMixin

Get the next valid month.
107
108
109
110
111
def get_next_month(self, date):
    """
    Get the next valid month.
    """
    return _get_next_prev(self, date, is_previous=False, period='month')

def get_next_year(self, date): YearMixin

Get the next valid year.
51
52
53
54
55
def get_next_year(self, date):
    """
    Get the next valid year.
    """
    return _get_next_prev(self, date, is_previous=False, period='year')

def get_object(self, queryset=None):

BaseDateDetailView

Get the object this request displays.
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
def get_object(self, queryset=None):
    """
    Get the object this request displays.
    """
    year = self.get_year()
    month = self.get_month()
    day = self.get_day()
    date = _date_from_string(year, self.get_year_format(),
                             month, self.get_month_format(),
                             day, self.get_day_format())
    # Use a custom queryset if provided
    qs = self.get_queryset() if queryset is None else queryset
    if not self.get_allow_future() and date > datetime.date.today():
        raise Http404(_(
            "Future %(verbose_name_plural)s not available because "
            "%(class_name)s.allow_future is False.") % {
            'verbose_name_plural': qs.model._meta.verbose_name_plural,
            'class_name': self.__class__.__name__,
            },
        )
    # Filter down a queryset from self.queryset using the date from the
    # URL. This'll get passed as the queryset to DetailView.get_object,
    # which'll handle the 404
    lookup_kwargs = self._make_single_date_lookup(date)
    qs = qs.filter(**lookup_kwargs)
    return super(BaseDetailView, self).get_object(queryset=qs)

SingleObjectMixin

Returns the object the view is displaying.

By default this requires `self.queryset` and a `pk` or `slug` argument
in the URLconf, but subclasses can override this to return any object.
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
def get_object(self, queryset=None):
    """
    Returns the object the view is displaying.
    By default this requires `self.queryset` and a `pk` or `slug` argument
    in the URLconf, but subclasses can override this to return any object.
    """
    # Use a custom queryset if provided; this is required for subclasses
    # like DateDetailView
    if queryset is None:
        queryset = self.get_queryset()
    # Next, try looking up by primary key.
    pk = self.kwargs.get(self.pk_url_kwarg, None)
    slug = self.kwargs.get(self.slug_url_kwarg, None)
    if pk is not None:
        queryset = queryset.filter(pk=pk)
    # Next, try looking up by slug.
    if slug is not None and (pk is None or self.query_pk_and_slug):
        slug_field = self.get_slug_field()
        queryset = queryset.filter(**{slug_field: slug})
    # If none of those are defined, it's an error.
    if pk is None and slug is None:
        raise AttributeError("Generic detail view %s must be called with "
                             "either an object pk or a slug."
                             % self.__class__.__name__)
    try:
        # Get the single item from the filtered queryset
        obj = queryset.get()
    except queryset.model.DoesNotExist:
        raise Http404(_("No %(verbose_name)s found matching the query") %
                      {'verbose_name': queryset.model._meta.verbose_name})
    return obj

def get_previous_day(self, date): DayMixin

Get the previous valid day.
172
173
174
175
176
def get_previous_day(self, date):
    """
    Get the previous valid day.
    """
    return _get_next_prev(self, date, is_previous=True, period='day')

def get_previous_month(self, date): MonthMixin

Get the previous valid month.
113
114
115
116
117
def get_previous_month(self, date):
    """
    Get the previous valid month.
    """
    return _get_next_prev(self, date, is_previous=True, period='month')

def get_previous_year(self, date): YearMixin

Get the previous valid year.
57
58
59
60
61
def get_previous_year(self, date):
    """
    Get the previous valid year.
    """
    return _get_next_prev(self, date, is_previous=True, period='year')

def get_queryset(self): SingleObjectMixin

Return the `QuerySet` that will be used to look up the object.

Note that this method is called by the default implementation of
`get_object` and may not be called if `get_object` is overridden.
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
def get_queryset(self):
    """
    Return the `QuerySet` that will be used to look up the object.
    Note that this method is called by the default implementation of
    `get_object` and may not be called if `get_object` is overridden.
    """
    if self.queryset is None:
        if self.model:
            return 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 self.queryset.all()

def get_slug_field(self): SingleObjectMixin

Get the name of a slug field to be used to look up by slug.
79
80
81
82
83
def get_slug_field(self):
    """
    Get the name of a slug field to be used to look up by slug.
    """
    return self.slug_field

def get_year(self): YearMixin

Return the year for which this view should display data.
36
37
38
39
40
41
42
43
44
45
46
47
48
49
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(_("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.
29
30
31
32
33
34
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

91
92
93
94
95
96
97
98
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.
100
101
102
103
104
105
106
107
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