Django入门（二）

蔚落 2021-12-10 01:57 318阅读 0赞

> 跟书《python编程：从入门到实践》，学习用Django编写名为“学习笔记”的Web应用程序。

Web应用程序的核心是让任何用户都能够注册账户并能够使用它，不管用户身处何方。我们可以创建一些表单，让用户能够添加主题和条目，以及编辑既有的条目。

--------------------

### 让用户能够输入数据 ###

先来添加几个页面，让用户能够输入数据。可以让用户能够添加新主题、添加新条目以及编辑既有条目，但不能通过管理网站来输入，因为只有超级用户才可以这样做。

--------------------

#### 添加新主题 ####

首先来让用户能够添加新主题。创建基于表单的页面的方法几乎与前面创建网页一样：定义一个URL，编写一个视图函数并编写一个模板。一个主要差别是，[需要导入包含表单的模块forms.py][forms.py]。

*  用于添加主题的表单：

在Django中，创建表单的最简单方式是使用ModelForm。创建一个名为forms.py的文件，将其存储到models.py所在的目录中，并在其中编写第一个表单。

# vim learning_logs/forms.py

from django import forms
    
    from .models import Topic
    
    class TopicForm(forms.ModelForm):
        class Meta:
            model = Topic
            fields = ['text']
            labels = { 'text': ''}

首先导入了模块forms以及要使用的模型Topic。然后定义了一个名为TopicForm的类，它继承了forms.ModelForm。

最简单的ModelForm版本只包含一个内嵌的Meta类，它告诉Django根据哪个模型创建表单，以及在表单中包含哪些字段。我们根据模型Topic创建一个表单，该表单只包含字段text，且让Django不要为字段text生成标签。

*  URL模式`new_topic`：

# vim learning_logs/urls.py

这个URL模式会将请求交给视图函数`new_topic()`。

*  视图函数`new_topic()`：

函数`new_topic()`需要处理两种情形：刚进入`new_topic`网页，它应显示一个空表单；对提交的表单数据进行处理，并将用户重定向到网页topics。

# vim learning_logs/views.py

from django.shortcuts import render
    from django.http import HttpResponseRedirect
    from django.urls import reverse
    
    from .models import Topic
    from .forms import TopicForm
    
    def index(request):
        """学习笔记的主页"""
        return render(request, 'learning_logs/index.html')
    
    def topics(request):
        """显示所有主题"""
        topics = Topic.objects.order_by('date_added')
        context = { 'topics': topics}
        return render(request, 'learning_logs/topics.html', context)
    
    def topic(request, topic_id):
        """显示一个主题及其详细页面"""
        topic = Topic.objects.get(id=topic_id)
        entries = topic.entry_set.order_by('-date_added')
        context = { 'topic': topic, 'entries': entries}
        return render(request, 'learning_logs/topic.html', context)
    
    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)

导入了`HttpResponseRedirect`类和刚才创建的表单`TopicForm`，用户提交主题后我们将使用`HttpResponseRedirect`类将用户重定向到网页topics。函数`reverse()`根据指定的URL模型确定URL，这意味着Django将在页面被请求时生成URL。

首先判断请求方法是否是POST——如果请求方法不是POST，返回一个空表单；如果请求方法是POST，将使用用户输入的数据（存储在request.POST中）创建一个`TopicForm`实例，这样对象form将包含用户提交的信息。

然后要将提交的信息保存到数据库，必须先通过检查确定它们是有效的。函数`is_valid()`核实用户填写了所有必不可少的字段（表单字段默认都是必不可少的），且输入的数据与要求的字段类型一致。如果所有字段都有效，我们就调用`save()`将表单中的数据写入数据库。

最后使用`reverse()`获取页面topics的URL，并将其传递给`HttpResponseRedirect()`，后者将用户的浏览器重定向到页面topics。在页面topics中，用户将在主题列表中看到他刚输入的主题。

*  GET请求和POST请求：

创建Web应用程序时，将用到的两种主要请求类型是GET请求和POST请求。对于只是从服务器读取数据的页面，使用GET请求；在用户需要通过表单提交信息时，通常使用POST请求。处理所有表单时，我们都将指定使用POST方法。

函数`new_topic()`将请求对象作为参数。用户初次请求该网页时，其浏览器将发送GET请求；用户填写并提交表单时，其浏览器将发送POST请求。根据请求的类型，我们可以确定用户请求的是空表单（GET请求）还是要求对填写好的表单进行处理（POST请求）。

