用户帐户——《Python编程从入门到实践》

Web应用程序的核心是让任何用户都可以注册帐户并可以使用它，无论用户身处何方

一、让用户可以输入数据

创建用于建立用户的身份验证系统以前，咱们先来添加几个页面，让用户可以输入数据。当前，只有超级用户可以经过管理网站输入数据。咱们不想让用户与管理网站交互，所以咱们将使用Django的表单建立工具来建立让用户可以输入数据的页面

1.添加新主题：

首先让用户可以添加新主题。建立基于表单的页面的方法几乎与前面建立网页同样:定义一个URL，编写一个视图函数并编写一个模板。主要差异是，须要导入包含表单的模块forms.py

用于添加主题的表单

在Django中，建立表单最简单的方法是使用ModelForm，它根据咱们定义的模板中的信息自动建立表单。
首先，建立一个名为在应用程序目录下建立forms.py

咱们首先导入了模板forms以及要使用的模板Topic，而后定义了一个名为TopicForm的类，继承forms.ModelForm。最简单的ModelForm只包含一个内嵌的Meta类，它告诉Django根据哪一个模型建立表单，以及在表单中包含哪些字段。上例中，咱们根据Topic建立一个表单，该表单包含text字段，且不用为text字段生成标签

URL模式new_topic

当用户要添加新主题时，咱们将切换到http://localhost:8000/new_topic/ ，咱们在learning_logs/urls.py中定义网页new_topic的URL模式

URL模式将请求交给视图函数new_topic().接下来编写这个函数

视图函数new_topic()

函数new_topic()须要处理两种情形：刚进入new_topic网页（在这种状况下，他应该显示一个空表单）；对提交的表单数据进行处理，并将用户重定向到网页topics
首先咱们要导入HttpResponseRedirect类，用户提交主题后，使用这个类将用户重定向到网页topics。函数reverse()根据指定的URL模型肯定URL，这意味着Django将在页面被请求时生成URL。咱们还导入来了刚才建立的表单TopicForm

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.core.urlresolvers import reverse

from .models import Topic
from .forms import TopicForm


# Create your views here.

--snip--

def new_topic(request):
    """添加新主题"""
    if request.method != 'POST':
        # 未提交数据：建立一个新表单
        form = TopicForm()
    else:
        # POST提交的数据，对数据进行处理
        form = TopicForm(request.POST)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(reverse('learning_logs:topics'))

    context = {'form': form}
    return render(request, 'learning_logs/new_topic.html', context)

GET请求和POST请求

对于只是从服务器读取数据的页面，使用GET请求；在用户须要经过表单提交信息时，一般使用POST请求
函数new_topic()将请求对象做为参数。用户首次请求网页时，浏览器发送GET请求，当用户填写并提交表单时，浏览器将发送POST请求。根据请求类型能够肯定用户请求是空表单（GET请求）仍是对填写好的表单进行处理（POST请求）
若是请求方法不是POST，请求就多是GET，咱们返回一个空表单。若是请求方法是POST，执行else代码块，对提交的表单数据进行处理。咱们根据用户输入（它们存储在request.POST中）建立一个TopicForm实例，这样form包含了用户提交的信息
要将提交的信息保存到数据库，必须先经过检查它们是否是有效的。函数is_valid()合适用户填写了全部必不可少的字段（表单字段默认都是必不可少的），且输入的数据与要求的字段类型一致（例如，字段text少于200个字符，这是咱们以前在models.py中指定的）。这种自动验证避免了咱们去作大量的工做。若是字段都有效，咱们调用save()将表单的数据写入数据库。保存数据后，就能够离开这个页面了。咱们使用reverse()获取页面topics的URL，并将其传递给HttpResponseRedirect()，将用户的浏览器重定向到页面topics

模板new_topic

下面来建立新模板new_topic.html，用于显示咱们刚建立的表单

