7 构建在线商店

在上一章中，你创建了关注系统和用户活动流。你还学习了Django信号是如何工作的，并在项目中集成了Redis，用于计算图片的浏览次数。在这一章中，你会学习如何构建一个基本的在线商店。你会创建商品目录（catalog），并用Django会话（session）实现购物车。你还会学习如果创建自定义上下文管理器，以及用Celery启动异步任务。

在这一章中，你会学习：

• 创建商品目录
• 使用Django会话创建购物车
• 管理客户订单
• 用Celery给客户发送异步通知

7.1 创建在线商店项目

我们将创建一个新的Django项目来构建在线商店。用户可以通过商品目录浏览，并把商品添加到购物车中。最后，客户结账并下单。本章将会覆盖在线商店以下几个功能：

• 创建商品目录模型，把它们添加到管理站点，并创建一个基础视图，用于显示目录
• 使用Django会话构建购物车系统，允许用户浏览网站时保留选定的商品
• 创建用于下单的表单和功能
• 用户下单后，发送一封异步确认邮件给用户

首先，我们为新项目创建虚机环境，并用以下命令激活虚拟环境：

mkdiv env
virtualenv env/myshop
source env/myshop/bin/activate

使用以下命令在虚拟环境中安装Django：

pip install Django

打开终端，执行以下命令，创建myshop项目，以及shop应用：

django-admin startproject myshop
cd myshop
django-admin startapp shop

编辑项目的settings.py文件，在INSTALLED_APPS设置中添加shop应用：

INSTALLED_APPS = (
    # ...
    'shop',
)

现在项目中的应用已经激活。让我们为商品目录定义模型。

7.1.1 创建商品目录模型

商店的目录由属于不同类别的商品组成。每个商品有名字，可选的描述，可选的图片，价格，以及有效的库存。编辑你刚创建的shop应用的models.py文件，添加以下代码：

from django.db import models

class Category(models.Model):
    name = models.CharField(max_length=200, db_index=True)
    slug = models.SlugField(max_length=200, db_index=True, unique=True)

    class Meta:
        ordering = ('name', )
        verbose_name = 'category'
        verbose_name_plural = 'categories'
    
    def __str__(self):
        return self.name

class Product(models.Model):
    category = models.ForeignKey(Category, related_name='products')
    name = models.CharField(max_length=200, db_index=True)
    slug = models.SlugField(max_length=200, db_index=True)
    image = models.ImageField(upload_to='products/%Y/%m/%d', blank=True)
    description = models.TextField(blank=True)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    stock = models.PositiveIntegerField()
    available = models.BooleanField(default=True)
    created = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ('name', )
        index_together = (('id', 'slug'), )

    def __str__(self):
        return self.name

这是我们的Category和Product模型。Category模型由name字段和唯一的slug字段组成。Product模型包括以下字段：

• category：这是指向Catetory模型的ForeignKey。这是一个多对一的关系：一个商品属于一个目录，而一个目录包括多个商品。
• name：这是商品的名称。
• slug：这是商品的别名，用于构建友好的URL。
• image：这是一张可选的商品图片。
• description：这是商品的可选描述。
• price：这是DecimalField。这个字段用Python的decimal.Decimal类型存储固定精度的十进制数。使用max_digits属性设置最大的位数（包括小数位），使用decimal_places属性设置小数位。
• stock：这个PositiveIntegerField存储商品的库存。
• available：这个布尔值表示商品是否有效。这允许我们在目录中启用或禁用商品。
• created：对象创建时存储该字段。
• updated：对象最后更新时存储该字段。

对于price字段，我们使用DecimalField代替FloatField，来避免四舍五入的问题。

总是使用DecimalField存储货币值。在Python内部，FloatField使用float类型，而DecimalField使用Decimal类型。使用Decimal类型可以避免float的四舍五入问题。

在Product模型的Meta类中，我们用index_together元选项为id和slug字段指定共同索引。这是因为我们计划通过id和slug来查询商品。两个字段共同索引可以提升用这两个字段查询的性能。

因为我们要在模型中处理图片，打开终端，用以下命令安装Pillow：

pip install Pillow

现在，执行以下命令，创建项目的初始数据库迁移：

python manage.py makemigrations

你会看到以下输出：

Migrations for 'shop':
  shop/migrations/0001_initial.py
    - Create model Category
    - Create model Product
    - Alter index_together for product (1 constraint(s))

执行以下命令同步数据：

python manage.py migrate

你会看到包括这一行的输出：

Applying shop.0001_initial... OK

现在数据库与模型已经同步了。

7.1.2 在管理站点注册目录模型

让我们把模型添加到管理站点，从而可以方便的管理目录和商品。编辑shop应用的admin.py文件，添加以下代码：

from django.contrib import admin
from .models import Category, Product

class CategoryAdmin(admin.ModelAdmin):
    list_display = ('name', 'slug')
    prepopulated_fields = {'slug': ('name', )}
admin.site.register(Category, CategoryAdmin)

class ProductAdmin(admin.ModelAdmin):
    list_display = ('name', 'slug', 'price', 'stock', 'available', 'created', 'updated')
    list_filter = ('available', 'created', 'updated')
    list_editable = ('price', 'stock', 'available')
    prepopulated_fields = {'slug': ('name', )}
admin.site.register(Product, ProductAdmin)

记住，我们使用prepopulated_fields属性指定用其它字段的值自动填充的字段。正如你前面看到的，这样可以很容易的生成别名。我们在ProductAdmin类中使用list_editable属性设置可以在管理站点的列表显示页面编辑的字段。这样可以一次编辑多行。list_editable属性中的所有字段都必须列在list_display属性中，因为只有显示的字段才可以编辑。

现在使用以下命令为网站创建超级用户：

python manage.py createsuperuser

执行python manage.py runserver命令启动开服务器。在浏览器中打开http://127.0.0.1:8000/admin/shop/product/add/，然后用刚创建的用户登录。使用管理界面添加一个新的目录和商品。管理页面的商品修改列表页面看起来是这样的：

