Fr

ee

Django is a powerful Python web framework designed to

develop web applications quickly, from simple prototypes to
large-scale projects. Django encourages clean, pragmatic
design, and provides developers with a comprehensive set
of tools to build scalable web applications.
This book will walk you through the creation of four
professional Django projects, teaching you how to solve
common problems, and implement best practices.
The book begins by showing you how to build a blog
application, before moving on to developing a social image
bookmarking website, an online shop, and an e-learning
platform. You will learn how to build a search engine and
implement a user activity stream. Furthermore, you will
create a recommendation engine, an e-commerce coupon
system, and a content management system. The book will
also teach you how to enhance your applications with AJAX,
create RESTful APIs, and setup a production environment
for your Django projects.
After reading this book, you will have a good understanding
of how Django works and how to integrate it with other
technologies to build practical, and advanced web
applications.
If you are a web developer who is completely new to or
familiar with Django and wants to make the most of it, this
book is for you. Some basic knowledge of Python, HTML,
and JavaScript is recommended.

Build practical real-world web applications

with Django
Use Django with other technologies such as
Redis, Celery, Solr, and Memcached
Develop pluggable Django applications
Create advanced features, optimize your
code, and use the cache framework
Add internationalization to your Django
projects
Enhance the user experience using
JavaScript and AJAX
Add social features to your projects
Build RESTful APIs for your applications

$ 44.99 US
28.99 UK

community experience distilled

P U B L I S H I N G

Antonio Mel

Who this book is written for

What you will learn from this book

Django By Example

Django By Example

pl

C o m m u n i t y

E x p e r i e n c e

D i s t i l l e d

Django By Example
Create your own line of successful web applications with Django

Prices do not include

local sales tax or VAT
where applicable

Visit www.PacktPub.com for books, eBooks,

code, downloads, and PacktLib.

Sa
m

Antonio Mel

In this package, you will find:

The author biography

A preview chapter from the book, Chapter 6 'Tracking User Actions'
A synopsis of the books content
More information on Django By Example

About the Author

Antonio Mel holds an MSc in Computer Science. He has been developing Django
projects since 2006 and leads the django.es Spanish Django community. He has
founded Zenx IT, a technology company that creates web applications for clients of
several industries.

Antonio has also worked as a CTO for several technology-based start-ups. His father
inspired his passion for computers and programming.

Preface
Django is a powerful Python web framework that encourages rapid development
and clean, pragmatic design, offering a relatively shallow learning curve. This makes
it attractive to both novice and expert programmers.
This book will guide you through the entire process of developing professional web
applications with Django. The book not only covers the most relevant aspects of the
framework, it also teaches you how to integrate other popular technologies into your
Django projects.
The book will walk you through the creation of real-world applications, solving
common problems, and implementing best practices with a step-by-step approach
that is easy to follow.
After reading this book, you will have a good understanding of how Django works
and how to build practical, advanced web applications.

What this book covers

Chapter 1, Building a Blog Application, introduces you to the framework by creating a
blog application. You will create the basic blog models, views, templates, and URLs
to display blog posts. You will learn how to build QuerySets with the Django ORM,
and you will configure the Django administration site.
Chapter 2, Enhancing Your Blog with Advanced Features, teaches how to handle forms
and modelforms, send e-mails with Django, and integrate third-party applications.
You will implement a comment system for your blog posts and allow your users
to share posts by e-mail. The chapter will also guide you through the process of
creating a tagging system.

Preface

Chapter 3, Extending Your Blog Application explores how to create custom template
tags and filters. The chapter will also show you how to use the sitemap framework
and create an RSS feed for your posts. You will complete your blog application by
building a search engine with Solr.
Chapter 4, Building a Social Website explains how to build a social website. You will
use the Django authentication framework to create user account views. You will
learn how to create a custom user profile model and build social authentication into
your project using major social networks.
Chapter 5, Sharing Content in Your Website teaches you how to transform your social
application into an image bookmarking website. You will define many-to-many
relationships for models, and you will create an AJAX bookmarklet in JavaScript
and integrate it into your project. The chapter will show you how to generate image
thumbnails and create custom decorators for your views.
Chapter 6, Tracking User Actions shows you how to build a follower system for users.
You will complete your image bookmarking website by creating a user activity
stream application. You will learn how to optimise QuerySets, and you will work
with signals. You will integrate Redis into your project to count image views.
Chapter 7, Building an Online Shop explores how to create an online shop. You will
build the catalog models, and you will create a shopping cart using Django sessions.
You will learn to manage customer orders and send asynchronous notifications to
users using Celery.
Chapter 8, Managing Payments and Orders explains you how to integrate a payment
gateway into your shop and handle payment notifications. You will also customize
the administration site to export orders to CSV files, and you will generate PDF
invoices dynamically.
Chapter 9, Extending Your Shop teaches you how to create a coupon system to apply
discounts to orders. The chapter will show you how to add internationalization to
your project and
how to translate models. You will also build a product recommendation engine
using Redis.
Chapter 10, Building an e-Learning Platform guides you through creating an e-learning
platform. You will add fixtures to your project, use model inheritance, create custom
model fields, use class-based views, and manage groups and permissions. You will
create a content management system and handle formsets.
Chapter 11, Caching Content shows you how to create a student registration system and
manage student enrollment in courses. You will render diverse course contents and
you will learn how to use the cache framework.

Preface

Chapter 12, Building an API explores building a RESTful API for your project using
the Django REST framework.

Tracking User Actions

In the previous chapter, you implemented AJAX views into your project using
jQuery and built a JavaScript bookmarklet for sharing content from other websites
in your platform.
In this chapter, you will learn how to build a follower system and create a user
activity stream. You will discover how Django signals work and integrate Redis
fast I/O storage into your project to store item views.
This chapter will cover the following points:

Creating many-to-many relationships with an intermediary model

Building AJAX views

Creating an activity stream application

Adding generic relations to models

Optimizing QuerySets for related objects

Using signals for denormalizing counts

Storing item views in Redis

Building a follower system

We will build a follower system into our project. Our users will be able to follow
each other and track what other users share on the platform. The relationship
between users is a many-to-many relationship, A user can follow multiple users
and can be followed back by multiple users.

[ 169 ]

Tracking User Actions

Creating many-to-many relationships with an

