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

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

As noted earlier, you will be creating new features in the development environment, testing them in the testing environment, and then putting the website onto a staging server to let other people try the new features. Then, the website will be deployed to the production server for public access. Each of these environments can have specific settings, and you will learn how to organize them in this recipe.

Getting ready

In a Django project, we'll create settings for each environment: development, testing, staging, and production.

How to do it...

Follow these steps to configure the project settings:

In the myproject directory, create a settings Python module with the following files:

__init__.py makes the settings directory a Python module.
_base.py for shared settings
dev.py for development settings
test.py for testing settings
staging.py for staging settings
production.py for production settings

Copy the contents of settings.py, which was automatically created when you started a new Django project, to settings/_base.py. Then, delete settings.py.
Change the BASE_DIR in the settings/_base.py to point one level up. It should first look as follows:

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

After changing it, it should look like the following:

BASE_DIR = os.path.dirname(
    os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
)

If the settings of an environment are the same as the shared settings, then just
import everything from _base.py there, as follows:

# myproject/settings/production.py
from ._base import *

Apply the settings that you want to attach or overwrite for your specific environment in the other files—for example, the development environment settings should go to dev.py, as shown in the following code snippet:

# myproject/settings/dev.py
from ._base import *
EMAIL_BACKEND = "django.core.mail.backends.console.EmailBackend"

Modify the manage.py and myproject/wsgi.py files to use one of the environment settings by default by changing the following line:

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')

You should change this line to the following:

os.environ.setdefault('DJANGO_SETTINGS_MODULE',  'myproject.settings.production')

How it works...

By default, the Django management commands use the settings from myproject/settings.py. Using the method that is defined in this recipe, we can keep all of the required nonsensitive settings for all environments under version control in the config directory. On the other hand, the settings.py file itself would be ignored by version control and will only contain the settings that are necessary for the current development, testing, staging, or production environments.

For each environment, it is recommended that you set the DJANGO_SETTINGS_MODULE environment variable individually, either in PyCharm settings, the env/bin/activate script, or in .bash_profile.

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,