7.1.3 构建目录视图

为了显示商品目录，我们需要创建一个视图列出所有商品，或者通过制定的目录过滤商品。编辑shop应用的views.py文件，添加以下代码：

from django.shortcuts import render, get_object_or_404
from .models import Category, Product

def product_list(request, category_slug=None):
    category = None
    categories = Category.objects.all()
    products = Product.objects.filter(available=True)
    if category_slug:
        category = get_object_or_404(Category, slug=category_slug)
        products = products.filter(category=category)
    return render(request, 
                  'shop/product/list.html', 
                  {'category': category, 
                  'categories': categories, 
                  'products': products})

我们用available=True过滤QuerySet，只检索有效地商品。我们用可选的category_slug参数，过滤指定目录的商品。

我们还需要一个查询和显示单个商品的视图。添加以下代码到views.py文件中：

def product_detail(request, id, slug):
    product = get_object_or_404(Product, id=id, slug=slug, available=True)
    return render(request,
                'shop/product/detail.html',
                {'product': product})

product_detail视图接收id和slug参数来查询Product实例。我们可以只使用ID获得该实例，因为ID是唯一性的属性。但是我们会在URL中包括别名，为商品构建搜索引擎友好的URL。

创建商品列表和详情视图后，我们需要为它们定义URL模式。在shop应用目录中创建urls.py文件，添加以下代码：

from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^$', views.product_list, name='product_list'),
    url(r'^(?P<category_slug>[-\w]+)/$', views.product_list, name='product_list_by_category'),
    url(r'^(?P<id>\d+)/(?P<slug>[-\w]+)/$', views.product_detail, name='product_detail'),
]

这些是商品目录的URL模式。我们为product_list视图定义了两个不同的URL模式：product_list模式不带任何参数调用product_list视图；product_list_by_category模式给视图提供category_slug参数，用于过滤指定目录的商品。我们添加了product_detail模式，传递id和slug参数给视图，用于检索特定商品。

编辑myshop项目的urls.py文件，如下所示：

from django.conf.urls import url, include
from django.contrib import admin

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^', include('shop.urls', namespace='shop')),
]

我们在项目的主URL模式中引入了shop应用的URL，并指定命名空间为shop。

现在编辑shop应用的models.py文件，导入reverse()函数，并为Category和Product模型添加get_absolute_url()方法，如下所示：

from django.core.urlresolvers import reverse
# ...
class Category(models.Model):
    # ...
    def get_absolute_url(self):
        return reverse('shop:product_list_by_category', args=[self.slug])
        
class Product(models.Model):
    # ...
    def get_absolute_url(self):
        return reverse('shop:product_detail', args=[self.id, self.slug])

你已经知道，get_absolute_url()是检索指定对象URL的约定成俗的方法。我们在这里使用之前在urls.py文件中定义的URL模式。

7.1.4 创建目录模板

现在我们需要为商品列表和详情视图创建模板。在shop应用目录中创建以下目录和文件结构：

templates/
    shop/
        base.html
        product/
            list.html
            detail.html

我们需要定义一个基础模板，并在商品列表和详情模板中继承它。编辑shop/base.html模板，添加以下代码：

{% load static %}
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <title>{% block title %}My shop{% endblock %}</title>
    <link href="{% static "css/base.css" %}" rel="stylesheet">
</head>
<body>
    <div id="header">
        <a href="/" class="logo">My shop</a>
    </div>
    <div id="subheader">
        <div class="cart">
            Your cart is empty.
        </div>
    </div>
    <div id="content">
        {% block content %}
        {% endblock %}
    </div>
</body>
</html>

这是商店的基础模板。为了引入模板使用的CSS样式表和图片，你需要拷贝本章实例中的静态文件，它们位于shop应用的static/目录。把它们拷贝到你的项目中的相同位置。

编辑shop/product/list.html模板，添加以下代码：

{% extends "shop/base.html" %}
{% load static %}

{% block title %}
    {% if category %}{{ category.name }}{% else %}Products{% endif %}
{% endblock title %}