intermediary model
In previous chapters, you created many-to-many relationships by adding a
ManyToManyField to one of the related models and letting Django create the
database table for the relationship. This is suitable for most of the cases, but
sometimes you might need to create an intermediate model for the relation. Creating
an intermediary model is necessary when you want to store additional information
for the relationship, for example the date when the relation was created or a field
that describes the type of the relationship.
We will create an intermediary model for building relationships between users.
There are two reasons why we want to use an intermediate model:

We are using the user model provided by Django and we want to avoid
altering it

We want to store the time when the relation is created

Edit the models.py file of your account application and add the following code to it:
from django.contrib.auth.models import User
class Contact(models.Model):
user_from = models.ForeignKey(User,
related_name='rel_from_set')
user_to = models.ForeignKey(User,
related_name='rel_to_set')
created = models.DateTimeField(auto_now_add=True,
db_index=True)
class Meta:
ordering = ('-created',)
def __str__(self):
return '{} follows {}'.format(self.user_from,
self.user_to)

This is the Contact model we will use for user relationships. It contains the
following fields:

user_from: A ForeignKey for the user that creates the relationship

user_to: A ForeignKey for the user being followed

created: A DateTimeField field with auto_now_add=True to store the time

when the relationship was created
[ 170 ]

Chapter 6

A database index is automatically created on ForeignKey fields. We use

db_index=True to create a database index for the created field. This will
improve query performance when ordering QuerySets by this field.
Using the ORM, we could create a relationship for a user user1 following another
user user2, like this:
user1 = User.objects.get(id=1)
user2 = User.objects.get(id=2)
Contact.objects.create(user_from=user1, user_to=user2)

The related managers rel_from_set and rel_to_set will return a QuerySet for
the Contact model. In order to access the end side of the relationship from the User
model, it would be desirable that User contained a ManyToManyField as follows:
following = models.ManyToManyField('self',
through=Contact,
related_name='followers',
symmetrical=False)

In this example, we tell Django to use our custom intermediary model for the
relationship by adding through=Contact to the ManyToManyField. This is a
many-to-many relationship from the User model to itself: We refer to 'self'
in the ManyToManyField field to create a relationship to the same model.
When you need additional fields in a many-to-many relationship,
create a custom model with a ForeignKey for each side of the
relationship. Add a ManyToManyField in one of the related
models and indicate Django to use your intermediary model by
including it in the through parameter.

If the User model was part of our application, we could add the previous field to
the model. However, we cannot alter the User class directly because it belongs to
the django.contrib.auth application. We are going to take a slightly different
approach, by adding this field dynamically to the User model. Edit the models.py
file of the account application and add the following lines:
# Add following field to User dynamically
User.add_to_class('following',
models.ManyToManyField('self',
through=Contact,
related_name='followers',
symmetrical=False))

[ 171 ]

Tracking User Actions

In this code, we use the add_to_class() method of Django models to

monkey-patch the User model. Be aware that using add_to_class() is not the
recommended way for adding fields to models. However, we take advantage
from using it in this case because of the following reasons:

We simplify the way we retrieve related objects using the Django ORM
with user.followers.all() and user.following.all(). We use the
intermediary Contact model and avoid complex queries that would involve
additional database joins, as it would have been if we had defined the
relationship in our custom Profile model.
The table for this many-to-many relationship will be created using the

Contact model. Thus, the ManyToManyField added dynamically will not

imply any database changes for the Django User model.

We avoid creating a custom user model, keeping all the advantages of

Django's built-in User.

Keep in mind that in most cases, it is preferable to add fields to the Profile model
we created before, instead of monkey-patching the User model. Django also allows
you to use custom user models. If you want to use your custom user model, take a
look at the documentation at https://docs.djangoproject.com/en/1.8/topics/
auth/customizing/#specifying-a-custom-user-model.
You can see that the relationship includes symmetrical=False. When you define a
ManyToManyField to the model itself, Django forces the relationship to be symmetrical.
In this case, we are setting symmetrical=False to define a non-symmetric relation.

This is, if I follow you, it doesn't mean you automatically follow me.

When you use an intermediate model for many-to-many

relationships some of the related manager's methods are disabled,
such as add(), create() or remove(). You need to create or
delete instances of the intermediate model instead.

Run the following command to generate the initial migrations for the account
application:
python manage.py makemigrations account

You will see the following output:

Migrations for 'account':
0002_contact.py:
- Create model Contact

[ 172 ]

Chapter 6

Now run the following command to sync the application with the database:
python manage.py migrate account

You should see an output that includes the following line:

Applying account.0002_contact... OK

The Contact model is now synced to the database and we are able to create
relationships between users . However, our site doesn't offer a way to browse
through users or see a particular user profile yet. Let's build list and detail
views for the User model.

Creating list and detail views for user profiles

Open the views.py file of the account application and add the following code to it:
from django.shortcuts import get_object_or_404
from django.contrib.auth.models import User
@login_required
def user_list(request):
users = User.objects.filter(is_active=True)
return render(request,
'account/user/list.html',
{'section': 'people',
'users': users})
@login_required
def user_detail(request, username):
user = get_object_or_404(User,
username=username,
is_active=True)
return render(request,
'account/user/detail.html',
{'section': 'people',
'user': user})

These are simple list and detail views for User objects. The user_list view gets all
active users. The Django User model contains a flag is_active to designate whether
the user account is considered active. We filter the query by is_active=True to
return only active users. This view returns all results, but you can improve it by
adding pagination the same way we did for the image_list view.

[ 173 ]

Tracking User Actions

The user_detail view uses the get_object_or_404() shortcut to retrieve the

active user with the given username. The view returns an HTTP 404 response
if no active user with the given username is found.
Edit the urls.py file of the account application, and add an URL pattern for each
view as follows:
urlpatterns = [
# ...
url(r'^users/$', views.user_list, name='user_list'),
url(r'^users/(?P<username>[-\w]+)/$',
views.user_detail,
name='user_detail'),
]

We are going to use the user_detail URL pattern to generate the canonical URL
for users. You have already defined a get_absolute_url() method in a model to
return the canonical URL for each object. Another way to specify an URL for a model
is by adding the ABSOLUTE_URL_OVERRIDES setting to your project.
Edit the settings.py file of your project and add the following code to it:
ABSOLUTE_URL_OVERRIDES = {
'auth.user': lambda u: reverse_lazy('user_detail',
args=[u.username])
}