*  模板`new_topic`：

# vim learning_logs/templates/learning_logs/new_topic.html

{% extends "learning_logs/base.html" %}
    
    {% block content %}
      <p>Add a new topic:</p>
    
      <form action="{% url 'learning_logs:new_topic' %}" method='post'>
        {% csrf_token %}
        {
       { form.as_p }}
        <button name="submit">add topic</button>
      </form>
        
    {% endblock content %}

> 继承了base.html，然后定义了一个HTML表单。实参action告诉服务器将提交的表单数据发送到哪里，这里我们将它发回给视图函数`new_topic()`。实参method让浏览器以POST请求的方式提交数据。
> 
> Django使用模板标签`{% csrf_token %}`来防止攻击者利用表单来获得对服务器未经授权的访问（这种攻击被称为跨站  
> 请求伪造）。接着显示表单，只需包含模板变量`{ { form.as_p }}`，就可让Django自动创建显示表单所需的全部字段。修  
> 饰符`as_p`让Django以段落格式渲染所有表单元素。

*  链接到页面`new_topic`：

# vim learning_logs/templates/learning_logs/topics.html

{% extends "learning_logs/base.html" %}
    
    {% block content %}
    
      <p>Topics</p>
    
      <ul>
        {% for topic in topics %}
          <li>
            <a href="{% url 'learning_logs:topic' topic.id %}">{
       { topic }}</a>
          </li>
        {% empty %}
          <li>No topics have been added yet.</li>
        {% endfor %}
      </ul>
    
      <a href="{% url 'learning_logs:new_topic' %}">Add a new topic:</a>
    
    {% endblock content %}

*  访问网页：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 1]

--------------------

#### 添加新条目 ####

现在已经可以添加新主题了，但是还不能添加新条目，再次定义URL，编写视图函数和模板，并链接到添加新条目的网页。

*  用于添加新条目的表单：

创建一个与模型Entry相关联的表单。

# vim learning_logs/forms.py

from django import forms
    
    from .models import Topic, Entry
    
    class TopicForm(forms.ModelForm):
        class Meta:
            model = Topic
            fields = ['text']
            labels = { 'text': ''}
    
    class EntryForm(forms.ModelForm):
        class Meta:
            model = Entry
            fields = ['text']
            labels = { 'text': ''}
            wgdgets = { 'text': forms.Textarea(attrs={ 'cols': 80})}

除了导入Topic外，还需要导入Entry。新类EntryForm继承了forms.ModelForm，它包含的Meta类指出了表单基于的模型以及要在表单中包含哪些字段。

后面定义了属性`widgets`，小部件（widget）是一个HTML表单元素，如单行文本框、多行文本区域或下拉列表。通过设置属性`widgets`，可覆盖Django选择的默认小部件。通过让Django使用forms.Textarea，我们定制了字段`'text'`的输入小部件，将文本区域的宽度设置为80列，而不是默认的40列。

*  URL模式`new_entry`：

在用于添加新条目的页面的URL模式中，需要包含实参topic\_id ，因为条目必须与特定的主题相关联。

# vim learning_logs/urls.py

