| ============= |
| Simple mixins |
| ============= |
|
|
| ``ContextMixin`` |
| ================ |
|
|
| .. class:: django.views.generic.base.ContextMixin |
|
|
| **Attributes** |
|
|
| .. attribute:: extra_context |
|
|
| A dictionary to include in the context. This is a convenient way of |
| specifying some context in |
| :meth:`~django.views.generic.base.View.as_view`. Example usage:: |
|
|
| from django.views.generic import TemplateView |
|
|
| TemplateView.as_view(extra_context={"title": "Custom Title"}) |
|
|
| **Methods** |
|
|
| .. method:: get_context_data(**kwargs) |
|
|
| Returns a dictionary representing the template context. The keyword |
| arguments provided will make up the returned context. Example usage:: |
|
|
| def get_context_data(self, **kwargs): |
| context = super().get_context_data(**kwargs) |
| context["number"] = random.randrange(1, 100) |
| return context |
|
|
| The template context of all class-based generic views include a |
| ``view`` variable that points to the ``View`` instance. |
|
|
| .. admonition:: Use ``alters_data`` where appropriate |
|
|
| Note that having the view instance in the template context may |
| expose potentially hazardous methods to template authors. To |
| prevent methods like this from being called in the template, set |
| ``alters_data=True`` on those methods. For more information, read |
| the documentation on :ref:`rendering a template context |
| <alters-data-description>`. |
|
|
| ``TemplateResponseMixin`` |
| ========================= |
|
|
| .. class:: django.views.generic.base.TemplateResponseMixin |
|
|
| Provides a mechanism to construct a |
| :class:`~django.template.response.TemplateResponse`, given |
| suitable context. The template to use is configurable and can be |
| further customized by subclasses. |
|
|
| **Attributes** |
|
|
| .. attribute:: template_name |
|
|
| The full name of a template to use as defined by a string. Not defining |
| a ``template_name`` will raise a |
| :class:`django.core.exceptions.ImproperlyConfigured` exception. |
|
|
| .. attribute:: template_engine |
|
|
| The :setting:`NAME <TEMPLATES-NAME>` of a template engine to use for |
| loading the template. ``template_engine`` is passed as the ``using`` |
| keyword argument to ``response_class``. Default is ``None``, which |
| tells Django to search for the template in all configured engines. |
|
|
| .. attribute:: response_class |
|
|
| The response class to be returned by ``render_to_response`` method. |
| Default is :class:`TemplateResponse |
| <django.template.response.TemplateResponse>`. The template and context |
| of ``TemplateResponse`` instances can be altered later (e.g. in |
| :ref:`template response middleware <template-response-middleware>`). |
|
|
| If you need custom template loading or custom context object |
| instantiation, create a ``TemplateResponse`` subclass and assign it to |
| ``response_class``. |
|
|
| .. attribute:: content_type |
|
|
| The content type to use for the response. ``content_type`` is passed |
| as a keyword argument to ``response_class``. Default is ``None`` -- |
| meaning that Django uses ``'text/html'``. |
|
|
| **Methods** |
|
|
| .. method:: render_to_response(context, **response_kwargs) |
|
|
| Returns a ``self.response_class`` instance. |
|
|
| If any keyword arguments are provided, they will be passed to the |
| constructor of the response class. |
|
|
| Calls :meth:`get_template_names()` to obtain the list of template names |
| that will be searched looking for an existent template. |
|
|
| .. method:: get_template_names() |
|
|
| Returns a list of template names to search for when rendering the |
| template. The first template that is found will be used. |
|
|
| The default implementation will return a list containing |
| :attr:`template_name` (if it is specified). |
|
|