Django adds a get_absolute_url() method dynamically to any models that appear

in the ABSOLUTE_URL_OVERRIDES setting. This method returns the corresponding
URL for the given model specified in the setting. We return the user_detail URL
for the given user. Now you can use get_absolute_url() on a User instance to
retrieve its corresponding URL. Open the Python shell with the command python
manage.py shell and run the following code to test it:
>>> from django.contrib.auth.models import User
>>> user = User.objects.latest('id')
>>> str(user.get_absolute_url())
'/account/users/ellington/'

The returned URL is as expected. We need to create templates for the views we just
built. Add the following directory and files to the templates/account/ directory of
the account application:
/user/
detail.html
list.html
[ 174 ]

Chapter 6

Edit the account/user/list.html template and add the following code to it:
{% extends "base.html" %}
{% load thumbnail %}
{% block title %}People{% endblock %}
{% block content %}
<h1>People</h1>
<div id="people-list">
{% for user in users %}
<div class="user">
<a href="{{ user.get_absolute_url }}">
{% thumbnail user.profile.photo "180x180" crop="100%" as im
%}
<img src="{{ im.url }}">
{% endthumbnail %}
</a>
<div class="info">
<a href="{{ user.get_absolute_url }}" class="title">
{{ user.get_full_name }}
</a>
</div>
</div>
{% endfor %}
</div>
{% endblock %}

This template allows us to list all the active users in the site. We iterate over the given
users and use sorl-thumbnail's {% thumbnail %} template tag to generate profile
image thumbnails.
Open the base.html template of your project and include the user_list URL in the
href attribute of the following menu item:
<li {% if section == "people" %}class="selected"{% endif %}><a
href="{% url "user_list" %}">People</a></li>

[ 175 ]

Tracking User Actions

Start the development server with the command python manage.py runserver and
open http://127.0.0.1:8000/account/users/ in your browser. You should see a
list of users like the following one:

Edit account/user/detail.html template of the account application and add the

following code to it:
{% extends "base.html" %}
{% load thumbnail %}
{% block title %}{{ user.get_full_name }}{% endblock %}
{% block content %}
<h1>{{ user.get_full_name }}</h1>
<div class="profile-info">
{% thumbnail user.profile.photo "180x180" crop="100%" as im %}
<img src="{{ im.url }}" class="user-detail">
{% endthumbnail %}
</div>
{% with total_followers=user.followers.count %}
<span class="count">
<span class="total">{{ total_followers }}</span>
follower{{ total_followers|pluralize }}
</span>
<a href="#" data-id="{{ user.id }}" data-action="{% if request.
user in user.followers.all %}un{% endif %}follow" class="follow
button">
{% if request.user not in user.followers.all %}

[ 176 ]

Chapter 6
Follow
{% else %}
Unfollow
{% endif %}
</a>
<div id="image-list" class="image-container">
{% include "images/image/list_ajax.html" with images=user.
images_created.all %}
</div>
{% endwith %}
{% endblock %}

In the detail template we display the user profile and we use the {% thumbnail %}
template tag to display the profile image. We show the total number of followers and
a link to follow/unfollow the user. We prevent users from following themselves
by hiding this link if the user is watching their own profile. We are going to perform
an AJAX request to follow/unfollow a particular user. We add data-id and dataaction attributes to the <a> HTML element including the user ID and the initial
action to perform when it's clicked, follow or unfollow, that depends on the user
requesting the page being or not a follower of this user. We display the images
bookmarked by the user with the list_ajax.html template.
Open your browser again and click on a user that has bookmarked some images.
You will see a profile detail like the following one:

[ 177 ]

Tracking User Actions

Building an AJAX view to follow users

We will create a simple view to follow/unfollow a user using AJAX. Edit the
views.py file of the account application and add the following code to it:
from
from
from
from

django.http import JsonResponse

django.views.decorators.http import require_POST
common.decorators import ajax_required
.models import Contact

@ajax_required
@require_POST
@login_required
def user_follow(request):
user_id = request.POST.get('id')
action = request.POST.get('action')
if user_id and action:
try:
user = User.objects.get(id=user_id)
if action == 'follow':
Contact.objects.get_or_create(
user_from=request.user,
user_to=user)
else:
Contact.objects.filter(user_from=request.user,
user_to=user).delete()
return JsonResponse({'status':'ok'})
except User.DoesNotExist:
return JsonResponse({'status':'ko'})
return JsonResponse({'status':'ko'})

The user_follow view is quite similar to the image_like view we created before.
Since we are using a custom intermediary model for the users' many-to-many
relationship, the default add() and remove() methods of the automatic manager
of ManyToManyField are not available. We use the intermediary Contact model
to create or delete user relationships.
Import the view you just created in the urls.py file of the account application and
add the following URL pattern to it:
url(r'^users/follow/$', views.user_follow, name='user_follow'),

[ 178 ]

Chapter 6

Make sure that you place this pattern before the user_detail URL pattern.
Otherwise, any requests to /users/follow/ will match the regular expression of
the user_detail pattern and it will be executed instead. Remember that in every
HTTP request Django checks the requested URL against each pattern in order of
appearance and stops at the first match.
Edit the user/detail.html template of the account application and append the
following code to it:
{% block domready %}
$('a.follow').click(function(e){
e.preventDefault();
$.post('{% url "user_follow" %}',
{
id: $(this).data('id'),
action: $(this).data('action')
},
function(data){
if (data['status'] == 'ok') {
var previous_action = $('a.follow').data('action');
// toggle data-action
$('a.follow').data('action',
previous_action == 'follow' ? 'unfollow' : 'follow');
// toggle link text
$('a.follow').text(
previous_action == 'follow' ? 'Unfollow' : 'Follow');
// update total followers
var previous_followers = parseInt(
$('span.count .total').text());
$('span.count .total').text(previous_action == 'follow' ?
previous_followers + 1 : previous_followers - 1);
}
}
);
});
{% endblock %}

This is the JavaScript code to perform the AJAX request to follow or unfollow a
particular user and also toggle the follow/unfollow link. We use jQuery to perform
the AJAX request and set both the data-action attribute and the text of the HTML
<a> element based on its previous value. When the AJAX action is performed, we also
update the count of total followers displayed on the page. Open the user detail page
of an existing user and click the Follow link to try the functionality we just built.
[ 179 ]

Tracking User Actions

Building a generic activity stream