这个模板继承了base.html，咱们定义了一个HTML表单，action告诉服务器将提交的表单数据发送到哪里，这里咱们将它发回给new_topic()，method让浏览器以POST请求的方式提交数据
Django使用模板标签{% csrf_token %}来防止攻击者利用表单类获取对服务器未经受权的访问（这种攻击被称为跨站请求伪造）。咱们用模板变量{{ form.as_p }}让Django自动建立显示表单所需的所有字段。修饰符as_p让Django以段落格式渲染全部表单元素，这是一种整洁地显示表单的简单方法
Django不会为表单建立提交按钮，所以咱们还定义了一个按钮

连接到页面new_topic

接下来，咱们在页面topics中添加一个到页面new_topic的连接：

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

{% block content %}
<p>Topics</p>

<ul>
    --snip--
</ul>

<a href="{% url 'learning_logs:new_topic' %}">Add a new topic:</a>

{% endblock content %}

连接到new_topic页面后，能够利用这个表单添加几个新主题

2.添加新条目：

如今用户能够添加新主题了，但他们还想添加新条目。

用于添加新条目的表单

# -*- coding:utf-8 -*-
from django import forms
from .models import Topic, Entry

--snip--

class EntryForm(forms.ModelForm):
    class Meta:
        model = Entry
        fields = ['text']
        labels = {'text': ''}
        widgets = {'text': forms.Textarea(attrs={'cols': 80})}

咱们导入Entry。新类EntryForm继承forms.ModelForm，它包含的Meta类指出了表单基于的模型以及要在表单中包含哪些字段。这里也给text指定了一个空标签
另外，咱们定义了属性widgets。小部件（widget）是一个HTML表单元素，如单行文本框、多行文本框或下拉列表。经过设置属性widgets，能够覆盖Django选择的默认小部件。经过让Django使用forms.Textarea，咱们定制了字段’text'的输入 小部件，将文本区域的宽度设置为80列。这给用户提供了足够的空间，能够编写有意义的条目

URL模式new_entry

--snip--
urlpatterns=[
    --snip--
    # 用于添加新条目的网页
    url(r'^new_entry/(?P<topic_id>\d+)/$', views.new_entry, name='new_entry')
]

这个URL模式与形如：http://localhost:8000/new_entry/id/ 的URL匹配，其中id是一个与主题id匹配的数字。代码(?P<topic_id>\d+)捕获一个数字值，将其存在topic_id中。当请求匹配这个模式时，Django将请求和主题ID发送给函数new_entry()

视图函数new_entry()

视图new_entry与视图new_topic很像

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.core.urlresolvers import reverse

from .models import Topic
from .forms import TopicForm, EntryForm


# Create your views here.

--snip--

def new_entry(request, topic_id):
    """在特定的主题中添加新条目"""
    topic = Topic.objects.get(id=topic_id)
    if request.method != 'POST':
        # 未提交数据：建立一个空表单
        form = EntryForm()
    else:
        # POST提交的数据，对数据进行处理
        form = EntryForm(data=request.POST)
        if form.is_valid():
            new_entry = form.save(commit=False)
            new_entry.topic = topic
            new_entry.save()
            return HttpResponseRedirect(reverse('learning_logs:topic', args=[topic_id]))
        
    context = {'topic': topic, 'form': form}
    return render(request, 'learning_logs/new_entry.html', context)

咱们导入了刚建立的EntryForm。new_entry()的定义包含形参topic_id,用于存储从URL中得到的值。咱们经过topic_id来得到正确的主题
咱们检查请求方法时POST仍是GET。若是是GET请求，将执行if代码块：建立一个空的EntryForm实例。若是是POST请求，咱们对数据进行处理：建立一个EntryForm实例，使用request对象中的POST数据填充它；再检查表单是否有效，若是有效，就设置条目对象的topic属性，再将条目对象保存到数据库
调用save()时，咱们传递了实参commit=False，让Django建立一个新的条目对象，并将其存储到new_entry中，而后将new_entry的属性topic设置为从数据库中找到的主题，而后再调用save()，把条目保存到数据库，并将其与正确的主题关联
而后将用户重定向到显示相关主题的页面。调用reverse()时，提供了两个参数：根据它来生成URL的URL模式的名称；列表args，其中包含要包含在URL中的全部实参。这里，列表args只有topic_id一个元素

模板new_entry