"""定义learning_logs的URL模式"""
    
    from django.urls import path, re_path
    from . import views
    
    app_name='learning_logs'
    urlpatterns = [
        # 主页
        path('', views.index, name='index'),
    
        # 显示所有的主题
        path('topics/', views.topics, name='topics'),
    
        # 特定主题的详细页面
        re_path(r'^topics/(?P<topic_id>\d+)/$', views.topic, name='topic'),
    
        # 用于添加新主题的页面
        path('new_topic/', views.new_topic, name='new_topic'),
    
        # 用于添加新条目的页面
        re_path(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`中。请求的URL与这个模式匹配时，Django将请求和主题ID发送给函数`new_entry()`。

*  视图函数`new_entry()`：

视图函数`new_entry()`与视图函数`new_topic()`比较类似。

# vim learning_logs/views.py

from django.shortcuts import render
    from django.http import HttpResponseRedirect
    from django.urls import reverse
    
    from .models import Topic
    from .forms import TopicForm, EntryForm
    
    def index(request):
        """学习笔记的主页"""
        return render(request, 'learning_logs/index.html')
    
    def topics(request):
        """显示所有主题"""
        topics = Topic.objects.order_by('date_added')
        context = { 'topics': topics}
        return render(request, 'learning_logs/topics.html', context)
    
    def topic(request, topic_id):
        """显示一个主题及其详细页面"""
        topic = Topic.objects.get(id=topic_id)
        entries = topic.entry_set.order_by('-date_added')
        context = { 'topic': topic, 'entries': entries}
        return render(request, 'learning_logs/topic.html', context)
    
    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)
    
    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请求，将创建一个空的EntryForm实例。如果请求方法为POST，我们就对数据进行处理：创建一个EntryForm实例，使用request对象中的POST数据来填充它；再检查表单是否有效，如果有效则设置条目对象的属性`topic`，再将条目对象保存到数据库。

在调用`save()`时，传递了实参`commit=False`，让Django创建一个新的条目对象，并将其存储到`new_entry`中，但不将它保存到数据库中。我们将`new_entry`的属性`topic`设置为在这个函数开头从数据库中获取的主题，然后调用`save()`，且不指定任何实参。这将把条目保存到数据库，并将其与正确的主题相关联。

最后，将用户重定向到显示相关主题的页面。调用`reverse()`时，需要提供两个实参：要根据它来生成URL的URL模式的名称；列表args ，其中包含要包含在URL中的所有实参。

*  模板`new_entry`：

模板`new_entry`与模板`new_topic`也比较类似。

# vim learning_logs/templates/learning_logs/new_entry.html

{% 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 %}

> 首先继承base.html。接着在页面顶端显示了主题，让用户知道是在哪个主题中添加条目；该主题名也是一个链接，可用于返回该主题的主页面。
> 
> 表单的实参action 包含URL中的`topic_id`值，让视图函数能够将新条目关联到正确的主题。除此之外，这个模板与模板new\_topic.html完全相同。

*  链接到页面`new_entry`：

# vim learning_logs/templates/learning_logs/topic.html

{% 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>
      {% for entry in entries %}
        <li>
          <p>{
       { entry.date_added|date:'M d, Y H:i' }}</p>
          <p>{
       { entry.text|linebreaks }}</p>
        </li>
      {% empty %}
        <li>
          There are no entries for this topic yet.
        </li>
      {% endfor %}
      </ul>
    
    {% endblock content %}

> 在显示条目前添加链接，因为在这种页面中，执行的最常见的操作是添加新条目。

*  访问网页：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 2]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 3]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 4]

--------------------

#### 编辑条目 ####

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

*  URL模式`edit_entry`：

# vim learning_logs/urls.py

在URL（如`http://localhost:8000/edit_entry/1/`）中传递的ID存储在形参`entry_id`中。这个URL模式将预期匹配的请求发送给视图函数`edit_entry()`。

*  视图函数`edit_entry()`：

页面`edit_entry`收到GET请求时，`edit_entry()`将返回一个表单，让用户能够对条目进行编辑。该页面收到POST请求（条目文本经过修订）时，它将修改后的文本保存到数据库中。

# vim learning_logs/views.py

from django.shortcuts import render
    from django.http import HttpResponseRedirect
    from django.urls import reverse
    
    from .models import Topic, Entry
    from .forms import TopicForm, EntryForm
    
    def index(request):
        """学习笔记的主页"""
        return render(request, 'learning_logs/index.html')
    
    def topics(request):
        """显示所有主题"""
        topics = Topic.objects.order_by('date_added')
        context = { 'topics': topics}
        return render(request, 'learning_logs/topics.html', context)
    
    def topic(request, topic_id):
        """显示一个主题及其详细页面"""
        topic = Topic.objects.get(id=topic_id)
        entries = topic.entry_set.order_by('-date_added')
        context = { 'topic': topic, 'entries': entries}
        return render(request, 'learning_logs/topic.html', context)
    
    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)
    
    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)
    
    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/new_entry.html', context)

首先导入模型Entry 。接着获取用户要修改的条目对象，以及与该条目相关联的主题。在请求方法为GET时，我们使用实参`instance=entry`创建一个EntryForm实例。该实参让Django创建一个表单，并使用既有条目对象中的信息填充它。用户将看到既有的数据，并能够编辑它们。

处理POST请求时，传递实参`instance=entry`和`data=request.POST`，让Django根据既有条目对象创建一个表单实例，并根据request.POST中的相关数据对其进行修改。然后检查表单是否有效，如果有效就调用`save()`且不指定任何实参。接下来重定向到显示条目所属主题的页面，用户将在其中看到其编辑的条目的新版本。