application
Many social websites show an activity stream to their users, so that they can track
what other users do in the platform. An activity stream is a list of recent activities
performed by a user or a group of users. For example, Facebook's News Feed is an
activity stream. Example actions can be User X bookmarked image Y or User X is
now following user Y. We will build an activity stream application so that every
user can see recent interactions of users he follows. To do so, we will need a model
to save the actions performed by users on the website and simple way to add actions
to the feed.
Create a new application named actions inside your project with the following
command:
django-admin startapp actions

Add 'actions' to INSTALLED_APPS in the settings.py file of your project to let

Django know the new application is active:
INSTALLED_APPS = (
#
'actions',
)

Edit the models.py file of the actions application and add the following code to it:
from django.db import models
from django.contrib.auth.models import User
class Action(models.Model):
user = models.ForeignKey(User,
related_name='actions',
db_index=True)
verb = models.CharField(max_length=255)
created = models.DateTimeField(auto_now_add=True,
db_index=True)
class Meta:
ordering = ('-created',)

[ 180 ]

Chapter 6

This is the Action model that will be used for storing user activities. The fields of
this model are as follows:

user: The user that performed the action. This is a ForeignKey to the Django
User model.

verb: The verb describing the action that the user has performed.

created: The date and time when this action was created. We use auto_now_
add=True to automatically set this to the current datetime when the object is

saved for the first time in the database.

With this basic model, we can only store actions such as User X did something. We
need an extra ForeignKey field in order to save actions that involve a target object,
such as User X bookmarked image Y or User X is now following user Y. As you
already know, a normal ForeignKey can only point to one other model. Instead,
we need a way for the action's target object to be an instance of any existing model.
This is where the Django contenttypes framework comes on the scene.

Using the contenttypes framework

Django includes a contenttypes framework located at django.contrib.
contenttypes. This application can track all models installed in your project
and provides a generic interface to interact with your models.
The 'django.contrib.contenttypes' is included in the INSTALLED_APPS setting
by default when you create a new project using the startproject command. It
is used by other contrib packages such as the authentication framework and the
admin application.
The contenttypes application contains a ContentType model. Instances of this
model represent the actual models of your application, and new instances of
ContentType are automatically created when new models are installed in your
project. The ContentType model has the following fields:

app_label: The name of the application the model belongs to. This is
automatically taken from the app_label attribute of the model Meta options.
For example, our Image model belongs to the application images.

model: The name of the model class.

name: The human-readable name of the model. This is automatically taken

from the verbose_name attribute of the model Meta options.

[ 181 ]

Tracking User Actions

Let's take a look at how we can interact with ContentType objects. Open the
Python console using the python manage.py shell command. You can get the
ContentType object corresponding to a specific model by performing a query
with the app_label and model attributes such as this:
>>> from django.contrib.contenttypes.models import ContentType
>>> image_type = ContentType.objects.get(app_label='images',
model='image')
>>> image_type
<ContentType: image>

You can also retrieve the model class back from a ContentType object by calling its
model_class() method:
>>> image_type.model_class()
<class 'images.models.Image'>

It's also common to get the ContentType object for a particular model class as
follows:
>>> from images.models import Image
>>> ContentType.objects.get_for_model(Image)
<ContentType: image>

These are just some examples of using contenttypes. Django offers more ways to work
with them. You can find the official documentation about the contenttypes framework
at https://docs.djangoproject.com/en/1.8/ref/contrib/contenttypes/.

Adding generic relations to your models

In generic relations ContentType objects play the role of pointing to the model used
for the relationship. You will need three fields to setup a generic relation in a model:

A ForeignKey field to ContentType. This will tell us the model for the
relationship.

A field to store the primary key of the related object. This will usually be a
PositiveIntegerField to match Django automatic primary key fields.

A field to define and manage the generic relation using the two previous
fields. The contenttypes framework offers a GenericForeignKey field for
this purpose.

[ 182 ]

Chapter 6

Edit the models.py file of the actions application and make it look like this:
from
from
from
from

django.db import models

django.contrib.auth.models import User
django.contrib.contenttypes.models import ContentType
django.contrib.contenttypes.fields import GenericForeignKey

class Action(models.Model):
user = models.ForeignKey(User,
related_name='actions',
db_index=True)
verb = models.CharField(max_length=255)
target_ct = models.ForeignKey(ContentType,
blank=True,
null=True,
related_name='target_obj')
target_id = models.PositiveIntegerField(null=True,
blank=True,
db_index=True)
target = GenericForeignKey('target_ct', 'target_id')
created = models.DateTimeField(auto_now_add=True,
db_index=True)
class Meta:
ordering = ('-created',)

We have added the following fields to the Action model:

target_ct: A ForeignKey field to the ContentType model.

target_id: A PositiveIntegerField for storing the primary key of the

target: A GenericForeignKey field to the related object based on the

related object.

combination of the two previous fields.

Django does not create any field in the database for GenericForeignKey fields. The
only fields that are mapped to database fields are target_ct and target_id. Both
fields have blank=True and null=True attributes so that a target object is not
required when saving Action objects.
You can make your applications more flexible by using generic
relationships instead of foreign-keys when it makes sense to have
a generic relation.

[ 183 ]

Tracking User Actions

Run the following command to create initial migrations for this application:
python manage.py makemigrations actions

You should see the following output:

Migrations for 'actions':
0001_initial.py:
- Create model Action

Then, run the next command to sync the application with the database:
python manage.py migrate

The output of the command should indicate that the new migrations have been
applied as follows:
Applying actions.0001_initial... OK

Let's add the Action model to the administration site. Edit the admin.py file of the
actions application and add the following code to it:
from django.contrib import admin
from .models import Action
class ActionAdmin(admin.ModelAdmin):
list_display = ('user', 'verb', 'target', 'created')
list_filter = ('created',)
search_fields = ('verb',)
admin.site.register(Action, ActionAdmin)

You just registered the Action model in the administration site. Run the command
python manage.py runserver to initialize the development server and open
http://127.0.0.1:8000/admin/actions/action/add/ in your browser. You
should see the page for creating a new Action object as follows:

[ 184 ]

Chapter 6