从下面的代码可知，模板new_entry相似于模板new_entry

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

{% block content %}
<p><a href="{% url 'learning_logs:topic' topic.id %}">{{ topic  }}</a> </p>

<p>Add a new entry:</p>

<form action="{% url 'learning_logs:new_entry' topic.id %}" method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button name="submit">add entry</button>
</form>

{% endblock content %}

咱们在页面顶端显示了主题，让用户知道他是在那个主题中添加条目；该主题名也是一个连接，可用于返回到该主题的主页面
表单的action包含URL中的topic_id值，让视图函数可以将新条目关联到正确的主题

连接到页面new_entry

接下来，咱们须要在显示特定主题的页面中添加到new_entry的连接：

{% extends 'learning_logs/base.html' %}

{% block content %}

<p>Topic:{{ topic }}</p>

<p>Entries:</p>
<p>
    <a href="{% url 'learning_logs:new_entry' topic.id %}">add new entry</a>
</p>
<ul>
   --snip--
</ul>

{% endblock content %}

尝试添加新条目

3.编辑条目：

下面建立一个页面，让用户可以编辑既有的条目

URL模式edit_entry

# -*- coding:utf-8 -*-
"""定义learning_logs的URL模式"""
from django.conf.urls import url
from . import views

urlpatterns = [
    --snip--
    # 用于编辑条目的页面
    url(r'^edit_entry/(?P<entry_id>\d+)/$', views.edit_entry, name='edit_entry'),
]

该模式匹配如：http://localhost:8000/edit_entry/1/ 的请求，发送给视图函数edit_entry()

视图函数edit_entry()

页面edit_entry收到GET请求，edit_entry()返回一个表单，让用户可以对条目进行编辑。收到POST请求，将修改后的文本保存到数据库中

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.core.urlresolvers import reverse

from .models import Topic, Entry
from .forms import TopicForm, EntryForm


# Create your views here.

--snip--

def edit_entry(request, entry_id):
    """编辑既有条目"""
    entry = Entry.objects.get(id=entry_id)
    topic = entry.topic

    if request.method != 'POST':
        # 初次请求，使用当前条目填充表单
        form = EntryForm(instance=entry)
    else:
        # POST提交的数据，对数据进行处理
        form = EntryForm(instance=entry, data=request.POST)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(reverse('learning_logs:topic', args=[topic.id]))
    context = {'entry': entry, 'topic': topic, 'form': form}
    return render(request, 'learning_logs/edit_entry.html', context)

咱们要导入Entry模型，先获取用户要修改的条目对象，以及该条目相关联的主题
在请求方法为GET时将执行if代码块，咱们使用实参instance=entry建立一个EntryForm实例，这个实参让Django建立一个表单，并使用既有的条目对象中的信息填充它。用户将看到既有的数据，并能编辑它们
处理POST请求时，咱们传递实参instance=entry和data=request.POST，让Django根据既有条目对象建立一个表单实例，并根据request.POST中的相关数据对其进行修改。而后咱们验证表单是否有效，有效就save()，接下来咱们重定向到显示条目所属主题的页面，用户将在其中看到其编辑的条目的新版本

模板edit_entry

下面是模板edit_entry.html，它与模板new_entry.html相似

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

{% block content %}
<p><a href="{% url 'learning_logs:topic' topic.id %}">{{ topic }}</a></p>

<p>Edit entry:</p>

<form action="{% url 'learning_logs:edit_entry' entry.id %}" method='post'>
    {% csrf_token %}
    {{ form.as_p }}
    <button name="submit">save changes</button>
</form>

{% endblock content %}

连接到页面edit_entry

如今在特定的主题页面中，须要给每一个条目添加到页面edit_entry的连接：

--snip--
    {% for entry in entries %}
    <li>
        <p>{{ entry.date_added|date:'M d, Y H:i' }}</p>
        <p>{{ entry.text|linebreaks }}</p>
        <p>
            <a href="{% url 'learning_logs:edit_entry' entry.id %}">edit entry</a>
        </p>
    </li>
--snip--

