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', 'delete', 'head', 'options', 'trace'] View
model = None SingleObjectMixin
month = None MonthMixin
month_format = '%b' MonthMixin
queryset = None SingleObjectMixin
slug_field = 'slug' SingleObjectMixin
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.
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, **kwargs): BaseDetailView

 97
 98
 99
100
def get(self, request, **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.
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): SingleObjectMixin

88
89
90
91
92
93
def get_context_data(self, **kwargs):
    context = kwargs
    context_object_name = self.get_context_object_name(self.object)
    if context_object_name:
        context[context_object_name] = self.object
    return context

def get_context_object_name(self, obj): SingleObjectMixin

Get the name to use for the object.
77
78
79
80
81
82
83
84
85
86
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 hasattr(obj, '_meta'):
        return smart_str(obj._meta.object_name.lower())
    else:
        return None

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

Return the day for which this view should display data
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
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(_(u"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.
82
83
84
85
86
87
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
48
49
50
51
52
53
54
55
56
57
58
59
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(_(u"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.
41
42
43
44
45
46
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.
102
103
104
105
106
107
def get_next_day(self, date):
    """
    Get the next valid day.
    """
    next = date + datetime.timedelta(days=1)
    return _get_next_prev_month(self, next, is_previous=False, use_first_day=False)

def get_next_month(self, date): MonthMixin

Get the next valid month.
61
62
63
64
65
66
67
def get_next_month(self, date):
    """
    Get the next valid month.
    """
    first_day, last_day = _month_bounds(date)
    next = (last_day + datetime.timedelta(days=1)).replace(day=1)
    return _get_next_prev_month(self, next, is_previous=False, use_first_day=True)

def get_object(self, queryset=None):

BaseDateDetailView

Get the object this request displays.
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
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())
    qs = self.get_queryset()
    if not self.get_allow_future() and date > datetime.date.today():
        raise Http404(_(u"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
    date_field = self.get_date_field()
    field = qs.model._meta.get_field(date_field)
    lookup = _date_lookup_for_field(field, date)
    qs = qs.filter(**lookup)
    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.
19
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
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('pk', None)
    slug = self.kwargs.get('slug', None)
    if pk is not None:
        queryset = queryset.filter(pk=pk)
    # Next, try looking up by slug.
    elif slug is not None:
        slug_field = self.get_slug_field()
        queryset = queryset.filter(**{slug_field: slug})
    # If none of those are defined, it's an error.
    else:
        raise AttributeError(u"Generic detail view %s must be called with "
                             u"either an object pk or a slug."
                             % self.__class__.__name__)
    try:
        obj = queryset.get()
    except ObjectDoesNotExist:
        raise Http404(_(u"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.
109
110
111
112
113
114
def get_previous_day(self, date):
    """
    Get the previous valid day.
    """
    prev = date - datetime.timedelta(days=1)
    return _get_next_prev_month(self, prev, is_previous=True, use_first_day=False)

def get_previous_month(self, date): MonthMixin

Get the previous valid month.
69
70
71
72
73
74
75
def get_previous_month(self, date):
    """
    Get the previous valid month.
    """
    first_day, last_day = _month_bounds(date)
    prev = (first_day - datetime.timedelta(days=1))
    return _get_next_prev_month(self, prev, is_previous=True, use_first_day=True)

def get_queryset(self): SingleObjectMixin

Get the queryset to look an object up against. May not be called if
`get_object` is overridden.
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
def get_queryset(self):
    """
    Get the queryset to look an object up against. 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(u"%(cls)s is missing a queryset. Define "
                                       u"%(cls)s.model, %(cls)s.queryset, or override "
                                       u"%(cls)s.get_object()." % {
                                            'cls': self.__class__.__name__
                                    })
    return self.queryset._clone()

def get_slug_field(self): SingleObjectMixin

Get the name of a slug field to be used to look up by slug.
71
72
73
74
75
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
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)