*  模板`edit_entry`：

# vim learning_logs/templates/learning_logs/edit_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`：

# vim learning_logs/templates/learning_logs/topic.html

{% 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>
      {% 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>
      {% empty %}
        <li>
          There are no entries for this topic yet.
        </li>
      {% endfor %}
      </ul>
    
    {% endblock content %}

> 将编辑链接放在每个条目的日期和文本后面。在循环中，使用模板标签`{% url %}`根据URL模式`edit_entry`和当前条目的ID属性`entry.id`来确定URL。链接文本为`"edit entry"`，它出现在页面中每个条目的后面。

*  访问网页：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 5]

--------------------

### 创建用户账户 ###

> 应用路径：users

接下来建立一个用户注册和身份验证系统，让用户能够注册账户，进而登录和注销。

#### 应用程序users ####

*  创建应用程序：

# python manage.py startapp users
    
    # ls
    db.sqlite3  learning_log  learning_logs  ll_env  manage.py  users
    
    # ls users/
    admin.py  apps.py  __init__.py  migrations  models.py  tests.py  views.py

可以看到， users目录的结构与应用程序learning\_logs相同。

*  将应用程序users添加到settings.py中：

# vim learning_log/settings.py
    
    INSTALLED_APPS = [
        'django.contrib.admin',
        'django.contrib.auth',
        'django.contrib.contenttypes',
        'django.contrib.sessions',
        'django.contrib.messages',
        'django.contrib.staticfiles',
        # 我的应用程序
        'learning_logs',
        'users',                #增加这行
    ]

*  包含应用程序users的URL：

# vim learning_log/urls.py

from django.contrib import admin
    from django.urls import path, include
    
    urlpatterns = [
        path('admin/', admin.site.urls),
        path('users/', include('users.urls', namespace='users')),               #增加这行
        path('', include('learning_logs.urls', namespace='learning_logs')),
    ]

同样的，这里保存完文件之后会报错`ModuleNotFoundError: No module named 'users.urls'`，不用理会，继续往下做。

--------------------

#### 登录页面 ####

现在来实现登录页面的功能，可以使用Django提供的默认登录视图。

*  URL模式：

# vim users/urls.py

*  模板`login.html`：

# mkdir -p users/templates/users
    
    # vim users/templates/users/login.html

{% 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在用户成功登录后将其重定向到主页。

*  链接到登录页面：

# vim learning_logs/templates/learning_logs/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`属性：如果用户已登录，该属性将为True，否则为False。
> 
> 在这里向已登录的用户显示一条问候语。对于已通过身份验证的用户设置了属性`username`，我们使用这个属性来个性化问候语，让用户知道他已经登录。而对于还未通过身份验证的用户，我们再显示一个到登录页面的链接。

*  使用登录页面：

访问`192.168.30.128:8000/users/login/`。如果之前使用超级用户登录的，注销之后再访问。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 6]

--------------------

#### 注销 ####

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

*  注销URL：

# vim users/urls.py

"""定义users的URL模式"""
    
    from django.urls import path, re_path
    from django.contrib.auth.views import LoginView
    
    from . import views
    
    app_name='users'
    urlpatterns = [
        # 登录主页
        re_path(r'^login/$', LoginView.as_view(template_name='users/login.html'), name='login'),
    
        # 注销
        re_path(r'^logout/$', views.logout_view, name='logout'),
    ]

这个URL模式将请求发送给函数`logout_view()`，要将其与我们下面在其中调用的函数`logout()`区分开来。

*  视图函数`logout_view()`：

# vim users/views.py

from django.shortcuts import render
    from django.http import HttpResponseRedirect
    from django.urls import reverse
    from django.contrib.auth import logout
    
    def logout_view(request):
        """注销用户"""
        logout(request)
        return HttpResponseRedirect(reverse('learning_logs:index'))

先从django.contrib.auth中导入了函数`logout()`；然后调用了函数`logout()`，它要求将request对象作为实参；最后重定向到主页。

*  链接到注销视图：

现在需要在base.html中添加注销链接，让每个页面都包含它；将它放在标签`{% if user.is_authenticated %}`中，使得仅当用户登录后才能看到它。

# vim learning_logs/templates/learning_logs/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 }}.
        <a href="{% url 'users:logout' %}">log out</a>
      {% else %}
        <a href="{% url 'users:login' %}">log in</a>
      {% endif %}
    </p>
    
    {% block content %}{% endblock content %}

*  访问网页：

使用超级用户登录

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 7]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 8]