咱们将每一个编辑连接放在每一个条目的日期和文本后面，咱们根据URL模式edit_entry和当前条目的id属性entry.id来肯定URL

二、建立用户帐户

接下来，咱们就将创建一个用户注册和身份验证的系统，让用户可以注册帐户，进而登陆和注销。咱们将新建一个应用程序，其中包含与处理用户帐户相关的全部功能，咱们还将对模型Topic稍作修改，让每一个主题都归属于特定用户

1.应用程序users：

咱们首先使用startapp命令来建立一个名为users的应用程序:

将应用程序users添加到setting.py中

包含应用程序users的URL

2.登陆页面：

首先来实现登陆页面的功能，为此咱们将使用Django提供的默认的登陆视图，所以须要对URL模式稍做修改。咱们在应用程序users目录中，新建一个 urls.py文件，添加以下代码：

咱们导入了默认视图login，匹配了该URL模式的请求将发送给Django默认视图login，注意：这里的视图实参是login，不是views.login。鉴于咱们没有编写本身的视图函数，咱们传递了一个字典，告诉Django去哪里查找咱们将编写的模板

模板login.html
用于请求的登陆页面时，Django将使用其默认视图login，但咱们依然须要为这个页面提供模板。为此，在users中建立一个名为templates的目录，在其中建立一个名为users的目录。如下是模板login.html，它应该在users/templates/users/中

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

{% block content %}
{% if form.errors %}
<p>Your username and password didn't match. Please try again.</p>
{% endif %}

<form method="post" action="{% url 'users:login' %}">
    {% csrf_token %}
    {{ form.as_p }}

    <button name="submit">log in</button>
    <input type="hidden" name="next" value="{% url 'learning_logs:index' %}"/>
</form>

{% endblock content %}

这个模板继承了base.html，保证在登陆页面的外观与网站的其余页面相同。注意：一个应用程序中的模板可继承另外一个应用程序的模板
若是表单errors属性被设置，就显示一条错误信息，提示用户用户名密码不匹配，请重试
action设置为登陆页面URL让登陆视图处理表单，登陆视图返回一个表单发送给模板，在模板中咱们显示该表单，并添加提交按钮。另外，咱们包含了一个隐藏的表单元素——‘next'，其中value告诉Django在用户成功登陆后将其重定向到什么地方

连接到登陆页面
下面在base.html中添加到登陆页面的连接，让全部页面都包含它。用户已登陆，咱们就不显示这个连接

<p>
    <a href="{% url 'learning_logs:index' %}">Learning Log</a> -
    <a href="{% url 'learning_logs:topics' %}">Topics</a> -
    {% if user.is_authenticated %}
        Hello, {{ user.username }}
    {% else %}
        <a href="{% url 'users:login' %}">log in</a>
    {% endif %}
</p>

{% block content %}{% endblock content %}

在Django身份验证系统中，每一个模板均可使用变量user，这个变量有一个is_authenticated属性：若是用户已登陆，该属性为Ture，不然为Fals，咱们经过该属性判断用户是否登陆，显示不一样消息

使用登陆页面

前面创建一个用户帐户，下面来登陆一下，看看登陆页面是否管用。请访问http://localhost:8000/admin/ ,若是依然是以管理员的身份登陆的，先注销，注销后，访问http://localhost:8000/users/login/ ,你将看到以下界面，输入用户名密码，将进入页面index，在这个页面中，显示一条问候语，其中包含你的用户名

3.注销：

如今须要提供一个让用户注销的途径。咱们不建立用于注销的页面，而让用户只需点击一个连接就能注销并返回到主页。为此咱们为注销定义一个URL模式，编写一个视图函数，并在base.html中添加一个注销连接

注销URL

--snip--
urlpatterns = [
    # 登录页面
    --snip--
    # 注销
    url(r'^logout/$', views.logout_view, name='logout')
]

视图函数logout_view()
函数logout_view()很简单：咱们从django.contrib.auth中导入函数logout()，并调用它，再重定向到主页。咱们再users/views.py中输入下面的代码

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.shortcuts import render

from django.http import HttpResponseRedirect
from django.core.urlresolvers import reverse
from django.contrib.auth import logout


