class DetailView

from django.views.generic import DetailView
Render a "detail" view of an object.

By default this is a model instance looked up from `self.queryset`, but the
view will support display of *any* object by overriding `self.get_object()`.

Attributes

  Defined in
context_object_name = None SingleObjectMixin
http_method_names = ['get', 'post', 'put', 'delete', 'head', 'options', 'trace'] View
model = None SingleObjectMixin
queryset = None SingleObjectMixin
response_class = <class 'django.template.response.TemplateResponse'> TemplateResponseMixin
slug_field = 'slug' SingleObjectMixin
template_name = None TemplateResponseMixin
template_name_field = None SingleObjectTemplateResponseMixin
template_name_suffix = '_detail' SingleObjectTemplateResponseMixin
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, **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_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_object(self, queryset=None): 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_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_template_names(self):

SingleObjectTemplateResponseMixin

Return a list of template names to be used for the request. Must return
a list. May not be called if get_template is overridden.
107
108
109
110
111
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
138
139
def get_template_names(self):
    """
    Return a list of template names to be used for the request. Must return
    a list. May not be called if get_template is overridden.
    """
    try:
        names = super(SingleObjectTemplateResponseMixin, self).get_template_names()
    except ImproperlyConfigured:
        # If template_name isn't specified, it's not a problem --
        # we just start with an empty list.
        names = []
    # If self.template_name_field is set, grab the value of the field
    # of that name from the object; this is the most specific template
    # name, if given.
    if self.object and self.template_name_field:
        name = getattr(self.object, self.template_name_field, None)
        if name:
            names.insert(0, name)
    # The least-specific option is the default <app>/<model>_detail.html;
    # only use this if the object in question is a model.
    if hasattr(self.object, '_meta'):
        names.append("%s/%s%s.html" % (
            self.object._meta.app_label,
            self.object._meta.object_name.lower(),
            self.template_name_suffix
        ))
    elif hasattr(self, 'model') and hasattr(self.model, '_meta'):
        names.append("%s/%s%s.html" % (
            self.model._meta.app_label,
            self.model._meta.object_name.lower(),
            self.template_name_suffix
        ))
    return names

TemplateResponseMixin

Returns a list of template names to be used for the request. Must return
a list. May not be called if render_to_response is overridden.
 99
100
101
102
103
104
105
106
107
108
109
def get_template_names(self):
    """
    Returns a list of template names to be used for the request. Must return
    a list. May not be called if render_to_response is overridden.
    """
    if self.template_name is None:
        raise ImproperlyConfigured(
            "TemplateResponseMixin requires either a definition of "
            "'template_name' or an implementation of 'get_template_names()'")
    else:
        return [self.template_name]

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 render_to_response(self, context, **response_kwargs): TemplateResponseMixin

Returns a response with a template rendered with the given context.
88
89
90
91
92
93
94
95
96
97
def render_to_response(self, context, **response_kwargs):
    """
    Returns a response with a template rendered with the given context.
    """
    return self.response_class(
        request = self.request,
        template = self.get_template_names(),
        context = context,
        **response_kwargs
    )