{% block content %}
    <div id="sidebar">
        <h3>Categories</h3>
        <ul>
            <li {% if not category %}class="selected"{% endif %}>
                <a href="{% url "shop:product_list" %}">All</a>
            </li>
            {% for c in categories %}
                <li {% if category.slug == c.slug %}class="selected"{% endif %}>
                    <a href="{{ c.get_absolute_url }}">{{ c.name }}</a>
                </li>
            {% endfor %}
        </ul>
    </div>
    <div id="main" class="product-list">
        <h1>{% if catetory %}{{ category.name }}{% else %}Products{% endif %}</h1>
        {% for product in products %}
            <div class="item">
                <a href="{{ product.get_absolute_url }}">
                    ![]({% if product.image %}{{ product.image.url }}{% else %}{% static )
                </a>
                <a href="{{ product.get_absolute_url }}">{{ product.name }}</a><br/>
                ${{ product.price }}
            </div>
        {% endfor %}
    </div>
{% endblock content %}

这是商品列表目录。它继承自shop/base.html目录，用categories上下文变量在侧边栏显示所有目录，用products显示当前页商品。用同一个模板列出所有有效商品和通过目录过滤的所有商品。因为Product模型的image字段可以为空，所以如果商品没有图片时，我们需要提供一张默认图片。图片位于静态文件目录，相对路径为img/no_image.png。

因为我们用ImageField存储商品图片，所以需要开发服务器管理上传的图片文件。编辑myshop的settings.py文件，添加以下设置：

MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media/')

MEDIA_URL是管理用户上传的多媒体文件的基础URL。MEDIA_ROOT是这些文件的本地路径，我们在前面添加BASE_DIR变量，动态生成该路径。

要让Django管理通过开发服务器上传的多媒体文件，需要编辑myshop项目的urls.py文件，如下所示：

from django.conf import settings
from django.conf.urls.static import static

urlpatterns = [
    # ...
]
if settings.DEBUG:
    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

记住，我们只在开发阶段这么做。在生产环境，你不应该用Django管理静态文件。

使用管理站点添加一些商品，然后在浏览器中打开http://127.0.0.1:8000/。你会看到商品列表页面，如下图所示：

如果你用管理站点创建了一个商品，但是没有上传图片，则会显示默认图片：

让我们编辑商品详情模板。编辑shop/product/detail.html模板，添加以下代码：

{% extends "shop/base.html" %}
{% load static %}

{% block titie %}
    {% if category %}{{ category.title }}{% else %}Products{% endif %}
{% endblock titie %}

{% block content %}
    <div class="product-detail">
        ![]({% if product.image %}{{ product.image.url }}{% else %} {% static )
        <h1>{{ product.name }}</h1>
        <h2><a href="{{ product.category.get_absolute_url }}">{{ product.category }}</a></h2>
        <p class="price">${{ product.price }}</p>
        {{ product.description|linebreaks }}
    </div>
{% endblock content %}

我们在关联的目录对象上调用get_absolute_url()方法，来显示属于同一个目录的有效商品。现在在浏览器中打开http://127.0.0.1/8000/，点击某个商品查看详情页面，如下图所示：

我们现在已经创建了一个基本的商品目录。

7.2 构建购物车

创建商品目录之后，下一步是创建购物车，让用户选择他们希望购买的商品。当用户浏览网站时，购物车允许用户选择并暂时存储他们想要的商品，直到最后下单。购物车存储在会话中，所以在用户访问期间可以保存购物车里的商品。

我们将使用Django的会话框架保存购物车。购物车会一直保存在会话中，直到完成购物或者用户结账离开。我们还需要为购物车和它的商品创建额外的Django模型。

7.2.1 使用Django会话

Django提供了一个会话框架，支持匿名和用户会话。会话框架允许你为每个访问者存储任意数据。会话数据保存在服务端，cookies包括会话ID，除非你使用基于cookie的会话引擎。会话中间件负责发送和接收cookies。默认的会话引擎在数据库中存储会话数据，但是接下来你会看到，可以选择不同的会话引擎。要使用会话，你必须确保项目的MIDDLEWARE_CLASSES设置中包括django.contrib.sessions.middleware.SessionMiddleware。这个中间件负责管理会话，当你用startproject命令创建新项目时，会默认添加这个中间件。

会话中间件让当前会话在request对象中生效。你可以使用request.session访问当前会话，与使用Python字典类似的存储和检索会话数据。会话字典默认接收所有可以序列化为JSON的Python对象。你可以这样在会话中设置变量：

request.session['foo'] = 'bar'

查询一个会话的键：

request.session.get('foo')

删除存储在会话中的键：

del request.session['foo']

正如你所看到的，我们把request.session当做标准的Python字典。

当用户登录到网站时，他们的匿名会话丢失，并未认证用户创建新的会话。如果你在匿名会话中存储了数据，并想在用户登录后保留，你需要旧的会话数据拷贝到新的会话中。

7.2.2 会话设置

你可以使用几种设置为项目配置会话。其中最重要的是SESSION_ENGINE。该设置允许你设置会话存储的位置。默认情况下，Django使用django.contrib.sessions应用的Session模型，把会话存储在数据库中。

Django为存储会话数据提供了以下选项：

• Database sessions：会话数据存储在数据库中。这是默认的会话引擎。
• File-based sessions：会话数据存储在文件系统中。
• Cached sessions：会话数据存储在缓存后台。你可以使用CACHES设置指定婚车后台。在缓存系统中存储会话数据的性能最好。
• Cached database sessions：会话数据存储在连续写入的缓存（write-through cache）和数据库中。只有在缓存中没有数据时才读取数据库。
• Cookie-based sessions：会话数据存储于发送到浏览器的cookies。

使用cache-based会话引擎有更好的性能。Django支持Memcached，以及其它支持Redis的第三方缓存后台和缓存系统。

你可以只是用其它设置自定义会话。以下是一些重要的会话相关设置：

• SESSION_COOKIE_AGE：这是会话cookies的持续时间（单位是秒）。默认值是1209600（两周）。
• SESSION_COOKIE_DOMAIN：会话cookies使用的域。设置为.mydomain.com可以启用跨域cookies。
• SESSION_EXPIRE_AT_BROWSER_CLOSE：当浏览器关闭后，表示会话是否过期的一个布尔值。
• SESSION_SAVE_EVERY_REQUEST：如果这个布尔值为True，则会在每次请求时把会话保存到数据库中。会话的过期时间也会每次更新。

你可以在这里查看所有会话设置。

7.2.3 会话过期

你可以使用SESSTION_EXPIRE_AT_BROWSER_CLOSE设置选择browser-length会话或者持久会话。默认值为False，强制把会话的有效期设置为SESSION_COOKIE_AGE的值。如果设置SESSTION_EXPIRE_AT_BROWSER_CLOSE为True，当用户关闭浏览器后，会话会过期，而SESSION_COOKIE_AGE不会起任何作用。

你可以使用request.session的set_expiry()方法覆写当前会话的有效期。

7.2.4 在会话中存储购物车

我们需要创建一个简单的可以序列号为JSON的结构体，在会话中存储购物车商品。购物车的每一件商品必须包括以下数据：

• Product实例的id
• 选择该商品的数量
• 该商品的单价

因为商品价格可能变化，所以当商品添加到购物车时，我们把商品的价格和商品本身同事存入购物车。这样的话，即使之后商品的价格发生变化，用户看到的还是添加到购物车时的价格。

现在你需要创建购物车，并与会话关联起来。购物车必须这样工作：

• 需要购物车时，我们检查是否设置了自定义会话键。如果会话中没有设置购物车，则创建一个新的购物车，并保存在购物车会话键中。
• 对于连续的请求，我们执行相同的检查，并从购物车会话键中取出购物车的商品。我们从会话中检索购物车商品，并从数据库中检索它们关联的Product对象。

编辑项目settings.py文件，添加以下设置：

CART_SESSION_ID = 'cart'

我们在用户会话用这个键存储购物车。因为每个访客的Django会话是独立的，所以我们可以为所有会话使用同一个购物车会话键。

让我们创建一个管理购物车的应用。打开终端，执行以下命令创建一个新应用：

python manage.py startapp cart

然后编辑项目的settings.py文件，把cart添加到INSTALLED_APPS：

INSTALLED_APPS = (
    # ...
    'cart',
)

在cart应用目录中创建cart.py文件，并添加以下代码：

from decimal import Decimal
from django.conf import settings
from shop.models import Product

class Cart:
    def __init__(self, request):
        self.session = request.session
        cart = self.session.get(settings.CART_SESSION_ID)
        if not cart:
            # save an empty cart in the session
            cart = self.session[settings.CART_SESSION_ID] = {}
        self.cart = cart

这个Cart类用于管理购物车。我们要求用request对象初始化购物车。我们用self.session = request.session存储当前会话，以便在Cart类的其它方法中可以访问。首先，我们用self.session.get(settings.CART_SESSION_ID)尝试从当前会话中获得购物车。如果当前会话中没有购物车，通过在会话中设置一个空字典来设置一个空的购物车。我们希望购物车字典用商品ID做为键，一个带数量和价格的字典作为值。这样可以保证一个商品不会在购物车中添加多次；同时还可以简化访问购物车的数据。

让我们创建一个方法，用于向购物车中添加商品，或者更新商品数量。在Cart类中添加add()和save()方法：

def add(self, product, quantity=1, update_quantity=False):
    product_id = str(product.id)
    if product_id not in self.cart:
        self.cart[product_id] = {
            'quantity': 0,
            'price': str(product.price)
        }
    if update_quantity:
        self.cart[product_id]['quantity'] = quantity
    else:
        self.cart[product_id]['quantity'] += quantity
    self.save()

def save(self):
    # update the session cart
    self.session[settings.CART_SESSION_ID] = self.cart
    # mark the sessions as "modified" to make sure it is saved
    self.session.modified = True

add()方法接收以下参数：

• product：在购物车中添加或更新的Product实例。
• quantity：可选的商品数量。默认为1.
• update_quantity：一个布尔值，表示使用给定的数量更新数量（True），或者把新数量加到已有的数量上（False）。

我们用商品id作为购物车内容字典的键。因为Django使用JSON序列号会话数据，而JSON只允许字符串类型的键名，所以我们把商品id转换为字符串。商品id是键，保存的值是带商品quantity和price的字典。为了序列号，我们把商品价格转换为字符串。最后，我们调用save()方法在会话中保存购物车。

save()方法在会话中保存购物车的所有修改，并使用session.modified = True标记会话已修改。这告诉Django，会话已经修改，需要保存。

我们还需要一个方法从购物车中移除商品。在Cart类中添加以下方法：

def remove(self, product):
    product_id = str(product.id)
    if product_id in self.cart:
        del self.cart[product_id]
        self.save()

remove()方法从购物车字典中移除指定商品，并调用save()方法更新会话中的购物车。

我们将需要迭代购物车中的商品，并访问关联的Product实例。因为需要在类中定义__iter__()方法。在Cart类中添加以下方法：

def __iter__(self):
    product_ids = self.cart.keys()
    # get the product objects and add them to the cart
    products = Product.objects.filter(id__in=product_ids)
    for product in products:
        self.cart[str(product.id)]['product'] = product

    for item in self.cart.values():
        item['price'] = Decimal(item['price'])
        item['total_price'] = item['price'] * item['quantity']
        yield item

在__iter__()方法中，我们检索购物车中的Product实例，并把它们包括在购物车商品中。最后，我们迭代购物车商品，把price转换回Decimal类型，并为每一项添加total_price属性。现在我们可以在购物车中方便的迭代商品。

我们还需要返回购物车中商品总数量。当在一个对象上调用len()函数时，Python会调用__len__()方法返回对象的长度。我们定义一个__len__()方法，返回购物车中所有商品的总数量。在Cart类中添加__len__()方法：

def __len__(self):
    return sum(item['quantity'] for item in self.cart.values())

我们返回购物车中所有商品数量的总和。

添加以下方法，计算购物车中所有商品的总价：

def get_total_price(self):
    return sum(Decimal(item['price']) * item['quantity'] for item in self.cart.values())

最后，添加一个清空购物车会话的方法：

def clear(self):
    del self.session[settings.CART_SESSION_ID]
    self.session.modified = True

我们的Cart类已经可以管理购物车了。

7.2.5 创建购物车视图

现在我们已经创建了Cart类来管理购物车，我们需要创建添加，更新和移除购物车商品的视图。我们需要创建以下视图：

• 一个添加或更新购物车商品的视图，可以处理当前和新的数量
• 一个从购物车中移除商品的视图
• 一个显示购物车商品和总数的视图

7.2.5.1 添加商品到购物车

要添加商品到购物车中，我们需要一个用户可以选择数量的表单。在cart应用目录中创建forms.py文件，并添加以下代码：

from django import forms

PRODUCT_QUANTITY_CHOICES = [(i, str(i)) for i in range(1, 21)]

class CartAddProductForm(forms.Form):
    quantity = forms.TypedChoiceField(choices=PRODUCT_QUANTITY_CHOICES, coerce=int)
    update = forms.BooleanField(required=False, initial=False, widget=forms.HiddenInput)

我们用这个表单向购物车中添加商品。CartAddProductForm类包括以下两个字段：

• quantity：允许用户选择1-20之间的数量。我们使用带coerce=int的TypedChoiceField字段把输入的值转换为整数。
• update：允许你指定把数量累加到购物车中已存在的商品数量上（False），还是用给定的数量更新已存在商品数量（True）。我们为该字段使用HiddenInput组件，因为我们不想让用户看见它。

让我们创建向购物车添加商品的视图。编辑cart应用的views.py文件，并添加以下代码：

from django.shortcuts import render, redirect, get_object_or_404
from django.views.decorators.http import require_POST
from shop.models import Product
from .cart import Cart
from .forms import CartAddProductForm

@require_POST
def cart_add(request, product_id):
    cart = Cart(request)
    product = get_object_or_404(Product, id=product_id)
    form = CartAddProductForm(request.POST)
    if form.is_valid():
        cd = form.cleaned_data
        cart.add(product=product, quantity=cd['quantity'], update_quantity=cd['update'])
    return redirect('cart:cart_detail')

这个视图用于向购物车中添加商品或者更新已有商品的数量。因为这个视图会修改数据，所以我们只允许POST请求。视图接收商品ID作为参数。我们用给定的商品ID检索Product实例，并验证CartAddProductForm。如果表单有效，则添加或更新购物车中的商品。该视图重定向到cart_detail URL，它会显示购物车中的内容。之后我们会创建cart_detail视图。

我们还需要一个从购物车中移除商品的视图。在cart应用的views.py文件中添加以下代码：

def cart_remove(request, product_id):
    cart = Cart(request)
    product = get_object_or_404(Product, id=product.id)
    cart.remove(product)
    return redirect('cart:cart_detail')

cart_remove视图接收商品ID作为参数。我们用给定的商品ID检索Product实例，并从购物车中移除该商品。接着我们重定向到cart_detail URL。

最后，我们需要一个显示购物车和其中的商品的视图。在views.py文件中添加以下代码：

def cart_detail(request):
    cart = Cart(request)
    return render(request, 'cart/detail.html', {'cart': cart})

cart_detail视图获得当前购物车，并显示它。

我们已经创建了以下视图：向购物车中添加商品，更新数量，从购物车中移除商品，已经显示购物车。让我们为这些视图添加URL。在cart应用目录中创建urls.py文件，并添加以下URL模式：

from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^$', views.cart_detail, name='cart_detail'),
    url(r'^add/(?P<product_id>\d+)/$', views.cart_add, name='cart_add'),
    url(r'^remove/(?P<product_id>\d+)/$', views.cart_remove, name='cart_remove'),
]

最后，编辑myshop项目的主urls.py文件，引入cart的URL模式：

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^cart/', include('cart.urls', namespace='cart')),
    url(r'^', include('shop.urls', namespace='shop')),
]