# Create your views here.


def logout_view(request):
    """注销用户"""
    logout(request)
    return HttpResponseRedirect(reverse('learning_logs:index'))

连接到注销视图
如今咱们须要添加一个注销连接，咱们在base.html中添加这种连接，让每一个页面都包含它：咱们将它放在标签{% if user.is_authenticated %}中，使得仅当用户登陆后才能看到它：

--snip--
    {% if user.is_authenticated %}
    Hello, {{ user.username }}
    <a href="{% url 'users:logout' %}">log out</a>
    {% else %}
    <a href="{% url 'users:login' %}">log in</a>
    {% endif %}
</p>
--snip--

而后咱们登陆就看到的是下面的样子：

4.注册页面

下面来建立一个新用户可以注册的页面。 咱们将使用Django提供的表单UserCreationForm，但编写本身的视图函数和模板

注册页面的URL模式

--snip--
urlpatterns = [
    # 登录页面
    --snip--
    # 注册页面
    url(r'^register/$', views.register, name='register'),
]

这个模式与URL http://lcalhost:8000/users/register/ 匹配，将请求发送给咱们编写的函数register()

视图函数register()

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.shortcuts import render
from django.http import HttpResponseRedirect
from django.core.urlresolvers import reverse
from django.contrib.auth import logout, login, authenticate
from django.contrib.auth.forms import UserCreationForm

def logout_view(request):
    --snip--

def register(request):
    """注册新的用户"""
    if request.method != 'POST':
        # 显示空的注册表单
        form = UserCreationForm()
    else:
        # 处理填好的表单
        form = UserCreationForm(data=request.POST)
        if form.is_valid():
            new_user = form.save()
            # 让用户自动登陆，再重定向到主页
            authenticated_user = authenticate(username=new_user.username, password=request.POST['password1'])
            login(request, authenticated_user)
            return HttpResponseRedirect(reverse('learning_logs:index'))
    context = {'form': form}
    return render(request, 'users/register.html', context)

咱们导入了render()，而后导入了login()和authenticate()，以便在用户正确填写了注册信息时让其自动登陆
咱们还导入了UserCreationForm。在函数register()中，咱们检查要响应的是不是POST请求，若是不是就建立一个UserCreationForm，且不给它提供任何初始数据。
若是响应的是POST请求，咱们就根据提交的数据建立一个UserCreationForm实例，并检查这些数据是否有效：就这里而言，是用户名未包含非法字符，输入的两个密码相同，以及用户没有试图作恶意的事情。
若是提交的数据有效，咱们就调用表单的方法save()，将用户名和密码的散列值保存到数据库中。方法save()返回新建立的用户对象，咱们保存在new_user中。
保存用户的信息后，咱们让用户自动登陆，这包含两个步骤：

• 首先咱们，调用authenticate()，并将实参new_user.username和密码传递给它。用户注册时，被要求输入密码两次；因为表单是有效的，咱们知道输入的这两个密码是相同的，所以可使用其中任何一个。在这里，咱们从表单的POST数据中获取与键’password1'相关联的值。若是用户名和密码无误，方法authenticate()将返回一个经过了身份验证的用户对象，咱们将其存储在authenticated_user中
• 接下来，咱们调用login()，将对象request和authenticated_user传递给它，这将为新用户建立有效的会话
  最后，咱们将用户重定向到主页，并显示注册成功的问候消息

注册模板
注册页面的模板与登陆页面的模板相似，它跟login.html在一个目录下：

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

{% block content %}

<form method="post" action="{% url 'users:register' %}">
    {% csrf_token %}
    {{ form.as_p }}
    <button name="submit">register</button>
    <input type="hidden" name="next" value="{% url 'learning_logs:index' %}"/>
</form>

{% endblock content %}

这里也用了as_p，让Django在表单中正确地显示全部的字段，包括错误消息——若是用户没有正确地填写表单

连接到注册页面
接下来咱们，添加以下代码，即用户没有登陆时显示到注册页面的连接：