--------------------

#### 注册页面 ####

下面使用Django提供的表单UserCreationForm来创建一个让新用户能够注册的页面。

*  URL模式：

# vim users/urls.py

这个模式与URL`http://localhost:8000/users/register/`匹配，并将请求发送给我们即将编写的函数`register()`。

*  视图函数`register()`：

在注册页面首次被请求时，视图函数`register()`需要显示一个空的注册表单，并在用户提交填写好的注册表单时对其进行处理。如果注册成功，这个函数还需让用户自动登录。

# vim users/views.py

from django.shortcuts import render
    from django.http import HttpResponseRedirect
    from django.urls import reverse
    from django.contrib.auth import login, logout, authen
    from django.contrib.auth.forms import UserCreationForm
    
    def logout_view(request):
        """注销用户"""
        logout(request)
        return HttpResponseRedirect(reverse('learning_logs:index'))
        
    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)

首先导入了函数`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`传递给它，这将为新用户创建有效的会话。最后，我们将用户重定向到主页，其页眉中显示了一条个性化的问候语，让用户知道注册成功了。

*  注册模板`register.html`：

# vim users/templates/users/register.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 %}

*  链接到注册页面：

# vim learning_logs/templates/learning_logs/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 }}.
        <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 %}
    </p>
    
    {% block content %}{% endblock content %}

*  访问网页：

现在，已登录的用户看到的是个性化的问候语和注销链接，而未登录的用户看到的是注册链接和登录链接。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 9]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 10]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 11]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 12]

需要注意的是，这里的注册系统允许用户创建任意数量的账户。实际情况下的系统会要求用户确认其身份：发送一封确认邮件或者用手机验证码，用户回复后其账户才生效。通过这样做，系统生成的垃圾账户将比这里使用的简单系统少。

--------------------

### 让用户拥有自己的数据 ###

用户应该能够输入其专有的数据，因此我们将创建一个系统，确定各项数据所属的用户，再限制对页面的访问，让用户只能使用自己的数据。

下面将修改模型Topic ，让每个主题都归属于特定用户。这也将影响条目，因为每个条目都属于特定的主题。

--------------------

#### 使用@login\_required限制 ####

Django提供了装饰器`@login_required`，让你能够轻松地实现这样的目标：对于某些页面，只允许已登录的用户访问它们。**装饰器**（decorator）是放在函数定义前面的指令，Python在函数运行前，根据它来修改函数代码的行为。

*  限制对topics页面的访问：

# vim learning_logs/views.py

from django.shortcuts import render
    from django.http import HttpResponseRedirect
    from django.urls import reverse
    from django.contrib.auth.decorators import login_required
    
    from .models import Topic, Entry
    from .forms import TopicForm, EntryForm
    
    def index(request):
        """学习笔记的主页"""
        return render(request, 'learning_logs/index.html')
    
    @login_required
    def topics(request):
        """显示所有主题"""
        topics = Topic.objects.order_by('date_added')
        context = { 'topics': topics}
        return render(request, 'learning_logs/topics.html', context)
    
    def topic(request, topic_id):
        """显示一个主题及其详细页面"""
        topic = Topic.objects.get(id=topic_id)
        entries = topic.entry_set.order_by('-date_added')
        context = { 'topic': topic, 'entries': entries}
        return render(request, 'learning_logs/topic.html', context)
    
    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)
    
    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)
    
    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/new_entry.html', context)

首先导入函数`login_required()`，将`login_required()`作为装饰器用于视图函数`topics()`——在它前面加上符号`@`和`login_required`，让Python在运行`topics()`的代码前先运行`login_required()`的代码。

`login_required()`的代码检查用户是否已登录，仅当用户已登录时，Django才运行`topics()`的代码。如果用户未登录，就重定向到登录页面。

*  [修改settings.py][settings.py]：

为了实现未登录的重定向，[需要修改settings.py][settings.py 1]。

# vim learning_log/settings.py #末尾添加
    
    # 我的设置
    LOGIN_URL = '/users/login/'

*  访问网页：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 13]

可以看到，现在直接点击`topics`会直接跳转到登录页。

*  全面限制对项目“学习笔记”的访问：

在项目“学习笔记”中，我们将不限制主页、注册页面和注销页面的访问，同时限制其它所有页面的访问。

