When you start adding content to your blog, you can easily store tens or hundreds of posts in your database. 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.3 shows Google’s pagination links for search result pages:

Figure 2.3: 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

We will add pagination to the list of posts so that...

We have built the blog 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 you can use to implement your own views. All of them inherit from the View class, which handles HTTP method dispatching and other common functionalities.

Why use class-based views

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

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

We will allow users to share blog posts with others by sending post recommendations via email. You will learn how to create forms in Django, handle data submission, and send emails with Django, enhancing your blog with a personal touch.

Take a minute to think about how you could use views, URLs, and templates to create this functionality using what you learned in the preceding chapter.

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

1. Create a form for users to fill in their name, their email address, the recipient’s email address, and optional comments
2. Create a view in the views.py file that handles the posted data and sends the email
3. Add a URL pattern for the new view in the urls.py file of the blog application
4. 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 allows you to create...

We will continue extending our blog application with 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 Django 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 the HTML form to add a new comment that can be included in the post detail template

Creating a model for comments

Let’s start by building a model to store user comments on posts.

Open the models.py file of your blog application and add the following code:

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

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 full-text search functionality for your posts.

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

• Source code for this chapter: https://github.com/PacktPublishing/Django-5-by-example/tree/main/Chapter02
• URL utility functions: https://docs.djangoproject.com/en/5.0/ref/urlresolvers/
• URL path converters: https://docs.djangoproject.com/en/5.0/topics/http/urls/#path-converters
• Django paginator class: https://docs.djangoproject.com/en/5.0/ref/paginator/
• Introduction to class-based views – https://docs.djangoproject.com/en/5.0/topics/class-based-views/intro/
• Sending emails with Django: https://docs.djangoproject.com/en/5.0/topics/email/
• The python-decouple library: https://github.com/HBNetwork/python-decouple
• The django-anymail library: https://anymail.dev/en/stable/installation/
• The django-anymail supported email service providers: https://anymail.dev/en/stable/esps/
• Django form field types...