As you can see, only the target_ct and target_id fields that are mapped to actual
database fields are shown, and the GenericForeignKey field does not appear here.
The target_ct allows you to select any of the registered models of your Django
project. You can restrict the contenttypes to choose from to a limited set of models
by using the limit_choices_to attribute in the target_ct field: The limit_
choices_to attribute allows you to restrict the content of ForeignKey fields to a
specific set of values.
Create a new file inside the actions application directory and name it utils.py.
We will define a shortcut function that will allow us to create new Action objects in
a simple way. Edit the new file and add the following code to it:
from django.contrib.contenttypes.models import ContentType
from .models import Action
def create_action(user, verb, target=None):
action = Action(user=user, verb=verb, target=target)
action.save()

The create_action() function allows us to create actions that optionally include a

target object. We can use this function anywhere in our code to add new actions
to the activity stream.

[ 185 ]

Tracking User Actions

Avoiding duplicate actions in the activity

stream
Sometimes your users might perform an action multiple times. They might click
several times on like/unlike buttons or perform the same action multiple times in a
short period of time. This will make you end up storing and displaying duplicated
actions. In order to avoid this we will improve the create_action() function to
avoid most of the duplicates.
Edit the utils.py file of the actions application and make it look like the following:
import datetime
from django.utils import timezone
from django.contrib.contenttypes.models import ContentType
from .models import Action
def create_action(user, verb, target=None):
# check for any similar action made in the last minute
now = timezone.now()
last_minute = now - datetime.timedelta(seconds=60)
similar_actions = Action.objects.filter(user_id=user.id,
verb= verb,
timestamp__gte=last_minute)
if target:
target_ct = ContentType.objects.get_for_model(target)
similar_actions = similar_actions.filter(
target_ct=target_ct,
target_id=target.id)
if not similar_actions:
# no existing actions found
action = Action(user=user, verb=verb, target=target)
action.save()
return True
return False

We have changed the create_action() function to avoid saving duplicate actions

and return a boolean to tell if the action was saved or not. This is how we avoid
duplicates:

First, we get the current time using the timezone.now() method provided
by Django. This method does the same as datetime.datetime.now() but
returns a timezone-aware object. Django provides a setting called USE_TZ
to enable or disable timezone support. The default settings.py file created
using the startproject command includes USE_TZ=True.
[ 186 ]

Chapter 6

We use the last_minute variable to store the datetime one minute ago and
we retrieve any identical actions performed by the user since then.

We create an Action object if no identical action already exists in the last

minute. We return True if an Action object was created, False otherwise.

Adding user actions to the activity stream

It's time to add some actions to our views to build the activity stream for our users.
We are going to store an action for each of the following interactions:

A user bookmarks an image

A user likes/unlikes an image

A user creates an account

A user follows/unfollows another user

Edit the views.py file of the images application and add the following import:
from actions.utils import create_action

In the image_create view, add create_action() after saving the image like this:
new_item.save()
create_action(request.user, 'bookmarked image', new_item)

In the image_like view, add create_action() after adding the user to the
users_like relationship as follows:
image.users_like.add(request.user)
create_action(request.user, 'likes', image)

Now edit the views.py file of the account application and add the following import:
from actions.utils import create_action

In the register view, add create_action() after creating the Profile object
as follows:
new_user.save()
profile = Profile.objects.create(user=new_user)
create_action(new_user, 'has created an account')

[ 187 ]

Tracking User Actions

In the user_follow view add create_action() like this:

Contact.objects.get_or_create(user_from=request.user,
user_to=user)
create_action(request.user, 'is following', user)

As you can see, thanks to our Action model and our helper function, it's very easy
to save new actions to the activity stream.

Displaying the activity stream

Finally, we need a way to display the activity stream for each user. We are going to
include it in the user's dashboard. Edit the views.py file of the account application.
Import the Action model and modify the dashboard view as follows:
from actions.models import Action
@login_required
def dashboard(request):
# Display all actions by default
actions = Action.objects.exclude(user=request.user)
following_ids = request.user.following.values_list('id',
flat=True)
if following_ids:
# If user is following others, retrieve only their actions
actions = actions.filter(user_id__in=following_ids)
actions = actions[:10]
return render(request,
'account/dashboard.html',
{'section': 'dashboard',
'actions': actions})

In this view, we retrieve all actions from the database, excluding the ones performed
by the current user. If the user is not following anybody yet, we display the latest
actions performed by other users on the platform. This is the default behavior when
the user is not following any other users yet. If the user is following other users, we
restrict the query to only display actions performed by the users he follows. Finally,
we limit the result to the first 10 actions returned. We are not using order_by() here
because we are relying on the default ordering we provided in the Meta options
of the Action model. Recent actions will come first, since we have set ordering =
('-created',) in the Action model.

[ 188 ]

Chapter 6

Optimizing QuerySets that involve related

objects
Every time you retrieve an Action object, you will probably access its related User
object, and probably the user's related Profile object too. The Django ORM offers
a simple way to retrieve related objects at once, avoiding additional queries to
the database.

Using select_related
Django offers a QuerySet method called select_related() that allows you to
retrieve related objects for one-to-many relationships. This translates to a single,
more complex QuerySet, but you avoid additional queries when accessing the
related objects. The select_related method is for ForeignKey and OneToOne fields.
It works by performing a SQL JOIN and including the fields of the related object
in the SELECT statement.
To take advantage of select_related(), edit the following line of the previous code:
actions = actions.filter(user_id__in=following_ids)

And add select_related on the fields that you will use:

actions = actions.filter(user_id__in=following_ids)\
.select_related('user', 'user__profile')

We are using user__profile to join the profile table too in one single SQL query.
If you call select_related() without passing any arguments to it, it will retrieve
objects from all ForeignKey relationships. Always limit select_related() to the
relationships that will be accessed afterwards.
Using select_related() carefully can vastly improve execution time.

Using prefetch_related
As you see, select_related() will help you boost performance for retrieving related
objects in one-to-many relationships. However, select_related() cannot work for
many-to-many or many-to-one relationships (ManyToMany or reverse ForeignKey
fields). Django offers a different QuerySet method called prefetch_related that
works for many-to-many and many-to-one relations in addition to the relations
supported by select_related(). The prefetch_related() method performs a
separate lookup for each relationship and joins the results using Python. This method
also supports prefetching of GenericRelation and GenericForeignKey.
[ 189 ]

Tracking User Actions

Complete your query by adding prefetch_related() to it for the target

GenericForeignKey field as follows:
actions = actions.filter(user_id__in=following_ids)\
.select_related('user', 'user__profile')\
.prefetch_related('target')