确保在shop.urls模式之前引入这个URL模式，因为它比前者更有限定性。

7.2.5.2 构建显示购物车的模板

cart_add和cart_remove视图不需要渲染任何模板，但是我们需要为cart_detail视图创建显示购物车和总数量的模板。

在cart应用目录中创建以下文件结构：

templates/
    cart/
        detail.html

编辑cart/detail.html目录，并添加以下代码：

{% extends "shop/base.html" %}
{% load static %}

{% block title %}
    Your shopping cart
{% endblock title %}

{% block content %}
    <h1>Your shopping cart</h1>
    <table class="cart">
        <thead>
            <tr>
                <th>Image</th>
                <th>Product</th>
                <th>Quantity</th>
                <th>Remove</th>
                <th>Unit price</th>
                <th>Price</th>
            </tr>
        </thead>
        <tbody>
            {% for item in cart %}
                {% with product=item.product %}
                    <tr>
                        <td>
                            <a href="{{ prouct.get_absolute_url }}">
                                ![]({% if product.image %}{{ product.image.url}}{% else %}{% static )
                            </a>
                        </td>
                        <td>{{ product.name }}</td>
                        <td>{{ item.quantity }}</td>
                        <td><a href="{% url "cart:cart_remove" product.id %}">Remove</a></td>
                        <td class="num">${{ item.price }}</td>
                        <td class="num">${{ item.total_price }}</td>
                    </tr>
                {% endwith %}
            {% endfor %}
            <tr class="total">
                <td>Total</td>
                <td colspan="4"></td>
                <td class="num">${{ cart.get_total_price }}</td>
            </tr>
        </tbody>
    </table>
    <p class="text-right">
        <a href="{% url "shop:product_list" %}" class="button light">Continue shopping</a>
        <a href="#" class="button">Checkout</a>
    </p>
{% endblock content %}

这个模板用于显示购物车的内容。它包括一个当前购物车中商品的表格。用户通过提交表单到cart_add视图，来修改选中商品的数量。我们为每个商品提供了Remove链接，用户可以从购物车移除商品。

7.2.5.3 添加商品到购物车

现在我们需要在商品详情页面添加Add to cart按钮。编辑shop应用的views.py文件，修改product_detail视图，如下所示：

from cart.forms import CartAddProductForm

def product_detail(request, id, slug):
    product = get_object_or_404(Product, id=id, slug=slug, available=True)
    cart_product_form = CartAddProductForm()
    return render(request,
                'shop/product/detail.html',
                {'product': product,
                'cart_product_form': cart_product_form})

编辑shop应用的shop/product/detail.html模板，在商品价格之后添加表单，如下所示：

<p class="price">${{ product.price }}</p>
<form action="{% url "cart:cart_add" product.id %}" method="post">
    {{ cart_product_form }}
    {% csrf_token %}
    <input type="submit" value="Add to cart">
</form>

使用python manage.py runserver命令启动开发服务器。在浏览器中打开127.0.0.1/8000/，然后导航到商品详情页面。它现在包括一个选择数量的表单，如下图所示：

选择数量，然后点击Add to cart按钮。表单通过POST提交到cart_add视图。该视图把商品添加到会话中的购物车，包括当前价格和选择的数量。然后重定义到购物车详情页面，如下图所示：

7.2.5.4 在购物车中更新商品数量

当用户查看购物车时，他们可能希望在下单前修改商品数量。我们接下来实现在购物车详情页面修改数量。

编辑cart应用的views.py文件，如下修改cart_detail视图：

def cart_detail(request):
    cart = Cart(request)
    for item in cart:
        item['update_quantity_form'] = CartAddProductForm(
            initial={'quantity': item['quantity'], 'update': True})
    return render(request, 'cart/detail.html', {'cart': cart})

我们为购物车中的每个商品创建了一个CartAddProductForm实例，允许用户修改商品数量。我们用当前商品数量初始化表单，并设置update字段为True。因此，当我们把表单提交到cart_add视图时，会用新数量了代替当前数量。

现在编辑cart应用的cart/detail.html模板，找到这一行代码：

<td>{{ item.quantity }}</td>

把这行代码替换为：

<td>
    <form action="{% url "cart:cart_add" product.id %}" method="post">
        {{ item.update_quantity_form.quantity }}
        {{ item.update_quantity_form.update }}
        <input type="submit" value="Update">
        {% csrf_token %}
    </form>
</td>

在浏览器中打开http://127.0.0.1:8000/cart/。你会看到购物车中每个商品都有一个修改数量的表单，如下图所示：

修改商品数量，然后点击Update按钮，测试一下新功能。

7.2.6 为当前购物车创建上下文处理器

你可能已经注意到了，我们的网站头部还是显示Your cart is emtpy。当我们开始向购物车中添加商品，我们将看到它替换成购物车中商品的总数量和总价钱。因为这是需要在所有页面显示，所以我们将创建一个上下文处理器（context processor），将当前购物车包含在请求上下文中，而不管已经处理的视图。

7.2.6.1 上下文处理器

上下文处理器是一个Python函数，它将request对象作为参数，并返回一个添加到请求上下文中的字典。当你需要让某些东西在所有模板都可用时，它会派上用场。

默认情况下，当你使用startproject命令创建新项目时，项目中会包括以下模板上下文处理器，它们位于TEMPLATES设置的context_processors选项中：

• django.template.context_processors.debug：在上下文中设置debug布尔值和sql_queries变量，表示请求中执行的SQL查询列表
• django.template.context_processors.request：在上下文中设置request变量
• django.contrib.auth.context_processors.auth：在请求中设置user变量
• django.contrib.messages.context_processors.messages：在上下文中设置message变量，其中包括所有已经用消息框架发送的消息。

Django还启用了django.template.context_processors.csrf来避免跨站点请求伪造攻击。这个上下文处理器不在设置中，但它总是启用的，并且为了安全不能关闭。

你可以在这里查看所有内置的上下文处理器列表。

7.2.6.2 在请求上下文中设置购物车

让我们创建一个上下文处理器，把当前购物车添加到模板的请求上下文中。我们可以在所有模板中访问购物车。

在cart应用目录中创建context_processors.py文件。上下文处理器可以位于代码的任何地方，但是在这里创建他们将保持代码组织良好。在文件中添加以下代码：

from .cart import Cart

def cart(request):
    return {'cart': Cart(request)}

正如你所看到的，上下文处理器是一个函数，它将request对象作为参数，并返回一个对象的字典，这些对象可用于所有使用RequestContext渲染的模板。在我们的上下文处理器中，我们用request对象实例化购物车，模板可以通过cart变量名访问它。

编辑项目的settings.py文件，在TEMPLATES设置的context_processors选项中添加cart.context_processors.cart，如下所示：

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
                'cart.context_processors.cart',
            ],
        },
    },
]

