Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Django 2 Web Development Cookbook

By : Jake Kronika, Aidas Bendoraitis

4 (6)

Django 2 Web Development Cookbook

4 (6)

By: Jake Kronika, Aidas Bendoraitis

Overview of this book

Django is a framework designed to balance rapid web development with high performance. It handles high levels of user traffic and interaction, integrates with a variety of databases, and collects and processes data in real time. This book follows a task-based approach to guide you through developing with the Django 2.1 framework, starting with setting up and configuring Docker containers and a virtual environment for your project. You'll learn how to write reusable pieces of code for your models and manage database changes. You'll work with forms and views to enter and list data, applying practical examples using templates and JavaScript together for the optimum user experience. This cookbook helps you to adjust the built-in Django administration to fit your needs and sharpen security and performance to make your web applications as robust, scalable, and dependable as possible. You'll also explore integration with Django CMS, the popular content management suite. In the final chapters, you'll learn programming and debugging tricks and discover how collecting data from different sources and providing it to others in various formats can be a breeze. By the end of the book, you'll learn how to test and deploy projects to a remote dedicated server and scale your application to meet user demands.

Preface

Preface

Who this book is for

What this book covers

To get the most out of this book

Sections

Get in touch

Free Chapter

Getting Started with Django 2.1

Getting Started with Django 2.1

Introduction

Working with a virtual environment

Creating a virtual environment project file structure

Working with Docker

Creating a Docker project file structure

Handling project dependencies with pip

Including external dependencies in your project

Configuring settings for development, testing, staging, and production environments

Defining relative paths in the settings

Creating and including local settings

Setting up STATIC_URL dynamically for Subversion users

Setting up STATIC_URL dynamically for Git users

Setting UTF-8 as the default encoding for MySQL configuration

Setting the Subversion ignore property

Creating the Git ignore file

Deleting Python-compiled files

Respecting the import order in Python files

Creating app configuration

Defining overwritable app settings

Database Structure and Modeling

Database Structure and Modeling

Introduction

Using model mixins

Creating a model mixin with URL-related methods

Creating a model mixin to handle creation and modification dates

Creating a model mixin to take care of meta tags

Creating a model mixin to handle generic relations

Handling multilingual fields

Enabling schema microdata enhancements

Using migrations

Switching from South migrations to Django migrations

Changing a foreign key to the many-to-many field

Forms and Views

Forms and Views

Introduction

Passing HttpRequest to a form

Utilizing the save method of the form

Uploading images

Creating a form layout with custom templates

Creating a form layout with django-crispy-forms

Filtering object lists

Managing paginated lists

Composing class-based views

Generating PDF documents

Implementing a multilingual search with Haystack and Whoosh

Templates and JavaScript

Templates and JavaScript

Introduction

Exposing settings in JavaScript

Arranging the base.html template

Using HTML5 data attributes

Providing responsive images

Opening object details in a modal dialog

Implementing a continuous scroll

Implementing the Like widget

Uploading images via Ajax

Customizing Template Filters and Tags

Customizing Template Filters and Tags

Introduction

Following conventions for your own template filters and tags

Creating a template filter to show how much time has passed since a post was published

Creating a template filter to extract the first media object

Creating a template filter to humanize URLs

Creating a template tag to include a template if it exists

Creating a template tag to load a QuerySet in a template

Creating a template tag to parse content as a template

Creating a template tag to modify request query parameters

Model Administration

Model Administration

Introduction

Customizing columns on the change list page

Creating admin actions

Developing change list filters

Customizing default admin settings

Inserting a map into a change form

Security and Performance

Security and Performance

Introduction

Making forms secure from Cross Site Request Forgery (CSRF)

Implementing password validation

Downloading authorized files

Adding a dynamic watermark to images

Authenticating with Auth0

Caching the method return value

Using Memcached to cache Django views

Using Redis to cache Django views

Django CMS

Django CMS

Introduction

Creating templates for Django CMS

Structuring the page menu

Converting an app to a CMS app

Attaching your own navigation

Writing your own CMS plugin

Adding new fields to the CMS page

Hierarchical Structures

Hierarchical Structures

Introduction

Creating hierarchical categories with django-mptt

Creating a category administration interface with django-mptt-admin

Rendering categories in a template with django-mptt

Using a single selection field to choose a category in forms with django-mptt

Using a checkbox list to choose multiple categories in forms with django-mptt

Creating hierarchical categories with django-treebeard

Creating a basic category administration interface with django-treebeard

Importing and Exporting Data

Importing and Exporting Data

Introduction

Importing data from a local CSV file

Importing data from a local Excel file

Importing data from an external JSON file

Importing data from an external XML file

Creating filterable RSS feeds

Using Tastypie to create an API

Using Django REST framework to create an API

Bells and Whistles

Bells and Whistles

Introduction

Using the Django shell

Using database query expressions

Monkey patching the slugify() function for better internationalization support

Toggling the Debug Toolbar

Using ThreadLocalMiddleware

Using signals to notify administrators about new entries

Checking for missing settings

Testing and Deployment

Testing and Deployment

Introduction

Testing views with mock

Testing APIs created using the Django REST framework

Releasing a reusable Django app

Getting detailed error reporting via email

Deploying on Apache with mod_wsgi

Setting up cron jobs for regular tasks

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

4 (6)

5 star

66.7%

4 star

0

3 star

16.7%

2 star

0

1 star

16.7%

Setting up STATIC_URL dynamically for Subversion users

If you set STATIC_URL to a static value, then each time you update a CSS file, a JavaScript file, or an image, you will need to clear the browser cache in order to see the changes. There is a trick to work around clearing the browser's cache. It is to have the revision number of the version control system shown in STATIC_URL. Whenever the code is updated, the visitor's browser will force the loading of all-new static files.

This recipe shows how to put a revision number in STATIC_URL for Subversion users.

Getting ready

Make sure that your project is under the Subversion version control and you have BASE_DIR defined in your settings, as shown in the Defining relative paths in the settings recipe.

Then, create the utils module in your Django project, and also create a file called misc.py there.

How to do it...

The procedure to put the revision number in the STATIC_URL settings consists of the following two steps:

Insert the following content:

# utils/misc.py
import subprocess


def get_media_svn_revision(absolute_path):
    repo_dir = absolute_path
    svn_revision = subprocess.Popen(
        "svn info | grep 'Revision' | awk '{print $2}'",
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE, 
        shell=True,
        cwd=repo_dir,
        universal_newlines=True)
    rev = svn_revision.communicate()[0].partition('\n')[0]
    return rev

Modify the settings.py file and add the following lines:

# settings.py
# ... somewhere after BASE_DIR definition ...
from utils.misc import get_media_svn_revision
STATIC_URL = f'/static/{get_media_svn_revision(BASE_DIR)}/'

How it works...

The get_media_svn_revision() function takes the absolute_path directory as a parameter and calls the svn information shell command in that directory to find out the current revision. We pass BASE_DIR to the function, as we are sure that it is under version control. Then, the revision is parsed, returned, and included in the STATIC_URL definition.

See also

The Setting up STATIC_URL dynamically for Git users recipe
The Setting the Subversion ignore property recipe

Search

Your notes and bookmarks