Django 3 Web Development Cookbook - Fourth Edition

By : Aidas Bendoraitis, Jake Kronika

Django 3 Web Development Cookbook - Fourth Edition

By: Aidas Bendoraitis, Jake Kronika

Overview of this book

Django is a web framework for perfectionists with deadlines, designed to help you build manageable medium and large web projects in a short time span. This fourth edition of the Django Web Development Cookbook is updated with Django 3's latest features to guide you effectively through the development process. This Django book starts by helping you create a virtual environment and project structure for building Python web apps. You'll learn how to build models, views, forms, and templates for your web apps and then integrate JavaScript in your Django apps to add more features. As you advance, you'll create responsive multilingual websites, ready to be shared on social networks. The book will take you through uploading and processing images, rendering data in HTML5, PDF, and Excel, using and creating APIs, and navigating different data types in Django. You'll become well-versed in security best practices and caching techniques to enhance your website's security and speed. This edition not only helps you work with the PostgreSQL database but also the MySQL database. You'll also discover advanced recipes for using Django with Docker and Ansible in development, staging, and production environments. By the end of this book, you will have become proficient in using Django's powerful features and will be equipped to create robust websites.

Preface

Who this book is for

What this book covers

To get the most out of this book

Sections

Get in touch

Getting Started with Django 3.0

Introduction

Technical requirements

Working with a virtual environment

Creating a project file structure

Handling project dependencies with pip

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

Defining relative paths in the settings

Handling sensitive settings

Including external dependencies in your project

Setting up STATIC_URL dynamically

Setting UTF-8 as the default encoding for the MySQL configuration

Creating the Git ignore file

Deleting Python-compiled files

Respecting the import order in Python files

Creating an app configuration

Defining overwritable app settings

Working with Docker containers for Django, Gunicorn, Nginx, and PostgreSQL

Free Chapter

Models and Database Structure

Introduction

Technical requirements

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

Working with model translation tables

Avoiding circular dependencies

Adding database constraints

Using migrations

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

Forms and Views

Introduction

Technical requirements

Creating an app with CRUDL functions

Saving the author of a model instance

Uploading images

Creating a form layout with custom templates

Creating a form layout with django-crispy-forms

Working with formsets

Filtering object lists

Managing paginated lists

Composing class-based views

Providing Open Graph and Twitter Card data

Providing schema.org vocabularies

Generating PDF documents

Implementing a multilingual search with Haystack and Whoosh

Implementing a multilingual search with Elasticsearch DSL

Templates and JavaScript

Introduction

Technical requirements

Arranging the base.html template

Using Django Sekizai

Exposing settings in JavaScript

Using HTML5 data attributes

Providing responsive images

Implementing a continuous scrolling

Opening object details in a modal dialog

Implementing the Like widget

Uploading images via Ajax

Custom Template Filters and Tags

Introduction

Technical requirements

Following conventions for your own template filters and tags

Creating a template filter to show how many days have 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 template tags to modify request query parameters

Model Administration

Introduction

Technical requirements

Customizing columns on the change list page

Creating sortable inlines

Creating admin actions

Developing change list filters

Changing the app label of a third-party app

Creating a custom accounts app

Getting user Gravatars

Inserting a map into a change form

Security and Performance

Introduction

Technical requirements

Making forms secure from Cross-Site Request Forgery (CSRF)

Making requests secure with Content Security Policy (CSP)

Using django-admin-honeypot

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

Hierarchical Structures

Introduction

Technical requirements

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

Introduction

Technical requirements

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

Preparing paginated sitemaps for search engines

Creating filterable RSS feeds

Using Django REST framework to create an API

Bells and Whistles

Introduction

Technical requirements

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

Introduction

Technical requirements

Testing views with mock

Testing the user interface with Selenium

Testing APIs created using Django REST framework

Ensuring test coverage

Deployment

Introduction

Technical requirements

Releasing a reusable Django app

Deploying on Apache with mod_wsgi for the staging environment

Deploying on Apache with mod_wsgi for the production environment

Deploying on Nginx and Gunicorn for the staging environment

Deploying on Nginx and Gunicorn for the production environment

Maintenance

Introduction

Technical requirements

Creating and restoring MySQL database backups

Creating and restoring PostgreSQL database backups

Setting up cron jobs for regular tasks

Logging events for further introspection

Getting detailed error reporting via email

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Working with a virtual environment

It is very likely that you will develop multiple Django projects on your computer. Some modules, such as virtualenv, setuptools, wheel, or Ansible, can be installed once and then shared for all projects. Other modules, such as Django, third-party Python libraries, and Django apps, will need to be kept isolated from each other. The virtualenv tool is a utility that separates all of the Python projects and keeps them in their own realms. In this recipe, we will see how to use it.

Getting ready

To manage Python packages, you will need pip. If you are using Python 3.4+, then it will be included in your Python installation. If you are using another version of Python, you can install pip by executing the installation instructions at http://pip.readthedocs.org/en/stable/installing/. Let's upgrade the shared Python modules, pip, setuptools, and wheel:

$ sudo pip3 install --upgrade pip setuptools wheel

The virtual environment has been built into Python since version 3.3.

How to do it...

Once you have your prerequisites installed, create a directory where all your Django projects will be stored—for example, projects under your home directory. Go through the following steps after creating the directory:

Go to the newly created directory and create a virtual environment that uses the shared system site packages:

$ cd ~/projects
$ mkdir myproject_website
$ cd myproject_website
$ python3 -m venv env

To use your newly created virtual environment, you need to execute the activation script in your current shell. This can be done with the following command:

$ source env/bin/activate

Depending on the shell you are using, the source command may not be available. Another way to source a file is with the following command, which has the same result (note the space between the dot and env):

$ . env/bin/activate

You will see that the prompt of the command-line tool gets a prefix of the project name, as follows:

(env)$

To get out of the virtual environment, type the following command:

(env)$ deactivate

How it works...

When you create a virtual environment, a few specific directories (bin, include, and lib) are created in order to store a copy of the Python installation, and some shared Python paths are defined. When the virtual environment is activated, whatever you install with pip or easy_install will be put in and used by the site packages of the virtual environment, and not the global site packages of your Python installation.

To install the latest Django 3.0.x in your virtual environment, type the following command:

(env)$ pip install "Django~=3.0.0"

Django 3 Web Development Cookbook - Fourth Edition

By : Aidas Bendoraitis, Jake Kronika

Django 3 Web Development Cookbook - Fourth Edition

By: Aidas Bendoraitis, Jake Kronika

Overview of this book

Related Content you might be interested in

Current Title:

Django 3 Web Development Cookbook - Fourth Edition

Django 2 by Example

Django 4 By Example

Django 3 By Example,