# vim learning_logs/views.py

from django.shortcuts import render
    from django.http import HttpResponseRedirect
    from django.urls import reverse
    from django.contrib.auth.decorators import login_required
    
    from .models import Topic, Entry
    from .forms import TopicForm, EntryForm
    
    def index(request):
        """学习笔记的主页"""
        return render(request, 'learning_logs/index.html')
    
    @login_required
    def topics(request):
        """显示所有主题"""
        topics = Topic.objects.order_by('date_added')
        context = { 'topics': topics}
        return render(request, 'learning_logs/topics.html', context)
    
    @login_required
    def topic(request, topic_id):
        """显示一个主题及其详细页面"""
        topic = Topic.objects.get(id=topic_id)
        entries = topic.entry_set.order_by('-date_added')
        context = { 'topic': topic, 'entries': entries}
        return render(request, 'learning_logs/topic.html', context)
    
    @login_required
    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)
    
    @login_required
    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)
    
    @login_required
    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/new_entry.html', context)

如果你在未登录的情况下尝试访问这些页面，将被重定向到登录页面。此外，你还不能单击到new\_topic等页面的链接，如果你输入URL `http://192.168.30.128:8000/new_topic/`，将重定向到登录页面。对于所有与私有用户数据相关的URL，都应限制对它们的访问。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 14]

--------------------

#### 将数据关联到用户 ####

现在将数据关联到提交它们的用户。我们只需将最高层的数据关联到用户，这样更低层的数据将自动关联到用户。在项目“学习笔记”中，应用程序的最高层数据是主题，而所有条目都与特定主题相关联。只要每个主题都归属于特定用户，我们就能确定数据库中每个条目的所有者。

*  修改模型Topic：

# vim learning_logs/models.py

from django.db import models
    from django.contrib.auth.models import User
    
    class Topic(models.Model):
        """用户学习的主题"""
        text = models.CharField(max_length=200)
        date_added = models.DateTimeField(auto_now_add=True)
        owner = models.ForeignKey(User, on_delete=models.CASCADE)
    
        def __str__(self):
            """返回模型的字符串表示"""
            return self.text
            
    class Entry(models.Model):
        """学到的有关某个主题的具体知识"""
        topic = models.ForeignKey(Topic, on_delete=models.CASCADE)
        text = models.TextField()
        date_added = models.DateTimeField(auto_now_add=True)
    
        class Meta:
            verbose_name_plural = 'entries'
    
        def __str__(self):
            """返回模型的字符串表示"""
            return self.text[:50] + "..."

首先导入了`django.contrib.auth`中的模型User，然后在Topic中添加了字段owner，它建立到模型User的外键关系。

*  确定当前有哪些用户：

迁移数据库时，Django将对数据库进行修改，使其能够存储主题和用户之间的关联。为执行迁移，Django需要知道该将各个既有主题关联到哪个用户。最简单的办法是，将既有主题都关联到同一个用户，如超级用户。为此，我们需要知道用户的ID。

# python manage.py shell
    
    >>> from django.contrib.auth.models import User
    
    >>> User.objects.all()
    <QuerySet [<User: ll_admin>, <User: lzx>]>
    
    >>> for user in User.objects.all():
    ...     print(user.username, user.id)
    ... 
    ll_admin 1
    lzx 2

*  迁移数据库：

# python manage.py makemigrations learning_logs
    
    Select an option: 1                 #选择第1个选项——现在提供默认值
    
    >>> 1               #输入用户ID
    Migrations for 'learning_logs':
      learning_logs/migrations/0003_topic_owner.py
        - Add field owner to topic

将所有既有主题都关联到管理用户ll\_admin，我输入了用户ID值1。并非必须使用超级用户，也可使用已创建的任何用户的ID。

# python manage.py migrate #执行迁移
    
    # python manage.py shell
    
    >>> from learning_logs.models import Topic
    
    >>> for topic in Topic.objects.all():
    ...     print(topic, topic.owner)
    ... 
    Chess ll_admin
    Rock Climbing ll_admin

可以看到，每个主题的所有者是超级用户ll\_admin。

> 注意：也可以重置数据库而不是迁移它，但如果这样做，既有的数据都将丢失。如果确实想要一个新的数据库，可以执行命令`python manage.py flush`，这会重建数据库的结构。如果你这样做，就需要重新创建超级用户，且原来的所有数据都将丢失。

