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
extra_context = None ContextMixin
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 0x7f2e9bb9b240> DateMixin
year = None YearMixin
year_format = '%Y' YearMixin
Expand Collapse

Methods

def _allowed_methods(self): View

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

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)
    view.view_class = cls
    view.view_initkwargs = initkwargs
    # 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

104
105
106
107
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

Return `True` if the view should be allowed to display objects from
the future.
240
241
242
243
244
245
def get_allow_future(self):
    """
    Return `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.
90
91
92
93
94
95
96
97
98
99
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().get_context_data(**context)

ContextMixin

23
24
25
26
27
28
def get_context_data(self, **kwargs):
    if 'view' not in kwargs:
        kwargs['view'] = self
    if self.extra_context is not None:
        kwargs.update(self.extra_context)
    return kwargs

def get_context_object_name(self, obj): SingleObjectMixin

Get the name to use for the object.
81
82
83
84
85
86
87
88
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_current_day(self, date): DayMixin

Return the start date of the current interval.
161
162
163
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.
115
116
117
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.
63
64
65
def _get_current_year(self, date):
    """Return the start date of the current interval."""
    return date.replace(month=1, day=1)

def get_date_field(self): DateMixin

Get the name of the date field to be used to filter by.
234
235
236
237
238
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.
132
133
134
135
136
137
138
139
140
141
142
143
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.
125
126
127
128
129
130
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.
80
81
82
83
84
85
86
87
88
89
90
91
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.
73
74
75
76
77
78
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

Return the start date of the next interval.

The interval is defined by start date <= item date < next start date.
153
154
155
156
157
158
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_day(self, date): DayMixin

Get the next valid day.
145
146
147
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

Return the start date of the next interval.

The interval is defined by start date <= item date < next start date.
101
102
103
104
105
106
107
108
109
110
111
112
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:
        try:
            return date.replace(year=date.year + 1, month=1, day=1)
        except ValueError:
            raise Http404(_("Date out of range"))
    else:
        return date.replace(month=date.month + 1, day=1)

def get_next_month(self, date): MonthMixin

Get the next valid month.
93
94
95
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

Return the start date of the next interval.

The interval is defined by start date <= item date < next start date.
52
53
54
55
56
57
58
59
60
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.
    """
    try:
        return date.replace(year=date.year + 1, month=1, day=1)
    except ValueError:
        raise Http404(_("Date out of range"))

def get_next_year(self, date): YearMixin

Get the next valid year.
44
45
46
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.
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
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().get_object(queryset=qs)

SingleObjectMixin

Return the object the view is displaying.

Require `self.queryset` and a `pk` or `slug` argument in the URLconf.
Subclasses can override this to return any object.
20
21
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
def get_object(self, queryset=None):
    """
    Return the object the view is displaying.
    Require `self.queryset` and a `pk` or `slug` argument in the URLconf.
    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)
    slug = self.kwargs.get(self.slug_url_kwarg)
    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.
149
150
151
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.
97
98
99
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.
48
49
50
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.

This method is called by the default implementation of get_object() and
may not be called if get_object() is overridden.
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
def get_queryset(self):
    """
    Return the `QuerySet` that will be used to look up the object.
    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.
77
78
79
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.
31
32
33
34
35
36
37
38
39
40
41
42
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.
24
25
26
27
28
29
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
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 HttpResponseNotAllowed(self._allowed_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 kwargs.items():
        setattr(self, key, value)

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.
260
261
262
263
264
265
266
267
268
269
270
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.
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
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 options(self, request, *args, **kwargs): View

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