This query is now optimized for retrieving the user actions including related objects.

Creating templates for actions

We are going to create the template to display a particular Action object. Create a
new directory inside the actions application directory and name it templates. Add
the following file structure to it:
actions/
action/
detail.html

Edit the actions/action/detail.html template file and add the following lines
to it:
{% load thumbnail %}
{% with user=action.user profile=action.user.profile %}
<div class="action">
<div class="images">
{% if profile.photo %}
{% thumbnail user.profile.photo "80x80" crop="100%" as im %}
<a href="{{ user.get_absolute_url }}">
<img src="{{ im.url }}" alt="{{ user.get_full_name }}"
class="item-img">
</a>
{% endthumbnail %}
{% endif %}
{% if action.target %}
{% with target=action.target %}
{% if target.image %}
{% thumbnail target.image "80x80" crop="100%" as im %}
<a href="{{ target.get_absolute_url }}">
<img src="{{ im.url }}" class="item-img">
</a>
{% endthumbnail %}
{% endif %}
[ 190 ]

Chapter 6
{% endwith %}
{% endif %}
</div>
<div class="info">
<p>
<span class="date">{{ action.created|timesince }} ago</span>
<br />
<a href="{{ user.get_absolute_url }}">
{{ user.first_name }}
</a>
{{ action.verb }}
{% if action.target %}
{% with target=action.target %}
<a href="{{ target.get_absolute_url }}">{{ target }}</a>
{% endwith %}
{% endif %}
</p>
</div>
</div>
{% endwith %}

This is the template to display an Action object. First, we use the {% with %}
template tag to retrieve the user performing the action and their profile. Then, we
display the image of the target object if the Action object has a related target object.
Finally, we display the link to the user that performed the action, the verb and the
target object, if any.
Now, edit the account/dashboard.html template and append the following code
to the bottom of the content block:
<h2>What's happening</h2>
<div id="action-list">
{% for action in actions %}
{% include "actions/action/detail.html" %}
{% endfor %}
</div>

[ 191 ]

Tracking User Actions

Open http://127.0.0.1:8000/account/ in your browser. Log in with an existing

user and perform several actions so that they get stored in the database. Then, log in
using another user, follow the previous user, and take a look at the generated action
stream in the dashboard page. It should look like the following:

We just created a complete activity stream for our users and we can easily add new
user actions to it. You can also add infinite scroll functionality to the activity stream
by implementing the same AJAX paginator we used for the image_list view.

Using signals for denormalizing counts

There are some cases when you would like to denormalize your data. Denormalization
is making data redundant in a way that it optimizes read performance. You have
to be careful about denormalization and only start using it when you really need
it. The biggest issue you will find with denormalization is it's difficult to keep your
denormalized data updated.
We will see an example of how to improve our queries by denormalizing counts.
The drawback is that we have to keep the redundant data updated. We are going
to denormalize data from our Image model and use Django signals to keep the
data updated.

[ 192 ]

Chapter 6

Working with signals

Django comes with a signal dispatcher that allows receiver functions to get notified
when certain actions occur. Signals are very useful when you need your code to do
something every time something else happens. You can also create your own signals
so that others can get notified when an event happens.
Django provides several signals for models located at django.db.models.signals.
Some of these signals are:

pre_save and post_save: Sent before or after calling the save() method
of a model

pre_delete and post_delete: Sent before or after calling the delete()

m2m_changed: Sent when a ManyToManyField on a model is changed

method of a model or QuerySet

These are just a subset of the signals provided by Django. You can find the list of all
built-in signals at https://docs.djangoproject.com/en/1.8/ref/signals/.
Let's say you want to retrieve images by popularity. You can use the Django
aggregation functions to retrieve images ordered by then number of users who like
them. Remember you used Django aggregation functions in Chapter 3, Extending Your
Blog Application. The following code will retrieve images by their number of likes:
from django.db.models import Count
from images.models import Image
images_by_popularity = Image.objects.annotate(
total_likes=Count('users_like')).order_by('-total_likes')

However, ordering images by counting their total likes is more expensive in terms
of performance than ordering them by a field which stores total counts. You can
add a field to the Image model to denormalize the total number of likes to boost
performance in queries that involve this field. How to keep this field updated?
Edit the models.py file of the images application and add the following field to the
Image model:
total_likes = models.PositiveIntegerField(db_index=True,
default=0)

The total_likes field will allow us to store the total count of users that like each
image. Denormalizing counts is useful when you want to filter or order QuerySets
by them.

[ 193 ]

Tracking User Actions

There are several ways to improve performance that you have to take into
account before denormalizing fields. Consider database indexes, query
optimization and caching before starting to denormalize your data.

Run the following command to create the migrations for adding the new field to the
database table:
python manage.py makemigrations images

You should see the following output:

Migrations for 'images':
0002_image_total_likes.py:
- Add field total_likes to image

Then, run the following command to apply the migration:

python manage.py migrate images

The output should include the following line:

Applying images.0002_image_total_likes... OK

We are going to attach a receiver function to the m2m_changed signal. Create a

new file inside the images application directory and name it signals.py. Add the
following code to it:
from django.db.models.signals import m2m_changed
from django.dispatch import receiver
from .models import Image
@receiver(m2m_changed, sender=Image.users_like.through)
def users_like_changed(sender, instance, **kwargs):
instance.total_likes = instance.users_like.count()
instance.save()

First, we register the users_like_changed function as a receiver function using

the receiver() decorator and we attach it to the m2m_changed signal. We connect
the function to Image.users_like.through so that the function is only called if the
m2m_changed signal has been launched by this sender. There is an alternate method
for registering a receiver function, which consists of using the connect() method
of the Signal object.

[ 194 ]

Chapter 6

Django signals are synchronous and blocking. Don't confuse signals

with asynchronous tasks. However, you can combine both to launch
asynchronous tasks when your code gets notified by a signal.

You have to connect your receiver function to a signal, so that it gets called every
time the signal is sent. The recommended method for registering your signals is
by importing them in the ready() method of your application configuration class.
Django provides an application registry that allows you to configure and introspect
your applications.

Defining application configuration classes