每次使用RequestContext渲染模板时，会执行你的上下文处理器。cart变量会设置在模板的上下文中。

上下文处理器会在所有使用RequestContext的请求中执行。如果你想访问数据库的话，可能希望创建一个自定义模板标签来代替上下文处理器。

现在编辑shop应用的shop/base.html模板，找到以下代码：

<div class="cart">
    Your cart is empty.
</div>

用下面的代码替换上面的代码：

<div class="cart">
    {% with total_items=cart|length %}
        {% if cart|length > 0 %}
            Your cart:
            <a href="{% url "cart:cart_detail" %}">
                {{ total_items }} item{{ total_items|pluralize }},
                ${{ cart.get_total_price }}
            </a>
        {% else %}
            Your cart is empty.
        {% endif %}
    {% endwith %}
</div>

使用python manage.py runserver重启开发服务器。在浏览器中打开http://127.0.0.1:8000/，并添加一些商品到购物车中。在网站头部，你会看到当前购物车总数量和总价钱，如下所示：

7.3 注册用户订单

当购物车结账后，你需要在数据库中保存订单。订单包括用户信息和他们购买的商品。

使用以下命令创建一个新应用，来管理用户订单：

python manage.py startapp orders

编辑项目的settings.py文件，在INSTALLED_APPS设置中添加orders：

