Other Mixins ============ These mixins handle other random bits of Django's views, like controlling output, controlling content types, or setting values in the context. .. contents:: SetHeadlineMixin ---------------- The ``SetHeadlineMixin`` is a newer edition to our client's CMS. It allows us to *statically* or *programmatically* set the headline of any of our views. We like to write as few templates as possible, so a mixin like this helps us reuse generic templates. Its usage is amazingly straightforward and works much like Django's built-in ``get_queryset`` method. This mixin has two ways of being used. Static Example ^^^^^^^^^^^^^^ :: from braces.views import SetHeadlineMixin class HeadlineView(SetHeadlineMixin, TemplateView): headline = "This is our headline" template_name = "path/to/template.html" Dynamic Example ^^^^^^^^^^^^^^^ :: from datetime import date from braces.views import SetHeadlineMixin class HeadlineView(SetHeadlineMixin, TemplateView): template_name = "path/to/template.html" def get_headline(self): return u"This is our headline for %s" % date.today().isoformat() In both usages, in the template, just print out ``{{ headline }}`` to show the generated headline. SelectRelatedMixin ------------------ A simple mixin which allows you to specify a list or tuple of foreign key fields to perform a `select_related`_ on. See Django's docs for more information on `select_related`_. :: # views.py from django.views.generic import DetailView from braces.views import SelectRelatedMixin from profiles.models import Profile class UserProfileView(SelectRelatedMixin, DetailView): model = Profile select_related = ["user"] template_name = "profiles/detail.html" PrefetchRelatedMixin ------------------ A simple mixin which allows you to specify a list or tuple of reverse foreign key or ManyToMany fields to perform a `prefetch_related`_ on. See Django's docs for more information on `prefetch_related`_. :: # views.py from django.contrib.auth.models import User from django.views.generic import DetailView from braces.views import PrefetchRelatedMixin class UserView(PrefetchRelatedMixin, DetailView): model = User prefetch_related = ["post_set"] # where the Post model has an FK to the User model as an author. template_name = "users/detail.html" JSONResponseMixin ----------------- .. versionchanged:: 1.1 ``render_json_response`` now accepts a ``status_code`` keyword argument. ``json_dumps_kwargs`` class-attribute and ``get_json_dumps_kwargs`` method to provide arguments to the ``json.dumps()`` method. A simple mixin to handle very simple serialization as a response to the browser. :: # views.py from django.views.generic import DetailView from braces.views import JSONResponseMixin class UserProfileAJAXView(JSONResponseMixin, DetailView): model = Profile json_dumps_kwargs = {'indent': 2} def get(self, request, *args, **kwargs): self.object = self.get_object() context_dict = { 'name': self.object.user.name, 'location': self.object.location } return self.render_json_response(context_dict) You can additionally use the `AjaxResponseMixin` :: # views.py from braces.views import AjaxResponseMixin class UserProfileView(JSONResponseMixin, AjaxResponseMixin, DetailView): model = Profile def get_ajax(self, request, *args, **kwargs): return self.render_json_object_response(self.get_object()) The `JSONResponseMixin` provides a class-level variable to control the response type as well. By default it is `application/json`, but you can override that by providing the `content_type` variable a different value or, programmatically, by overriding the `get_content_type()` method. :: from braces.views import JSONResponseMixin class UserProfileAJAXView(JSONResponseMixin, DetailView): content_type = 'application/javascript' model = Profile def get(self, request, *args, **kwargs): self.object = self.get_object() context_dict = { 'name': self.object.user.name, 'location': self.object.location } return self.render_json_response(context_dict) def get_content_type(self): # Shown just for illustrative purposes return 'application/javascript' AjaxResponseMixin ----------------- A mixin to allow you to provide alternative methods for handling AJAX requests. To control AJAX-specific behavior, override `get_ajax`, `post_ajax`, `put_ajax`, or `delete_ajax`. All four methods take `request`, `*args`, and `**kwargs` like the standard view methods. :: # views.py from django.views.generic import View from braces.views import AjaxResponseMixin, JSONResponseMixin class SomeView(JSONResponseMixin, AjaxResponseMixin, View): def get_ajax(self, request, *args, **kwargs): json_dict = { 'name': "Benny's Burritos", 'location': "New York, NY" } return self.render_json_response(json_dict) OrderableListMixin ------------------ .. versionadded:: 1.1 A mixin to allow easy ordering of your queryset basing on the GET parameters. Works with `ListView`. To use it, define columns that the data can be order by as well as the default column to order by in your view. This can be done either by simply setting the class attributes... :: # views.py class OrderableListView(OrderableListMixin, ListView): model = Article orderable_columns = ('id', 'title',) orderable_columns_default = 'id' ...or by using similarly name methods to set the ordering constraints more dynamically: :: # views.py class OrderableListView(OrderableListMixin, ListView): model = Article def get_orderable_columns(self): # return an iterable return ('id', 'title', ) def get_orderable_columns_default(self): # return a string return 'id' The `orderable_columns` restriction is here in order to stop your users from launching inefficient queries, like ordering by binary columns. `OrderableListMixin` will order your queryset basing on following GET params: * `order_by`: column name, e.g. `'title'` * `ordering`: `'asc'` (default) or `'desc'` Example url: http://127.0.0.1:8000/articles/?order_by=title&ordering=asc .. _select_related: https://docs.djangoproject.com/en/1.5/ref/models/querysets/#select-related .. _prefetch_related: https://docs.djangoproject.com/en/1.5/ref/models/querysets/#prefetch-related