--snip--
    {% if user.is_authenticated %}
    Hello, {{ user.username }}
    <a href="{% url 'users:logout' %}">log out</a>
    {% else %}
    <a href="{% url 'users:register' %}">register</a> -
    <a href="{% url 'users:login' %}">log in</a>
    {% endif %}
--snip--

如今，已登陆的用户看到的是：

而未登陆的用户看到的是：

三、让用户拥有本身的数据

用户应该能输入其专有的数据，所以咱们将建立一个系统，肯定各项数据所属的用户，再限制对页面的访问，让用户只能使用本身的数据

咱们将修改模型Topic，让每一个主题都归属于特定用户。这也将影响条目，由于每一个条目都属于特定的主题。咱们先来限制对一些页面的访问

1.使用@login_required限制访问

Django提供了装饰器@login_required，让你可以轻松地实现这样的目标：对于某些页面，只容许已登陆的用户访问它们。装饰器(decorator)是放在函数定义前面的，Python在函数运行前，根据它来修改函数代码的行为

限制对topics页面的访问
每一个主题都归特定的用户全部，所以应只容许已登陆的用户请求topics页面。为此咱们修改learning_logs/views.py的代码

咱们导入了函数login_required()。在视图函数topics()前加上符号@和login_required，让Python在运行topics()代码的前先运行login_required()的代码。login_required()的代码检查用户是否已经登陆，仅当用户已登陆时，Django才运行topics()的代码。若是用户未登陆，就重定向到登陆页面
为实现这种重定向，咱们修改settings.py，绕过Django知道到哪里去查找登陆页面

如今，未登陆的用户请求修饰器@login_required的保护页面，Django将重定向到settings.py中的LOGIN_URL指定的URL
要测试这个设置，可注销进入主页，单击连接Topics，将重定向到登陆页面。使用你的帐号登陆后，再次点击Topics连接，你将看到topics页面

全面限制对项目“学习笔记”的访问
Django让你可以轻松地限制对页面的访问，但你必须针对要保护哪些页面作出决定。最好先肯定项目的哪些页面不须要保护，再限制对其余全部页面的访问。你能够轻松地修改过于严格的访问限制，其风险比不限制对敏感页面地访问更低
在“学习笔记”项目中，咱们不限制对主页、注册页面和注销页面的访问，并限制对其余全部页面的访问

--snip--
@login_required
def topics(request):
--snip


@login_required
def topic(request, topic_id):
--snip--


@login_required
def new_topic(request):
--snip--


@login_required
def new_entry(request, topic_id):
--snip--


@login_required
def edit_entry(request, entry_id):
--snip--

未登陆的状况下尝试访问这些页面，都将重定向到登陆页面

2.将数据关联到用户

如今，须要将数据关联到提交它们的用户。咱们只需将最高层的数据关联到用户，这样更低层的数据将自动关联到用户。例如，在项目“学习笔记”中，应用程序的最高数据是主题，全部条目都与特定主题相关联。只要每一个主题都归属于特定用户，咱们就能肯定数据库中每一个条目的全部者

修改模型Topic
对models.py的修改只涉及两行代码

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

from django.db import models
from django.contrib.auth.models import User


# Create your models here.
class Topic(models.Model):
    """用户学习的主题"""
    text = models.CharField(max_length=200)
    date_added = models.DateTimeField(auto_now_add=True)
    owner = models.ForeignKey(User)

    def __unicode__(self):
        """返回模型的字符串表示"""
        return self.text

--snip--

咱们导入了django.contrib.auth中的模型User，而后再Topic中添加了字段owner，它创建到模型User的外键关系

肯定当前有哪些用户
在咱们肯定将各个既有主题关联到哪一个用户上时，须要先知道关联用户的ID，为此咱们打开一个Django Shell会话，执行以下命令，查看已建立的全部用户的ID

shell会话中输出了三个用户:hasee_z、eric、willie，并打印了它们的ID，Django询问要将既有主题关联到哪一个用户时，咱们将指定其中的一个ID值

迁移数据库
知道用户ID后，就能够迁移数据库了：

如今能够执行迁移了，咱们继续执行命令python manage.py migrate

Django应用新的迁移，结果一切顺利。为验证符合预期，咱们在Shell会话中这样作