INSTALLED_APPS = [
    # ...
    'orders',
]

你已经激活了新应用。

7.3.1 创建订单模型

你需要创建一个模型存储订单详情，以及一个模型存储购买的商品，包括价格和数量。编辑orders应用的models.py文件，添加以下代码：

from django.db import models
from shop.models import Product

class Order(models.Model):
    first_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)
    email = models.EmailField()
    address = models.CharField(max_length=250)
    postal_code = models.CharField(max_length=20)
    city = models.CharField(max_length=100)
    created = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)
    paid = models.BooleanField(default=False)

    class Meta:
        ordering = ('-created', )

    def __str__(self):
        return 'Order {}'.format(self.id)

    def get_total_cost(self):
        return sum(item.get_cost() for item in self.items.all())

class OrderItem(models.Model):
    order = models.ForeignKey(Order, related_name='items')
    product = models.ForeignKey(Product, related_name='order_items')
    price = models.DecimalField(max_digits=10, decimal_places=2)
    quantity = models.PositiveIntegerField(default=1)

    def __str__(self):
        return '{}'.format(self.id)

    def get_cost(self):
        return self.price * self.quantity

Order模型包括几个用户信息字段和一个默认值为False的paid布尔字段。之后，我们将用这个字段区分已支付和未支付的订单。我们还定义了get_total_cost()方法，获得这个订单中购买商品的总价钱。

OrderItem模型允许我们存储商品，数量和每个商品的支付价格。我们用get_cost()返回商品价钱。

运行以下命令，为orders应用创建初始数据库迁移：

python manage.py makemigrations

