In the preceding chapter, we learned the main components of Django by developing a simple blog application. We created a simple blog application using views, templates, and URLs. In this chapter, we will extend the functionalities of the blog application with features that can be found in many blogging platforms nowadays. In this chapter, you will learn the following topics:

• Using canonical URLs for models
• Creating SEO-friendly URLs for posts
• Adding pagination to the post list view
• Building class-based views
• Sending emails with Django
• Using Django forms to share posts via email
• Adding comments to posts using forms from models

The source code for this chapter can be found athttps://github.com/PacktPublishing/Django-4-by-example/tree/main/Chapter02.

All Python packages used in this chapter are included in therequirements.txt file in the source code for the chapter. You can follow...

A website mighthave different pages that display the samecontent. In our application, the initial part of the content for each post is displayed both on the post list page and the post detail page. A canonical URL is the preferred URL for a resource. You can think of it as the URL of the most representative page for specific content. There might be different pages on your site that display posts, but there is a single URL that you use as the main URL for a post. Canonical URLs allow you to specify the URL for the master copy of a page. Django allows you to implement theget_absolute_url() method in your models to return the canonical URL for the object.

We will use thepost_detail URL defined in the URL patterns of the application to build thecanonical URL forPost objects. Django provides differentURL resolver functions that allow you to build URLs dynamically using their name and any required parameters. We will use thereverse() utility function...

The canonical URL for a blog post detail view currently looks like/blog/1/. We will change the URLpattern to create SEO-friendly URLs forposts. We will be using both thepublish date andslug values to build the URLs for single posts. By combining dates, we will make a post detail URL to look like/blog/2022/1/1/who-was-django-reinhardt/. We will provide search engines with friendly URLs to index, containing both the title and date of the post.

To retrieve single posts with the combination of publication date and slug, we need to ensure that no post can be stored in the database with the sameslug andpublish date as an existing post. We will prevent thePost model from storing duplicated posts by defining slugs to be unique for the publication date of the post.

Edit themodels.py file and add the followingunique_for_date parameter to theslug field of thePost model:

classPost(models.Model):# ...    slug = models.SlugField...

Let’s modify theURL patterns to use the publication date and slug for the post detail URL.

Edit theurls.py file of theblog application and replace the line:

path('<int:id>/', views.post_detail, name='post_detail'),

With the lines:

path('<int:year>/<int:month>/<int:day>/<slug:post>/',         views.post_detail,         name='post_detail'),

Theurls.py file should now look like this:

from django.urlsimport pathfrom .import viewsapp_name ='blog'urlpatterns = [# Post views    path('', views.post_list, name='post_list'),    path('<int:year>/<int:month>/<int:day>/<slug:post>/',         views.post_detail,         name='post_detail'),]

The URL pattern for thepost_detail view takes the following arguments:

• year: Requires an integer
• month: Requires...

Now we have tochange the parameters of thepost_detail view to match the new URL parameters and use them to retrieve the correspondingPost object.

Edit theviews.py file and edit thepost_detail view like this:

defpost_detail(request, year, month, day, post):    post = get_object_or_404(Post,                             status=Post.Status.PUBLISHED,slug=post,publish__year=year,publish__month=month,publish__day=day)return render(request,'blog/post/detail.html',                  {'post': post})

We have modified thepost_detail view to take theyear,month,day, andpost arguments and retrieve a published post with the given slug and publication date. By addingunique_for_date='publish' to theslug field of thePost model before, we ensured that there will be only one post with...

We also have to modifythe parameters of the canonical URL forblog posts to match the new URL parameters.

Edit themodels.py file of theblog application and edit theget_absolute_url() method as follows:

classPost(models.Model):# ...defget_absolute_url(self):return reverse('blog:post_detail',                       args=[self.publish.year,self.publish.month,self.publish.day,self.slug])

Start the development server by typing the following command in the shell prompt:

python manage.py runserver

Next, you canreturn to your browser and click on one of thepost titles to take a look at the detail view of the post. You should see something like this:

Figure 2.1: The page for the post’s detail view

Take a look at the URL—it should look like/blog/2022/1/1/who-was-django-reinhardt...

When you start adding content to your blog, you can easily store tens or hundreds of posts in yourdatabase. Instead of displaying all the posts on a single page, you may want to split the list of posts across several pages and include navigation links to the different pages. This functionality is called pagination, and you can find it in almost every web application that displays long lists of items.

For example, Google uses pagination to divide search results across multiple pages.Figure 2.2 shows Google’s pagination links for search result pages:

Figure 2.2: Google pagination links for search result pages

Django has a built-in pagination class that allows you to manage paginated data easily. You can define the number of objects you want to be returned per page and you can retrieve the posts that correspond to the page requested by the user.

Adding pagination to the post list view

Edit theviews.py fileof theblog application...

We have built theblog application using function-based views. Function-based views are simple and powerful, but Django also allows you to build views using classes.

Class-based views are an alternative way to implement views as Python objects instead of functions. Since a view is a function that takes a web request and returns a web response, you can also define your views as class methods. Django provides base view classes that youcan use to implement your own views. All of them inherit from theView class, which handles HTTP method dispatching and other common functionalities.

Why use class-based views

Class-based views offer someadvantages over function-basedviews that are useful for specific use cases. Class-based views allow you to:

• Organize code related to HTTP methods, such asGET,POST, orPUT, in separate methods, instead of using conditional branching
• Use multiple inheritance to create reusable view classes (also...

Now, we willlearn how to create forms and how tosend emails with Django. We will allow users to share blog posts with others by sending post recommendations via email.

Take a minute to think about how you could useviews,URLs, andtemplates to create this functionality using what you learned in the preceding chapter.

To allow users to share posts via email, we will need to:

• Create a form for users to fill in their name, their email address, the recipient email address, and optional comments
• Create a view in theviews.py file that handles the posted data and sends the email
• Add a URL pattern for the new view in theurls.py file of the blog application
• Create a template to display the form

Creating forms with Django

Let’s start by building the form to share posts. Django has a built-in forms framework that allowsyou to create forms easily. The forms framework makes it simple to define the...

We willcontinue extending our blog applicationwith a comment system that will allow users to comment on posts. To build the comment system, we will need the following:

• A comment model to store user comments on posts
• A form that allows users to submit comments and manages the data validation
• A view that processes the form and saves a new comment to the database
• A list of comments and a form to add a new comment that can be included in the post detail template

Creating a model for comments

Let’sstart by building amodel to store user comments on posts.

Open themodels.py file of yourblog application and add the following code:

classComment(models.Model):    post = models.ForeignKey(Post,                             on_delete=models.CASCADE,                             related_name='comments')    name = models.CharField(max_length=80)    email = models.EmailField()    body = models...

The following resources provide additional information related to the topics covered in this chapter:

• Source code for this chapter –https://github.com/PacktPublishing/Django-4-by-example/tree/main/Chapter02
• URLs utility functions –https://docs.djangoproject.com/en/4.1/ref/urlresolvers/
• URL path converters –https://docs.djangoproject.com/en/4.1/topics/http/urls/#path-converters
• Django paginator class –https://docs.djangoproject.com/en/4.1/ref/paginator/
• Introduction to class-based views –https://docs.djangoproject.com/en/4.1/topics/class-based-views/intro/
• Sending emails with Django –https://docs.djangoproject.com/en/4.1/topics/email/
• Django form field types –https://docs.djangoproject.com/en/4.1/ref/forms/fields/
• Working with forms –https://docs.djangoproject.com/en/4.1/topics/forms/
• Creating forms from models –https://docs.djangoproject...

In this chapter, you learned how to define canonical URLs for models. You created SEO-friendly URLs for blog posts, and you implemented object pagination for your post list. You also learned how to work with Django forms and model forms. You created a system to recommend posts by email and created a comment system for your blog.

In the next chapter, you will create a tagging system for the blog. You will learn how to build complex QuerySets to retrieve objects by similarity. You will learn how to create custom template tags and filters. You will also build a custom sitemap and feed for your blog posts and implement a full-text search functionality for your posts.