Django allows you to specify configuration classes for your applications. To provide
a custom configuration for your application, create a custom class that inherits
the AppConfig class located in django.apps. The application configuration class
allows you to store metadata and configuration for the application and provides
introspection.
You can find more information about application configuration at https://docs.
djangoproject.com/en/1.8/ref/applications/.
In order to register your signal receiver functions, when you are using the
receiver() decorator you just need to import the signals module of your
application inside the ready() method of the AppConfig class. This method is called
as soon as the application registry is fully populated. Any other initializations for
your application should be also included inside this method.

Create a new file inside the images application directory and name it apps.py.
Add the following code to it:
from django.apps import AppConfig
class ImagesConfig(AppConfig):
name = 'images'
verbose_name = 'Image bookmarks'
def ready(self):
# import signal handlers
import images.signals

[ 195 ]

Tracking User Actions

The name attribute defines the full Python path to the application. The verbose_name
attribute sets the human-readable name for this application. It's displayed in the
administration site. The ready() method is where we import the signals for this
application.
Now we need to tell Django where our application configuration resides. Edit the

__init__.py file located inside the images application directory and add the

following line to it:

default_app_config = 'images.apps.ImagesConfig'

Open your browser to view an image detail page and click on the like button. Go
back to the administration site and take a look at the total_likes attribute. You
should see that the total_likes attribute is updated like in the following example:

Now you can use the total_likes attribute to order images by popularity or
display the value anywhere, avoiding complex queries to calculate it. The following
query to get images ordered by their like count:
images_by_popularity = Image.objects.annotate(
likes=Count('users_like')).order_by('-likes')

Can now become like this:

images_by_popularity = Image.objects.order_by('-total_likes')

This results in a much less expensive SQL query. This is just an example about how
to use Django signals.
Use signals with caution, since they make difficult to know the control
flow. In many cases you can avoid using signals if you know which
receivers need to be notified.

[ 196 ]

Chapter 6

You will need to set initial counts to match the current status of the database. Open
the shell with the command python manage.py shell and run the following code:
from images.models import Image
for image in Image.objects.all():
image.total_likes = image.users_like.count()
image.save()

The likes count for each image is now updated.

Using Redis for storing item views

Redis is and advanced key-value database that allows you to save different types of
data and is extremely fast on I/O operations. Redis stores everything in memory, but
the data can be persisted by dumping the dataset to disk every once in a while or by
adding each command to a log. Redis is very versatile compared to other key-value
stores: It provides a set of powerful commands and supports diverse data structures
such as strings, hashes, lists, sets, ordered sets, and even bitmaps or HyperLogLogs.
While SQL is best suitable for schema-defined persistent data storage, Redis offers
numerous advantages when dealing with rapidly changing data, volatile storage,
or when a quick cache is needed. Let's see how Redis can be used for building new
functionality into our project.

Installing Redis
Download the latest Redis version from http://redis.io/download. Unzip
the tar.gz file, enter the redis directory and compile Redis using the make
command as follows:
cd redis-3.0.4
make

After installing it use the following shell command to initialize the Redis server:
src/redis-server

You should see an output that ends with the following lines:
# Server started, Redis version 3.0.4
* DB loaded from disk: 0.001 seconds
* The server is now ready to accept connections on port 6379

[ 197 ]

Tracking User Actions

By default, Redis runs on port 6379, but you can also specify a custom port using the
--port flag, for example redis-server --port 6655. When your server is ready,
you can open the Redis client in another shell using the following command:
src/redis-cli

You should see the Redis client shell like the following:
127.0.0.1:6379>

The Redis client allows you to execute Redis commands directly from the shell.
Let's try some commands. Enter the SET command in the Redis shell to store a
value in a key:
127.0.0.1:6379> SET name "Peter"
OK

The previous command creates a name key with the string value "Peter" in the
Redis database. The OK output indicates that the key has been saved successfully.
Then, retrieve the value using the GET command as follows:
127.0.0.1:6379> GET name
"Peter"

You can also check if a key exists by using the EXISTS command. This command
returns 1 if the given key exists, 0 otherwise:
127.0.0.1:6379> EXISTS name
(integer) 1

You can set the time for a key to expire using the EXPIRE command, which allows
you to set time to live in seconds. Another option is using the EXPIREAT command
that expects a Unix timestamp. Key expiration is useful to use Redis as a cache or
to store volatile data:
127.0.0.1:6379> GET name
"Peter"
127.0.0.1:6379> EXPIRE name 2
(integer) 1

Wait for 2 seconds and try to get the same key again:
127.0.0.1:6379> GET name
(nil)

[ 198 ]

Chapter 6

The (nil) response is a null response and means no key has been found. You can
also delete any key using the DEL command as follows:
127.0.0.1:6379> SET total 1
OK
127.0.0.1:6379> DEL total
(integer) 1
127.0.0.1:6379> GET total
(nil)

These are just basic commands for key operations. Redis includes a large set of
commands for other data types such as strings, hashes, sets, ordered sets, and so on.
You can take a look at all Redis commands at http://redis.io/commands and all
Redis data types at http://redis.io/topics/data-types.

Using Redis with Python

We need Python bindings for Redis. Install redis-py via pip using the command:
pip install redis==2.10.3

You can find the redis-py docs at http://redis-py.readthedocs.org/.

The redis-py offers two classes for interacting with Redis: StrictRedis and Redis.
Both offer the same functionality. The StrictRedis class attempts to adhere to the
official Redis command syntax. The Redis class extends StrictRedis overriding
some methods to provide backwards compatibility. We are going to use the
StrictRedis class since it follows the Redis command syntax. Open the Python
shell and execute the following code:
>>> import redis
>>> r = redis.StrictRedis(host='localhost', port=6379, db=0)

This code creates a connection with the Redis database. In Redis, databases are
identified by an integer index instead of a database name. By default, a client is
connected to database 0. The number of available Redis databases is set to 16,
but you can change this in the redis.conf file.
Now set a key using the Python shell:
>>> r.set('foo', 'bar')
True

[ 199 ]

Tracking User Actions

The command returns True indicating that the key has been successfully created.
Now you can retrieve the key using the get() command:
>>> r.get('foo')
'bar'

As you can see, the methods of StrictRedis follow the Redis command syntax.
Let's integrate Redis into our project. Edit the settings.py file of the bookmarks
project and add the following settings to it:
REDIS_HOST = 'localhost'
REDIS_PORT = 6379
REDIS_DB = 0

These are the settings for the Redis server and the database that we will use for
our project.

Storing item views in Redis