你会看到以下输出：

Migrations for 'orders':
  orders/migrations/0001_initial.py
    - Create model Order
    - Create model OrderItem

运行以下命令让新的迁移生效：

python manage.py migrate

现在你的订单模型已经同步到数据库中。

7.3.2 在管理站点引入订单模型

让我们在管理站点添加订单模型。编辑orders应用的admin.py文件，添加以下代码：

from django.contrib import admin
from .models import Order, OrderItem

class OrderItemInline(admin.TabularInline):
    model = OrderItem
    raw_id_fields = ['product']

class OrderAdmin(admin.ModelAdmin):
    list_display = ['id', 'first_name', 'last_name', 'email', 
        'address', 'postal_code', 'city', 'paid', 'created', 'updated']
    list_filter = ['paid', 'created', 'updated']
    inlines = [OrderItemInline]

admin.site.register(Order, OrderAdmin)

我们为OrderItem模型使用ModeInline，把它作为内联模型引入OrderAdmin类。内联可以包含一个模型，与父模型在同一个编辑页面显示。

使用python manage.py runserver命令启动开发服务器，然后在浏览器中打开http:127.0.0.1/8000/admin/order/add/。你会看到以下界面：

7.3.3 创建用户订单

当用户最终下单时，我们需要使用刚创建的订单模型来保存购物车中的商品。创建一个新订单的工作流程是这样的：

1. 向用户显示一个填写数据的订单表单。
2. 用用户输入的数据创建一个新的Order实例，然后为购物车中的每件商品创建关联的OrderItem实例。
3. 清空购物车中所有内容，然后重定向到成功页面。

首先，我们需要一个输入订单详情的表单。在orders应用目录中创建forms.py文件，并添加以下代码：

from django import forms
from .models import Order

class OrderCreateForm(forms.ModelForm):
    class Meta:
        model = Order
        fields = ['first_name', 'last_name', 'email', 
            'address', 'postal_code', 'city']

这是我们用于创建新Order对象的表单。现在我们需要一个视图处理表单和创建新表单。编辑orders应用的views.py文件，并添加以下代码：

from django.shortcuts import render
from .models import OrderItem
from .forms import OrderCreateForm
from cart.cart import Cart

def order_create(request):
    cart = Cart(request)
    if request.method == 'POST':
        form = OrderCreateForm(request.POST)
        if form.is_valid():
            order = form.save()
            for item in cart:
                OrderItem.objects.create(order=order, product=item['product'], 
                    price=item['price'], quantity=item['quantity'])
            # clear the cart
            cart.clear()
            return render(request, 'orders/order/created.html', {'order': order})
    else:
        form = OrderCreateForm()
    return render(request, 'orders/order/create.html', {'cart': cart, 'form': form})

在order_create视图中，我们用cart = Cart(request)从会话中获得当前购物车。根据请求的方法，我们执行以下任务：

• GET请求：实例化OrderCreateForm表单，并渲染orders/order/create.html模板。
• POST请求：验证提交的数据。如果数据有效，则使用order = form.save()创建一个新的Order实例。然后我们会将它保存到数据库中，并存储在order变量中。创建order之后，我们会迭代购物车中的商品，并为每个商品创建OrderItem。最后，我们会清空购物车的内容。

现在，在orders应用目录中创建urls.py文件，并添加以下代码：

from django.conf.urls import url
from .import views

urlpatterns = [
    url(r'^create/$', views.order_create, name='order_create'),
]

这是order_create视图的URL模式。编辑myshop项目的urls.py文件，并引入以下模式。记住，把它放在shop.urls模式之前：

url(r'^orders/', include('orders.urls', namespace='orders')),

编辑cart应用的cart/detail.html模板，找到这行代码：

<a href="#" class="button">Checkout</a>

把这样代码替换为以下代码：

<a href="{% url "orders:order_create" %}" class="button">Checkout</a>

现在用户可以从购物车详情页面导航到订单表单。我们还需要为下单定义模板。在orders应用目录中创建以下文件结构：

templates/
    orders/
        order/
            create.html
            created.html

编辑orders/order/create.html模板，并添加以下代码：

{% extends "shop/base.html" %}

{% block title %}
    Checkout
{% endblock title %}

{% block content %}
    <h1>Checkout</h1>

    <div class="order-info">
        <h3>Your order</h3>
        <ul>
            {% for item in cart %}
                <li>
                    {{ item.quantity }}x {{ item.product.name }}
                    <span>${{ item.total_price }}</span>
                </li>
            {% endfor %}
        </ul>
        <p>Total: ${{ cart.get_total_price }}</p>
    </div>

    <form action="." method="post" class="order-form">
        {{ form.as_p }}
        <p><input type="submit" value="Place order"></p>
        {% csrf_token %}
    </form>
{% endblock content %}

这个模板显示购物车中的商品，包括总数量和下单的表单。

编辑orders/order/created.html模板，并添加以下代码：

{% extends "shop/base.html" %}

{% block title %}
    Thank you
{% endblock title %}

{% block content %}
    <h1>Thank you</h1>
    <p>Your order has been successfully completed. 
        Your order number is <stong>{{ order.id }}</stong>
    </p>
{% endblock content %}

成功创建订单后，我们渲染这个模板。启动开发服务器，并在浏览器中打开http://127.0.0.1:8000/。在购物车中添加一些商品，然后跳转到结账界面。如下图所示：

用有效的数据填写表单，然后点击Place order按钮。订单会被创建，你将看到成功页面，如下图所示：

7.4 使用Celery启动异步任务

你在视图中执行的所有操作都会影响响应时间。在很多场景中，你可能希望尽快给用户返回响应，并让服务器执行一些异步处理。对于费时处理，或者失败后可能需要重试策略的处理尤其重要。例如，一个视频分享平台允许用户上传视频，但转码上传的视频需要很长的时间。网站可能给用户返回一个响应，告诉用户马上开始转码，然后开始异步转码。另一个例子是给用户发送邮件。如果网站在视图中发送邮件通知，SMTP连接可能失败，或者减慢响应时间。启动异步任务避免阻塞操作是必不可少的。