--------------------

#### 只允许用户访问自己的主题 ####

*  修改视图函数`views.py`：

# vim learning_logs/views.py

@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)

用户登录后，request对象将有一个`user`属性，这个属性存储了有关该用户的信息。代码`Topic.objects.filter(owner=request.user)`让Django只从数据库中获取`owner`属性为当前用户的Topic对象。

要查看结果，以所有既有主题关联到的用户的身份登录（这里我们是ll\_admin）并访问topics页面，你将看到所有的主题。然后，注销并以另一个用户的身份登录，topics页面将不会列出任何主题。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 15]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 16]

--------------------

#### 保护用户的主题 ####

接下来限制对单个主题的页面的访问。

*  修改视图函数`views.py`：

# vim learning_logs/views.py

from django.http import HttpResponseRedirect, Http404               #导入Http404
    
    @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)

服务器上没有请求的资源时，标准的做法是返回404响应。首先导入了异常Http404，并在用户请求它不能查看的主题时引发这个异常。收到主题请求后，在渲染网页前检查该主题是否属于当前登录的用户。如果请求的主题不归当前用户所有，我们就引发Http404异常，让Django返回一个404错误页面。

--------------------

#### 保护页面`edit_entry` ####

页面`edit_entry`的URL为`http://192.168.30.128:8000/edit_entry/entry_id/`，其中`entry_id`是一个数字。下面来保护这个页面，禁止用户通过输入类似于前面的URL来访问其他用户的条目。

*  修改视图函数`views.py`：

# vim learning_logs/views.py

@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':
            # 初次请求，使用当前条目填充表单
            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/new_entry.html', context)

获取指定的条目以及与之相关联的主题，然后检查主题的所有者是否是当前登录的用户，如果不是，就引发Http404异常。

--------------------

#### 将新主题关联到当前用户 ####

当前，用于添加新主题的页面存在问题。如果你尝试添加新主题，将看到错误消息IntegrityError，指出`learning_logs_topic.user_id`不能为NULL 。Django的意思是说，创建新主题时，你必须指定其owner字段的值。

*  修改视图函数`views.py`：

# vim learning_logs/views.py

@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)

首先调用`form.save()`，并传递实参`commit=False`，因为我们先修改新主题，再将其保存到数据库中。

接下来，将新主题的`owner`属性设置为当前用户。最后，对刚定义的主题实例调用`save()`。现在主题包含所有必不可少的数据，将被成功地保存。

现在，这个项目允许任何用户注册，而每个用户想添加多少新主题都可以。但每个用户都只能访问自己的数据，无论是查看数据、输入新数据还是修改旧数据时都如此。

--------------------

[forms.py]: http://xn--forms-ep5h60hksaf4dbwotwnvl5b1w7a7l4ckpdor5e.py
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70]: /images/20211209/9c9c83f9aae24e86a0cb738591fb3fb7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 1]: /images/20211209/73fff138f67048d983176c6433c3420f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 2]: /images/20211209/95aa2e4f17c74ee09bf8d2c334149ae6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 3]: /images/20211209/b7494952c06a46c787cfdbb469786553.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 4]: /images/20211209/e95090215b79442987af378ec028606e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 5]: /images/20211209/b9a92bd6d3c048d5b5459db35d1913c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 6]: /images/20211209/d45255fd131e42febbf46fc81146ac97.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 7]: /images/20211209/43c2ac4852a94dee918003d481c719f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 8]: /images/20211209/f89470f574bb4d9c80a560ad40588cd7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 9]: /images/20211209/d597cab70d1f4f20a760a2612cfa009a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 10]: /images/20211209/3925b7a614254882853ee84014fe5812.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 11]: /images/20211209/92272810396b426d8beff6d6f16c1a4d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 12]: /images/20211209/f9c07793df114eb3be5c62413d8ef37d.png
[settings.py]: http://xn--settings-0n3mm27o.py
[settings.py 1]: http://xn--settings-0n3mm27obo5et37a.py
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 13]: /images/20211209/e9399b5737bc4748800658684d4f86a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 14]: /images/20211209/116c584d611748d6a6bc064abd05473a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 15]: /images/20211209/74eb56440a324eada409f260907d5d96.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pc3MxMTgxMjQ4OTgz_size_16_color_FFFFFF_t_70 16]: /images/20211209/a16b0d9c181c4cac878316a2bba9be53.png