Tag CBV

From Classy Class Based Views 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().

There are 7 attributes for the DetailView that are derived from the SingleObjectMixin. I’ll talk about five of them and the go over the ‘slug’ fields in their own section.

• context_object_name: similar to the ListView it allows you to give a more memorable name to the object in the template. You’ll want to use this if you want to have future developers (i.e. you) not hate you
• model: similar to the ListView except it only returns a single record instead of all records for the model based on a filter parameter passed via the slug
• pk_url_kwarg: you can set this to be something other than pk if you want … though I’m not sure why you’d want to
• query_pk_and_slug: The Django Docs have a pretty clear explanation of what it does

This attribute can help mitigate insecure direct object reference attacks. When applications allow access to individual objects by a sequential primary key, an attacker could brute-force guess all URLs; thereby obtaining a list of all objects in the application. If users with access to individual objects should be prevented from obtaining this list, setting querypkand*slug to True will help prevent the guessing of URLs as each URL will require two correct, non-sequential arguments. Simply using a unique slug may serve the same purpose, but this scheme allows you to have non-unique slugs. *

• queryset: used to return data to the view. It will supersede the value supplied for model if both are present

The Slug Fields

There are two attributes that I want to talk about separately from the others:

• slug_field
• slug_url_kwarg

If neither slug_field nor slug_url_kwarg are set the the url must contain <int:pk>. The url in the template needs to include o.id

views.py

There is nothing to show in the views.py file in this example

urls.py

path('detail_view/<int:pk>', views.myDetailView.as_view(), name='detail_view'),

\<ListView>.html

{% url 'rango:detail_view' o.id %}

If slug_field is set but slug_url_kwarg is NOT set then the url can be <slug>. The url in the template needs to include o.<slug_field>

views.py

class myDetailView(DetailView):
    slug_field = 'first_name'

urls.py

path('detail_view/<slug>/', views.myDetailView.as_view(), name='detail_view'),

\<ListView>.html

{% url 'rango:detail_view' o.first_name %}

If slug_field is not set but slug_url_kwarg is set then you get an error. Don’t do this one.

If both slug_field and slug_url_kwarg are set then the url must be <value> where value is what the parameters are set to. The url in the template needs to include o.<slug_field>

views.py

class myDetailView(DetailView):
    slug_field = 'first_name'
    slug_url_kwarg = 'first_name'

urls.py

path('detail_view/<first_name>/', views.myDetailView.as_view(), name='detail_view'),

\<ListView>.html

{% url 'rango:detail_view' o.first_name %}

Diagram

A visual representation of how DetailView is derived can be seen here:

Conclusion

I think the most important part of the DetailView is to remember its relationship to ListView. Changes you try to implement on the Class for DetailView need to be incorporated into the template associated with the ListView you have.

Posted by ryan on Sun 24 November 2019

From Classy Class Based Views BaseListView

A base view for displaying a list of objects.

And from the Django Docs:

A base view for displaying a list of objects. It is not intended to be used directly, but rather as a parent class of the django.views.generic.list.ListView or other views representing lists of objects.

Almost all of the functionality of BaseListView comes from the MultipleObjectMixin. Since the Django Docs specifically say don’t use this directly, I won’t go into it too much.

Diagram

A visual representation of how BaseListView is derived can be seen here:

Conclusion

Don’t use this. It should be subclassed into a usable view (a la ListView).

There are many Base views that are ancestors for other views. I’m not going to cover any more of them going forward UNLESS the documentation says there’s a specific reason to.

Posted by ryan on Sun 17 November 2019

From Classy Class Based Views ListView:

Render some list of objects, set by self.model or self.queryset.

self.queryset can actually be any iterable of items, not just a queryset.

There are 16 attributes for the ListView but only 2 types are required to make the page return something other than a 500 error:

• Data
• Template Name

Data Attributes

You have a choice of either using Model or queryset to specify what data to return. Without it you get an error.

The Model attribute gives you less control but is easier to implement. If you want to see ALL of the records of your model, just set

model = ModelName

However, if you want to have a bit more control over what is going to be displayed you’ll want to use queryset which will allow you to add methods to the specified model, ie filter, order_by.

queryset = ModelName.objects.filter(field_name='filter')

If you specify both model and queryset then queryset takes precedence.

Template Name Attributes