3.只容许用户访问本身的主题

当前，无论你以哪一个用户的身份登陆，都能看到全部的主题。为只向用户显示属于本身的主题，咱们对views.py中的topics()作以下修改：

--snip--
@login_required
def topics(request):
    """显示全部的主题"""
    topics = Topic.objects.filter(owner=request.user).order_by('date_added')
    context = {'topics': topics}
    return render(request, 'learning_logs/topics.html', context)
--snip--

用户登陆后，request对象将有一个user属性，这个属性存储了有关该用户的信息。Topic.objects.filter(owner=request.user)让Django只从数据库中获取owner属性为当前用户的Topic对象
要验证结果，咱们以既有主题关联到的用户身份登陆，访问topics页面，将看到全部的主题

而后，注销并以另外一个用户的身份登陆，topics页面将不会列出任何主题

4.保护用户的主题

咱们还没限制对显示单个主题的页面的访问，所以任何已登陆的用户均可以输入相似于：http://localhost:8000/topics/1/ 的URL，来访问显示相应主题的页面
为了修复这种问题，咱们在视图函数topic()获取请求的条目前执行检察：

from django.shortcuts import render
from django.http import HttpResponseRedirect, Http404
from django.core.urlresolvers import reverse
--snip--

@login_required
def topic(request, topic_id):
    """显示单个主题及其全部的条目"""
    topic = Topic.objects.get(id=topic_id)
    # 确认请求的主题属于当前用户
    if topic.owner != request.user:
        raise Http404
    entries = topic.entry_set.order_by('-date_added')
    context = {'topic': topic, 'entries': entries}
    return render(request, 'learning_logs/topic.html', context)
--snip--

服务器上没有请求的资源时，标准作法是返回404响应。在这里，咱们导入异常Http404，并在用户请求它不能查看的主题时引起这个异常。收到主题请求后，咱们在渲染网页前检查该主题是否属于当前登陆的用户。若是请求的主题不归当前用户全部，咱们就引起Http404异常，让Django返回一个404错误页面
结果以下：

5.保护页面edit_entry

页面edit_entry的URL为http://localhost:8000/edit_entry/entry_id/ ,其中entry_id是一个数字。下面来保护这个页面，禁止用户经过输入相似前面的URL来访问其余用户的条目：

--snip--
@login_required
def edit_entry(request, entry_id):
    """编辑既有条目"""
    entry = Entry.objects.get(id=entry_id)
    topic = entry.topic
    if topic.owner != request.user:
        raise Http404

    if request.method != 'POST':
        # 初次请求，使用当前条目填充表单
        --snip--

咱们获取指定条目以及与之相关的主题，而后检查主题的全部者是不是当前登陆的用户，若是不是，就引起Http404异常

6.将新主题关联到当前用户

当前，咱们添加新主题的页面存在问题，没有将新主题关联到特定用户。尝试添加新主题，看到错误IntegrityError，指出learning_logs_topic.user_id不能为NULL，即建立新主题时，必须指定其owner字段的值

因而咱们修改views.py中new_topic()的代码：

--snip--
@login_required
def new_topic(request):
    """添加新主题"""
    if request.method != 'POST':
        # 未提交数据：建立一个新表单
        form = TopicForm()
    else:
        # POST提交的数据，对数据进行处理
        form = TopicForm(request.POST)
        if form.is_valid():
            new_topic=form.save(commit=False)
            new_topic.owner=request.user
            new_topic.save()
            return HttpResponseRedirect(reverse('learning_logs:topics'))

    context = {'form': form}
    return render(request, 'learning_logs/new_topic.html', context)
--snip--

咱们首先调用form.save()，传递实参commit=False，由于咱们先修改新主题，再对其保存到数据库中。接下来，将新主题的owner属性设置为当前用户。最后对刚定义的主题实例调用save()。如今新主题包含全部必不可少的数据，将被成功地保存。 如今，这个项目容许任何用户注册，并且用户想添加多少新主题均可以。每一个用户都只能访问本身的数据，不管是查看数据、输入新数据仍是修改旧数据时都如此。