Celery是一个可以处理大量消息的分布式任务队列。它既可以实时处理，也支持任务调度。使用Celery不仅可以很容易的创建异步任务，还可以尽快执行任务，但也可以在一个指定时间执行任务。

你可以在这里查看Celery文档。

7.4.1 安装Celery

让我们安装Celery，并在项目中集成它。使用以下pip命令安装Celery：

pip install celery

Celery必须有一个消息代理（message broker）处理外部请求。代理负责发送消息给Celery的worker，worker收到消息后处理任务。让我们安装一个消息代理。

7.4.2 安装RabbitMQ

Celery有几个消息代理可供选择，包括键值对存储（比如Redis），或者一个实际的消息系统（比如RabbitMQ）。我们将用RabbitMQ配置Celery，因为它是Celery的推荐消息worker。

如果你使用的是Linux，可以在终端执行以下命令安装RabbitMQ：

apt-get install rabbitmq

如果你需要在Max OS X或者Windows上安装RabbitMQ，你可以在这里找到独立的版本。

安装后，在终端执行以下命令启动RabbitMQ：

rabbitmq-server

你会看到以这一行结尾的输出：

Starting broker... completed with 10 plugins.

7.4.3 在项目中添加Celery

你需要为Celery实例提供一个配置。在myshop中创建celery.py文件，该文件会包括项目的Celery配置，并添加以下代码：

import os
from celery import Celery
from django.conf import settings

# set the default Django settings module for the 'celery' program.
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myshop.settings')

app = Celery('myshop')

app.config_from_object('django.conf:settings')
app.autodiscover_tasks(lambda: settings.INSTALLED_APPS)

在这段代码中，我们为Celery命令行程序设置DJANGO_SETINGS_MODULE变量。然后用app = Celery('myshop.)创建了一个应用实例。我们用config_from_object()方法从项目设置中加载所有自定义设置。最后我们告诉Celery，为INSTALLED_APPS设置中列出的应用自动查找异步任务。Celery会在每个应用目录中查找tasks.py文件，并加载其中定义的异步任务。

你需要在项目的__init__.py文件中导入celery模块，确保Django启动时会加载Celery。编辑myshop/__init__.py文件，并添加以下代码：

from .celery import app as celery_app

现在你可以开始为应用编写异步任务了。

CELERY_ALWAYS_EAGER设置允许你以同步方式在本地执行任务，而不是将其发送到队列。这对于运行单元测试，或者在不运行Celery的情况下，运行本地环境中的项目时非常有用。

7.4.4 在应用中添加异步任务

当用户下单后，我们将创建一个异步任务，给用户发送一封邮件通知。

一般的做法是在应用目录的tasks模块中包括应用的异步任务。在orders应用目录中创建tasks.py文件。Celery会在这里查找异步任务。在其中添加以下代码：

from celery import task
from django.core.mail import send_mail
from .models import Order

@task
def order_created(order_id):
    order = Order.objects.get(id=order_id)
    subject = 'Order nr. {}'.format(order.id)
    message = 'Dear {},\n\nYou have successfully placed an order.\
        Your order id is {}.'.format(order.first_name, order.id)
    mail_sent = send_mail(subject, message, 'admin@myshop.com', [order.email])
    return mail_sent

我们使用task装饰器定义了order_created任务。正如你所看到的，Celery任务就是一个用task装饰的Python函数。我们的task函数接收order_id作为参数。推荐只传递ID给任务函数，并在任务执行时查询对象。我们用Django提供的send_mail()函数，当用户下单后发送邮件通知。如果你不想配置邮件选项，你可以在项目的settings.py文件中添加以下设置，让Django在控制台输出邮件：

EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

异步任务不仅可以用于费时的操作，还可以用于可能失败的操作，这些操作不会执行很长时间，但它们可能会连接失败，或者需要重试策略。

现在我们需要在order_create视图中添加任务。打开orders应用的views.py文件，并导入任务：

from .tasks import order_created

然后在清空购物车之后调用order_created异步任务：

# clear the cart
cart.clear()
# launch asynchronous task
order_created.delay(order.id)

我们调用任务的delay()方法异步执行任务。任务会被添加到队列中，worker会尽快执行。

打开另一个终端，并使用以下命令启动Celery的worker：

celery -A myshop worker -l info

译者注：必须在myshop项目目录下执行上面的命令。

现在Celery的worker已经运行，准备好处理任务了。确保Django开发服务器也在运行。在浏览器中打开http://127.0.0.1/8000/，添加一些商品到购物车中，然后完成订单。在终端，你已经启动了Celery worker，你会看到类似这样的输出：

[2017-05-11 06:40:27,416: INFO/MainProcess] Received task: orders.tasks.order_created[4d6f667b-7cc7-4310-82fc-8323810fae54]
[2017-05-11 06:40:27,825: INFO/PoolWorker-3] Task orders.tasks.order_created[4d6f667b-7cc7-4310-82fc-8323810fae54] succeeded in 0.12212000600266038s: 1

任务已经执行，你会收到一封订单的邮件通知。

7.4.5 监控Celery

你可能希望监控已经执行的异步任务。Flower是一个基于网页的监控Celery工具。你可以使用pip install flower安装Flower。

安装后，你可以在项目目录下执行以下命令启动Flower：

celery -A myshop flower

在浏览器中打开http://127.0.0.1:5555/dashboard。你会看到活动的Celery worker和异步任务统计：

你可以在这里查看Flower的文档。

7.5 总结

在这章中，你创建了一个基础的在线商店应用。你创建了商品目录，并用会话构建了购物车。你实现了自定义上下文处理器，让模板可以访问购物车，并创建了下单的表单。你还学习了如何使用Celery启动异步任务。

在下一章中，你会学习在商店中集成支付网关（payment gateway），在管理站点添加用户操作，导出CVS格式数据，以及动态生成PDF文件。