You have a choice of using template_name or template_name_suffix. The template_name allows you to directly control what template will be used. For example, if you have a template called list_view.html you can specify it directly in template_name.

template_name_suffix will calculate what the template name should be by using the app name, model name, and appending the value set to the template_name_suffix.

In pseudo code:

templates/<app_name>/<model_name>_<template_name_suffix>.html

For an app named rango and a model named person setting template_name_suffix to _test would resolve to

templates/rango/person_test.html

Other Attributes

If you want to return something interesting you’ll also need to specify

• allow_empty: The default for this is true which allows the page to render if there are no records. If you set this to false then returning no records will result in a 404 error
• context_object_name: allows you to give a more memorable name to the object in the template. You’ll want to use this if you want to have future developers (i.e. you) not hate you
• ordering: allows you to specify the order that the data will be returned in. The field specified must exist in the model or queryset that you’ve used
• page_kwarg: this indicates the name to use when going from page x to y; defaults to name but overriding it to something more sensible can be helpful for SEO. For example you can use name instead of page if you’ve got a page that has a bunch of names

• paginate_by: determines the maximum number of records to return on any page.
• paginate_orphans: number of items to add to the last page; this helps keep pages with singletons (or some other small number
• paginator_class: class that defines several of the attributes above. Don’t mess with this unless you have an actual reason to do so. Also … you’re not a special snowflake, there are literal dragons in down this road. Go back!

Diagram

A visual representation of how ListView is derived can be seen here:

Conclusion

The ListView CBV is a powerful and highly customizable tool that allows you to display the data from a single model quite easily.

Posted by ryan on Sun 17 November 2019

From Classy Class Based View the RedirectView will

Provide a redirect on any GET request.

It is an extension of View and has 5 attributes:

• http_method_names (from View)
• pattern_name: The name of the URL pattern to redirect to. ¹ This will be used if no url is used.
• permanent: a flag to determine if the redirect is permanent or not. If set to True, then the HTTP Status Code 301 is returned. If set to False the 302 is returned
• query_string: If True then it will pass along the query string from the RedirectView. If it’s False it won’t. If this is set to True and neither pattern\_name nor url are set then nothing will be passed to the RedirectView
• url: Where the Redirect should point. It will take precedence over the patter_name so you should only url or pattern\_name but not both. This will need to be an absolute url, not a relative one, otherwise you may get a 404 error

The example below will give a 301 status code:

class myRedirectView(RedirectView):
    pattern_name = 'rango:template_view'
    permanent = True
    query_string = True

While this would be a 302 status code:

class myRedirectView(RedirectView):
    pattern_name = 'rango:template_view'
    permanent = False
    query_string = True

Methods

The method get\_redirect\_url allows you to perform actions when the redirect is called. From the Django Docs the example given is increasing a counter on an Article Read value.

Diagram

A visual representation of how RedirectView derives from View ²

Conclusion

In general, given the power of the url mapping in Django I’m not sure why you would need to use a the Redirect View. From Real Python they concur, stating:

As you can see, the class-based approach does not provide any obvious benefit while adding some hidden complexity. That raises the question: when should you use RedirectView?

If you want to add a redirect directly in your urls.py, using RedirectView makes sense. But if you find yourself overwriting getredirecturl, a function-based view might be easier to understand and more flexible for future enhancements.

1. From the [Django Docs](https://docs.djangoproject.com/en/2.2/ref/class-based-views/base/ ↩︎
2. Original Source from Classy Class Based Views ↩︎

Posted by ryan on Sun 10 November 2019

From Classy Class Based Views the TemplateView will

Render a template. Pass keyword arguments from the URLconf to the context.

It is an extended version of the View CBV with the the ContextMixin and the TemplateResponseMixin added to it.

It has several attributes that can be set

• content_type: will allow you to define the MIME type that the page will return. The default is DEFAULT\_CONTENT\_TYPE but can be overridden with this attribute.
• extra_context: this can be used as a keyword argument in the as\_view() but not in the class of the CBV. Adding it there will do nothing
• http_method_name: derived from View and has the same definition
• response_classes: The response class to be returned by render_to_response method it defaults to a TemplateResponse. See below for further discussion
• template_engine: can be used to specify which template engine to use IF you have configured the use of multiple template engines in your settings.py file. See the Usage section of the Django Documentation on Templates
• template_name: this attribute is required IF the method get\_template\_names() is not used.

More on response_class

This confuses the ever living crap out of me. The best (only) explanation I have found is by GitHub user spapas in his article Django non-HTML responses:

From the previous discussion we can conclude that if your non-HTML response needs a template then you just need to create a subclass of TemplateResponse and assign it to the responseclass attribute (and also change the contenttype attribute). On the other hand, if your non-HTML respond does not need a template to be rendered then you have to override rendertoresponse completely (since the template parameter does not need to be passed now) and either define a subclass of HttpResponse or do the rendering in the rendertoresponse.

Basically, if you ever want to use a non-HTML template you’d set this attribute, but it seems available mostly as a ‘just-in-case’ and not something that’s used every day.

My advise … just leave it as is.

When to use the get method

An answer which makes sense to me that I found on StackOverflow was (slightly modified to make it more understandable)

if you need to have data available every time, use get_context_data(). If you need the data only for a specific request method (eg. in get), then put it in get.

When to use the get_template_name method

This method allows you to easily change a template being used based on values passed through GET.

This can be helpful if you want to have one template for a super user and another template for a basic user. This helps to keep business logic out of the template and in the view where it belongs.

This can also be useful if you want to specify several possible templates to use. A list is passed and Django will work through that list from the first element to the last until it finds a template that exists and render it.

If you don’t specify template_name you have to use this method.

When to use the get_context_data method

See above in the section When to use the get method

Diagram

A visual representation of how TemplateView derives from View ¹

Conclusion

If you want to roll your own CBV because you have a super specific use case, starting at the TemplateView is going to be a good place to start. However, you may find that there is already a view that is going to do what you need it to. Writing your own custom implementation of TemplateView may be a waste of time IF you haven’t already verified that what you need isn’t already there.

1. Original Source from Classy Class Based Views ↩︎

Posted by ryan on Sun 03 November 2019

View is the ancestor of ALL Django CBV. From the great site Classy Class Based Views, they are described as

Intentionally simple parent class for all views. Only implements dispatch-by-method and simple sanity checking.

This is no joke. The View class has almost nothing to it, but it’s a solid foundation for everything else that will be done.

Its implementation has just one attribute http_method_names which is a list that allows you to specify what http verbs are allowed.

Other than that, there’s really not much to it. You just write a simple method, something like this:

def get(self, _):
    return HttpResponse('My Content')

All that gets returned to the page is a simple HTML. You can specify the content_type if you just want to return JSON or plain text but defining the content_type like this:

def get(self, _):
    return HttpResponse('My Content', content_type='text plain')

You can also make the text that is displayed be based on a variable defined in the class.

First, you need to define the variable

content = 'This is a {View} template and is not used for much of anything but '
             'allowing extensions of it for other Views'

And then you can do something like this:

def get(self, _):
    return HttpResponse(self.content, content_type='text/plain')

Also, as mentioned above you can specify the allowable methods via the attribute http_method_names.

The following HTTP methods are allowed:

• get
• post
• put
• patch
• delete
• head
• options
• trace

By default all are allowed.

If we put all of the pieces together we can see that a really simple View CBV would look something like this:

class myView(View):
    content = 'This is a {View} template and is not used for much of anything but '
             'allowing extensions of it for other Views'
    http_method_names = ['get']

    def get(self, _):
        return HttpResponse(self.content, content_type='text/plain')

This View will return content to the page rendered as plain text. This CBV is also limited to only allowing get requests.

Here’s what it looks like in the browser:

Conclusion

View doesn’t do much, but it’s the case for everything else, so understanding it is going to be important.

Posted by ryan on Sun 27 October 2019

As I’ve written about previously I’m working on a Django app. It’s in a pretty good spot (you should totally check it out over at StadiaTracker.com) and I thought now would be a good time to learn a bit more about some of the ways that I’m rendering the pages.

I’m using Class Based Views (CBV) and I realized that I really didn’t grok how they worked. I wanted to change that.

I’ll be working on a series where I deep dive into the CBV and work them from several angles and try to get them to do all of the things that they are capable of.

The first place I’d suggest anyone start to get a good idea of CBV, and the idea of Mixins would be SpaPas’ GitHub Page where he does a really good job of covering many pieces of the CBV. It’s a great resource!

This is just the intro to this series and my hope is that I’ll publish one of these pieces each week for the next several months as I work my way through all of the various CBV that are available.

Posted by ryan on Sun 27 October 2019