Let's store the total number of times an image has been viewed. If we did this using
the Django ORM, it would involve an SQL UPDATE statement every time an image
is displayed. Using Redis instead, we just need to increment a counter stored in
memory, resulting in much better performance.
Edit the views.py file of the images application and add the following code to it:
import redis
from django.conf import settings
# connect to redis
r = redis.StrictRedis(host=settings.REDIS_HOST,
port=settings.REDIS_PORT,
db=settings.REDIS_DB)

Here we establish the Redis connection in order to use it in our views. Edit the
image_detail view and make it look as follows:
def image_detail(request, id, slug):
image = get_object_or_404(Image, id=id, slug=slug)
# increment total image views by 1
total_views = r.incr('image:{}:views'.format(image.id))
return render(request,
'images/image/detail.html',
{'section': 'images',
'image': image,
'total_views': total_views})
[ 200 ]

Chapter 6

In this view, we use the INCR command that increments the value of a key by 1 and
sets the value to 0 before performing the operation if the key does not exist. The
incr() method returns the value of the key after performing the operation and we
store it in the total_views variable. We build the Redis key using a notation like
object-type:id:field (for example image:33:id).
The convention for naming Redis keys is to use a colon sign as separator
for creating namespaced keys. By doing so, the key names are specially
verbose and related keys share part of the same schema in their names.

Edit the image/detail.html template and add the following code to it after the
existing <span class="count"> element:
<span class="count">
<span class="total">{{ total_views }}</span>
view{{ total_views|pluralize }}
</span>

Now open an image detail page in your browser and load it several times. You will
see that each time the view is executed the total views displayed are incremented by
1. See the following example:

You have successfully integrated Redis into your project to store item counts.

[ 201 ]

Tracking User Actions

Storing a ranking in Redis

Let's built some more functionality with Redis. We are going to create a ranking
of the most viewed images in our platform. For building this ranking we will use
Redis sorted sets. A sorted set is a non-repeating collection of strings in which
every member is associated with a score. Items are sorted by their score.
Edit the views.py file of the images application and make the image_detail view
look as follows:
def image_detail(request, id, slug):
image = get_object_or_404(Image, id=id, slug=slug)
# increment total image views by 1
total_views = r.incr('image:{}:views'.format(image.id))
# increment image ranking by 1
r.zincrby('image_ranking', image.id, 1)
return render(request,
'images/image/detail.html',
{'section': 'images',
'image': image,
'total_views': total_views})

We use the zincrby() command to store image views in a sorted set with the key
image:ranking. We are storing the image id, and a score of 1 that will be added to
the total score of this element in the sorted set. This will allow us to keep track of all
image views globally and have a sorted set ordered by the total number of views.
Now create a new view to display the ranking of the most viewed images. Add the
following code to the views.py file:
@login_required
def image_ranking(request):
# get image ranking dictionary
image_ranking = r.zrange('image_ranking', 0, -1,
desc=True)[:10]
image_ranking_ids = [int(id) for id in image_ranking]
# get most viewed images
most_viewed = list(Image.objects.filter(
id__in=image_ranking_ids))
most_viewed.sort(key=lambda x: image_ranking_ids.index(x.id))
return render(request,
'images/image/ranking.html',
{'section': 'images',
'most_viewed': most_viewed})

[ 202 ]

Chapter 6

This is the image_ranking view. We use the zrange() command to obtain the
elements in the sorted set. This command expects a custom range by lowest and
highest score. By using 0 as lowest and -1 as highest score we are telling Redis
to return all elements in the sorted set. We also specify desc=True to retrieve the
elements ordered by descending score. Finally, we slice the results using [:10] to get
the first 10 elements with highest scores. We build a list of returned image IDs and we
store it in the image_ranking_ids variable as a list of integers. We retrieve the Image
objects for those IDs and force the query to be executed by using the list() function.
It is important to force the QuerySet execution because next we use the sort() list
method on it (at this point we need a list of objects instead of a queryset). We sort the
Image objects by their index of appearance in the image ranking. Now we can use the
most_viewed list in our template to display the 10 most viewed images.
Create a new image/ranking.html template file and add the following code to it:
{% extends "base.html" %}
{% block title %}Images ranking{% endblock %}
{% block content %}
<h1>Images ranking</h1>
<ol>
{% for image in most_viewed %}
<li>
<a href="{{ image.get_absolute_url }}">
{{ image.title }}
</a>
</li>
{% endfor %}
</ol>
{% endblock %}

The template is pretty straightforward, as we just iterate over the Image objects
contained in the most_viewed list.
Finally create an URL pattern for the new view. Edit the urls.py file of the images
application and add the following pattern to it:
url(r'^ranking/$', views.image_ranking, name='create'),

[ 203 ]

Tracking User Actions

Open http://127.0.0.1:8000/images/ranking/ in your browser. You should be

able to see an image ranking as follows:

Next steps with Redis

Redis is not a replacement for your SQL database but a fast in-memory storage that
is more suitable for certain tasks. Add it to your stack and use it when you really feel
it's needed. The following are some scenarios in which Redis suits pretty well:

Counting: As you have seen, it is very easy to manage counters with Redis.
You can use incr() and incrby() for counting stuff.

Storing latest items: You can add items to the start/end of a list using
lpush() and rpush(). Remove and return first/last element using lpop() /
rpop().You can trim the list length using ltrim() to maintain its length.

Queues: In addition to push and pop commands, Redis offers blocking

queue commands.

Caching: Using expire() and expireat() allows you to use Redis as a

cache. You can also find third-party Redis cache backends for Django.

Pub/Sub: Redis provides commands for subscribing/unsubscribing and

sending messages to channels.

Rankings and leaderboards: Redis sorted sets with scores make it very easy
to create leaderboards.

Real-time tracking: Redis fast I/O makes it perfect for real-time scenarios.

Summary
In this chapter, you have built a follower system and a user activity stream. You have
learned how Django signals work and you have integrated Redis into your project.
In the next chapter, you will learn how to build an on-line shop. You will create a
product catalog and build a shopping cart using sessions. You will also learn how
to launch asynchronous tasks with Celery.
[ 204 ]

Get more information Django By Example

Where to buy this book

You can buy Django By Example from the Packt Publishing website.
Alternatively, you can buy the book from Amazon, BN.com, Computer Manuals and most internet
book retailers.
Click here for ordering and shipping details.

www.PacktPub.com

Stay Connected: