# myproject/apps/idea/models.py
import uuid

from django.db import models
from django.urls import reverse
from django.conf import settings
from django.utils.translation import gettext_lazy as _

from myproject.apps.core.model_fields import TranslatedField 
from myproject.apps.core.models import (
  CreationModificationDateBase, UrlBase
)

RATING_CHOICES = ( 
  (1, "★☆☆☆☆"), 
  (2, "★★☆☆☆"), 
  (3, "★★★☆☆"), 
  (4, "★★★★☆"), 
  (5, "★★★★★"),
)

class Idea(CreationModificationDateBase, UrlBase):
  uuid = models.UUIDField(
    primary_key=True, default=uuid.uuid4, editable=False
  )
  author = models.ForeignKey(
    settings.AUTH_USER_MODEL, 
    verbose_name=_("Author"), 
    on_delete=models.SET_NULL, 
    blank=True,
    null=True,
    related_name="authored_ideas", 
  )
  title = models.CharField(_("Title"), max_length=200) 
  content = models.TextField(_("Content"))

  categories = models.ManyToManyField(
    "categories.Category", 
    verbose_name=_("Categories"), 
    related_name="category_ideas",
  )
  rating = models.PositiveIntegerField(
    _("Rating"), 
    choices=RATING_CHOICES, 
    blank=True, 
    null=True 
  )
  translated_title = TranslatedField("title") 
  translated_content = TranslatedField("content")

  class Meta:
    verbose_name = _("Idea") 
    verbose_name_plural = _("Ideas")

  def __str__(self): 
    return self.title

  def get_url_path(self):
    return reverse("ideas:idea_detail", kwargs={"pk": self.pk})

class IdeaTranslations(models.Model):
  idea = models.ForeignKey(
    Idea, 
    verbose_name=_("Idea"), 
    on_delete=models.CASCADE, 
    related_name="translations",
  )
  language = models.CharField(_("Language"), max_length=7)
  title = models.CharField(_("Title"), max_length=200) 
  content = models.TextField(_("Content"))

  class Meta:
    verbose_name = _("Idea Translations") 
    verbose_name_plural = _("Idea Translations") 
    ordering = ["language"]
    unique_together = [["idea", "language"]]

  def __str__(self): 
    return self.title

# myproject/apps/categories/models.py
from django.db import models
from django.utils.translation import gettext_lazy as _

from myproject.apps.core.model_fields import TranslatedField

class Category(models.Model):
  title = models.CharField(_("Title"), max_length=200)

  translated_title = TranslatedField("title")

  class Meta:
    verbose_name = _("Category") 
    verbose_name_plural = _("Categories")

  def __str__(self): 
  return self.title

class CategoryTranslations(models.Model): 
  category = models.ForeignKey(
    Category, 
    verbose_name=_("Category"), 
    on_delete=models.CASCADE, 
    related_name="translations",
  )
  language = models.CharField(_("Language"), max_length=7)

  title = models.CharField(_("Title"), max_length=200)

  class Meta:
    verbose_name = _("Category Translations") 
    verbose_name_plural = _("Category Translations") 
    ordering = ["language"]
    unique_together = [["category", "language"]]

  def __str__(self): 
    return self.title

# myprojects/apps/ideas/forms.py
    from django import forms 
    from .models import Idea

    class IdeaForm(forms.ModelForm): 
      class Meta:
        model = Idea 
        fields = "__all__"

from django.contrib.auth.decorators import login_required
from django.shortcuts import render, redirect, get_object_or_404 
from django.views.generic import ListView, DetailView

from .forms import IdeaForm
from .models import Idea

class IdeaList(ListView): 
  model = Idea

class IdeaDetail(DetailView): 
  model = Idea
  context_object_name = "idea"

@login_required
def add_or_change_idea(request, pk=None):
  idea = None 
  if pk:
    idea = get_object_or_404(Idea, pk=pk)

  if request.method == "POST": 
    form = IdeaForm(
      data=request.POST, 
      files=request.FILES, 
      instance=idea
    )

    if form.is_valid():
      idea = form.save()
      return redirect("ideas:idea_detail", pk=idea.pk)
  else:
    form = IdeaForm(instance=idea)

  context = {"idea": idea, "form": form}
  return render(request, "ideas/idea_form.html", context)

@login_required
def delete_idea(request, pk):
  idea = get_object_or_404(Idea, pk=pk) 
  if request.method == "POST":
    idea.delete()
    return redirect("ideas:idea_list")
  context = {"idea": idea}
  return render(request, "ideas/idea_deleting_confirmation.html", context)

3.  在ideas应用创建urls.py文件并添加URL规则：

from django.urls import path

from .views import ( 
  IdeaList,
  IdeaDetail,
  add_or_change_idea,
  delete_idea,
)

urlpatterns = [
  path("", IdeaList.as_view(), name="idea_list"),
  path("add/", add_or_change_idea, name="add_idea"), 
  path("<uuid:pk>/", IdeaDetail.as_view(), name="idea_detail"), 
  path("<uuid:pk>/change/", add_or_change_idea, name="change_idea"),
  path("<uuid:pk>/delete/", delete_idea, name="delete_idea"),
]

4.  现在我们把这些URL规则插入到项目的URL配置中。我们还会包含Django社区的auth应用中的账户URL规则，这样@login_required装饰器就可以正常运行了：

 ```
# myproject/urls.py
    from django.contrib import admin
    from django.conf.urls.i18n import i18n_patterns 
    from django.urls import include, path
    from django.conf import settings
    from django.conf.urls.static import static 
    from django.shortcuts import redirect

    urlpatterns = i18n_patterns(
      path("", lambda request: redirect("ideas:idea_list")), 
      path("admin/", admin.site.urls),
      path("accounts/", include("django.contrib.auth.urls")), 
      path("ideas/", include(("myproject.apps.ideas.urls", "ideas"), namespace="ideas")),
    )
    urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
    urlpatterns += static("/media/", document_root=settings.MEDIA_ROOT)

{% load i18n %}
<a href="{% url 'ideas:change_idea' pk=idea.pk %}">{% trans "Change this idea" %}</a>
<a href="{% url 'ideas:add_idea' %}">{% trans "Add idea" %}</a>

from django import forms 
from .models import Idea

class IdeaForm(forms.ModelForm): 
  class Meta:
    model = Idea
    exclude = ["author"]

  def __init__(self, request, *args, **kwargs): 
    self.request = request 
    super().__init__(*args, **kwargs)

  def save(self, commit=True):
    instance = super().save(commit=False) 
    instance.author = self.request.user 
    if commit:
      instance.save()
      self.save_m2m() 
    return instance

2.  修改视图来添加或修改idea：

 ```
# myproject/apps/ideas/views.py
    from django.contrib.auth.decorators import login_required
    from django.shortcuts import render, redirect, get_object_or_404

    from .forms import IdeaForm 
    from .models import Idea

    @login_required
    def add_or_change_idea(request, pk=None):
      idea = None 
      if pk:
        idea = get_object_or_404(Idea, pk=pk)
      if request.method == "POST":
        form = IdeaForm(request, data=request.POST, files=request.FILES, instance=idea) 
        if form.is_valid():
          idea = form.save()
          return redirect("ideas:idea_detail", pk=idea.pk)
      else:
        form = IdeaForm(request, instance=idea)

      context = {"idea": idea, "form": form}
      return render(request, "ideas/idea_form.html", context)

(env)$ pip install Pillow
(env)$ pip install django-imagekit==4.0.2

import os

from imagekit.models import ImageSpecField 
from pilkit.processors import ResizeToFill

from django.db import models
from django.utils.translation import gettext_lazy as _ 
from django.utils.timezone import now as timezone_now

from myproject.apps.core.models import (
  CreationModificationDateBase, 
  UrlBase
)

def upload_to(instance, filename):
  now = timezone_now()
  base, extension = os.path.splitext(filename) 
  extension = extension.lower()
  return f"ideas/{now:%Y/%m}/{instance.pk}{extension}"

class Idea(CreationModificationDateBase, UrlBase): # attributes and fields...
  picture = models.ImageField(
    _("Picture"), upload_to=upload_to 
  )
  picture_social = ImageSpecField( 
    source="picture",
    processors=[ResizeToFill(1024, 512)], 
    format="JPEG",
    options={"quality": 100},
  )
  picture_large = ImageSpecField(
    source="picture", 
    processors=[ResizeToFill(800, 400)], 
    format="PNG"
  )
  picture_thumbnail = ImageSpecField(
    source="picture", 
    processors=[ResizeToFill(728, 250)], 
    format="PNG"
  )
  # other fields, properties, and methods...

  def delete(self, *args, **kwargs):
    from django.core.files.storage import default_storage 
    if self.picture:
      with contextlib.suppress(FileNotFoundError): 
        default_storage.delete(
          self.picture_social.path 
          )
        default_storage.delete( 
          self.picture_large.path
        ) 
        default_storage.delete(
          self.picture_thumbnail.path 
        )
      self.picture.delete() 
    super().delete(*args, **kwargs)

2.  和前面小节中一样，在forms.py中为Idea模型创建模型表单IdeaForm。
3.  在添加或修改idea的视图中，确保在表单中在request.POST之后post请求还提交request.FILES：

from django.contrib.auth.decorators import login_required
from django.shortcuts import (render, redirect, get_object_or_404) 
from django.conf import settings

from .forms import IdeaForm 
from .models import Idea

@login_required
def add_or_change_idea(request, pk=None): 
  idea = None
  if pk:
    idea = get_object_or_404(Idea, pk=pk) 
  if request.method == "POST":
    form = IdeaForm( request,
      data=request.POST, 
      files=request.FILES, 
      instance=idea,
    )
    if form.is_valid():
      idea = form.save()
      return redirect("ideas:idea_detail", pk=idea.pk)
  else:
    form = IdeaForm(request, instance=idea)

  context = {"idea": idea, "form": form}
  return render(request, "ideas/idea_form.html", context)

4.  在模板中，记得为multipart/form- data设置编码类型，如下：

> 如果像*通过django-crispy-forms创建表单布局*一节中所描述那样使用django-crispy-form，则会在表单中自动添加enctype属性。

### 实现原理...

Django模型表单是动态地由模型进行创建的。它们提供来自模型的指定字段，因此无需在表单中手动重新定义这些字段。在前例中，我们为Idea模型创建了一个模型表单。在保存表单时，表单会知道在数据库中如何保存每个字段、如何上传文件并在media目录中进行保存。

本例中的upload_to() 函数用于将图片保存到指定目录并重新定义其名称，这样不会与其它模型实例中的文件名相冲突。每个文件保存的路径类似ideas/2020/01/0422c6fe- b725-4576-8703-e2a9d9270986.jpg，其中包含上传的年、月以及Idea实例的主键。

> 一些文件系统（如FAT32和NTFS）对每个目录中的文件存在上限；因此按照上传日期、字母或其它条件分割到不同目录是一种好实践。

我们使用django-imagekit中的ImageSpecField来创建3种图片规格：

*   picture_social用于社交分享
*   picture_large用于详情视图
*   picture_thumbnail用于列表视图

图片规格在数据库中不进行关联，而只是在CACHE/images/ideas/2020/01/0422c6fe-b725-4576-8703- e2a9d9270986/这样的文件路径中按默认文件存储进行保存。

在模板中，可以按如下使用原始或指定图片版本：

在Idea模型定义最后，我们重写了delete()方法来在删除Idea实例本身之前从磁盘上删除各版本图片及图片本身。

### 相关内容

*   *通过django-crispy-forms创建表单布局*一节
*   [**第4章 模板和JavaScript**](https://alanhou.org/django3-templates-javascript/)中的*编排base.html模板*一节
*   [**第4章 模板和JavaScript**](https://alanhou.org/django3-templates-javascript/)中的*使用响应式图片*一节

## 通过自定义模型创建表单布局

在Django的早前版本中，所有表单的渲染都独立放在Python代码中处理，但从Django 1.11开始，就引入了基于模板的表单组件渲染。在本小节中，我们将学习如何对表单组件使用自定义模板。我们会使用Django后台表单来讲解自定义组件模板如何提升字段的易用性。

### 准备工作

我们先创建Idea模型的默认后台管理并添加翻译：

此时如访问ideas的后台表单，界面类似下面这样：

![](https://upload-images.jianshu.io/upload_images/14565748-8e13f6e56c6784a2.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

### 如何实现...

学习本小节，需执行如下步骤：

1.  通过将django.forms添加到INSTALLED_APPS中、在模板配置中将APP_DIRS标记设置为True并使用TemplatesSetting表单渲染器来确保模板系统能够发现自定义模板：

 ```
# myproject/settings/_base.py
    INSTALLED_APPS = [ 
      "django.contrib.admin", 
      "django.contrib.auth", 
      "django.contrib.contenttypes", 
      "django.contrib.sessions", 
      "django.contrib.messages", 
      "django.contrib.staticfiles", 
      "django.forms",
      # other apps... 
    ]

    TEMPLATES = [ 
      {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [os.path.join(BASE_DIR, "myproject", "templates")], 
        "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", 
            "django.template.context_processors.media", 
            "django.template.context_processors.static", 
            "myproject.apps.core.context_processors .website_url",
          ] 
        },
      } 
    ]

    FORM_RENDERER = "django.forms.renderers.TemplatesSetting"

from django import forms
from django.contrib import admin
from django.utils.translation import gettext_lazy as _

from myproject.apps.core.admin import LanguageChoicesForm

from myproject.apps.categories.models import Category
from .models import Idea, IdeaTranslations

class IdeaTranslationsForm(LanguageChoicesForm):
  class Meta:
    model = IdeaTranslations 
    fields = "__all__"

class IdeaTranslationsInline(admin.StackedInline): 
  form = IdeaTranslationsForm
  model = IdeaTranslations
  extra = 0

class IdeaForm(forms.ModelForm):
  categories = forms.ModelMultipleChoiceField(
    label=_("Categories"), 
    queryset=Category.objects.all(), 
    widget=forms.CheckboxSelectMultiple(), 
    required=True,
  )

  class Meta:
    model = Idea
    fields = "__all__"

  def __init__(self, *args, **kwargs): 
    super().__init__(*args, **kwargs)

    self.fields[ 
      "picture"
    ].widget.template_name = "core/widgets/image.html"

@admin.register(Idea)
class IdeaAdmin(admin.ModelAdmin):
  form = IdeaForm
  inlines = [IdeaTranslationsInline]

  fieldsets = [
    (_("Author and Category"), 
    {"fields": ["author", "categories"]}),
    (_("Title and Content"),  "picture"]}),
    (_("Ratings"), {"fields": ["rating"]}),
  ]

3.  最后，为picture字段创建一个模板：

 ```
{# core/widgets/image.html #}
    {% load i18n %}

    <div style="margin-left: 160px; padding-left: 10px;"> 
      {% if widget.is_initial %}
        <a href="{{ widget.value.url }}">
          &lt;img src="{{ widget.value.url }}" width="624" height="auto" alt="" /&gt;
        </a>
        {% if not widget.required %}&lt;br /&gt;
          {{ widget.clear_checkbox_label }}:
          &lt;input type="checkbox" name="{{ widget.checkbox_name }}" id="{{ widget.checkbox_id }}"&gt; 
        {% endif %}&lt;br /&gt;
        {{ widget.input_text }}: 
      {% endif %}
      &lt;input type="{{ widget.type }}" name="{{ widget.name }}"{% include "django/forms/widgets/attrs.html" %}&gt;
    &lt;/div&gt;
    &lt;div class="help"&gt;
      {% trans "Available formats are JPG, GIF, and PNG." %} 
      {% trans "Minimal size is 800 x 800 px." %}
    &lt;/div&gt;

(env)$ pip install django-crispy-forms

INSTALLED_APPS = ( 
  # ...
  "crispy_forms",
  "ideas", 
)
# ...
CRISPY_TEMPLATE_PACK = "bootstrap4"

### 如何实现...

按照如下步骤操作：

1.  修改ideas的模型表单：

 ```
# myproject/apps/ideas/forms.py
    from django import forms
    from django.utils.translation import ugettext_lazy as _ 
    from django.conf import settings
    from django.db import models

    from crispy_forms import bootstrap, helper, layout

    from .models import Idea

    class IdeaForm(forms.ModelForm): 
      class Meta:
        model = Idea 
        exclude = ["author"]

      def __init__(self, request, *args, **kwargs): 
        self.request = request 
        super().__init__(*args, **kwargs)

        self.fields["categories"].widget = forms.CheckboxSelectMultiple()

        title_field = layout.Field(
          "title", css_class="input-block-level"
        )
        content_field = layout.Field(
          "content", css_class="input-block-level", rows="3" 
        )
        main_fieldset = layout.Fieldset(
          _("Main data"), title_field, content_field
        )

        picture_field = layout.Field(
          "picture", css_class="input-block-level"
        )
        format_html = layout.HTML(
          """{% include "ideas/includes/picture_guidelines.html" %}"""
        )
        picture_fieldset = layout.Fieldset( 
          _("Picture"),
          picture_field,
          format_html,
          title=_("Image upload"),
          css_id="picture_fieldset",
        )

        categories_field = layout.Field(
          "categories", css_class="input-block-level"
        )
        categories_fieldset = layout.Fieldset(
          _("Categories"), categories_field,
          css_id="categories_fieldset"
        )

        submit_button = layout.Submit("save", _("Save")) 
        actions = bootstrap.FormActions(submit_button)
        self.helper = helper.FormHelper() 
        self.helper.form_action = self.request.path 
        self.helper.form_method = "POST" 
        self.helper.layout = layout.Layout(
          main_fieldset,
          picture_fieldset,
          categories_fieldset,
          actions,
        )

      def save(self, commit=True):
        instance = super().save(commit=False) 
        instance.author = self.request.user 
        if commit:
          instance.save()
          self.save_m2m() 
        return instance

3.  最后更新ideas表单的模板：

 ```
{# ideas/idea_form.html #}
    {% extends "base.html" %}
    {% load i18n crispy_forms_tags static %}

    {% block content %}
      <a href="{% url ">{% trans "List of ideas" %}</a>
      &lt;h1&gt;
        {% if idea %}
          {% blocktrans trimmed with title=idea.translated_title %} 
            Change Idea "{{ title }}
          {% endblocktrans %}
        {% else %}
          {% trans "Add Idea" %}
        {% endif %}
      &lt;/h1&gt;
      {% crispy form %}
    {% endblock %}

from django import forms
from django.utils.translation import ugettext_lazy as _ 
from django.conf import settings
from django.db import models

from crispy_forms import bootstrap, helper, layout

from .models import Idea, IdeaTranslations

class IdeaForm(forms.ModelForm): 
  class Meta:
    model = Idea 
    exclude = ["author"]
  def __init__(self, request, *args, **kwargs): 
    self.request = request 
    super().__init__(*args, **kwargs)

    self.fields["categories"].widget = forms.CheckboxSelectMultiple()

    title_field = layout.Field(
      "title", css_class="input-block-level"
    )
    content_field = layout.Field(
      "content", css_class="input-block-level", rows="3" 
    )
    main_fieldset = layout.Fieldset(
      _("Main data"), title_field, content_field
    )
    picture_field = layout.Field(
      "picture", css_class="input-block-level"
    )
    format_html = layout.HTML(
      """{% include "ideas/includes/picture_guidelines.html" %}"""
    )

    picture_fieldset = layout.Fieldset(
      _("Picture"), 
      picture_field, 
      format_html, 
      title=_("Image upload"), 
      css_id="picture_fieldset",
    )

    categories_field = layout.Field(
      "categories", css_class="input-block-level"
    )
    categories_fieldset = layout.Fieldset(
      _("Categories"), categories_field,
      css_id="categories_fieldset" )

    inline_translations = layout.HTML(
      """{% include "ideas/forms/translations.html" %}"""
    )

    submit_button = layout.Submit("save", _("Save")) 
    actions = bootstrap.FormActions(submit_button)

    self.helper = helper.FormHelper() 
    self.helper.form_action = self.request.path 
    self.helper.form_method = "POST" 
    self.helper.layout = layout.Layout(
      main_fieldset,
      inline_translations,
      picture_fieldset,
      categories_fieldset,
      actions,
    )

  def save(self, commit=True):
    instance = super().save(commit=False) 
    instance.author = self.request.user 
    if commit:
      instance.save()
      self.save_m2m() 
    return instance

2.  然后，同一文件的最后添加IdeaTranslationsForm：

 ```
class IdeaTranslationsForm(forms.ModelForm): 
      language = forms.ChoiceField(
        label=_("Language"), 
        choices=settings.LANGUAGES_EXCEPT_THE_DEFAULT, 
        required=True,
      )

      class Meta:
        model = IdeaTranslations
        exclude = ["idea"]

      def __init__(self, request, *args, **kwargs): 
        self.request = request 
        super().__init__(*args, **kwargs)

        id_field = layout.Field("id") 
        language_field = layout.Field(
          "language", css_class="input-block-level" 
        )
        title_field = layout.Field(
          "title", css_class="input-block-level"
        )
        content_field = layout.Field(
          "content", css_class="input-block-level", rows="3" 
        )
        delete_field = layout.Field("DELETE") 
        main_fieldset = layout.Fieldset(
          _("Main data"),
          id_field,
          language_field,
          title_field,
          content_field,
          delete_field,
        )

        self.helper = helper.FormHelper() 
        self.helper.form_tag = False 
        self.helper.disable_csrf = True 
        self.helper.layout = layout.Layout(main_fieldset)

from django.contrib.auth.decorators import login_required
from django.shortcuts import render, redirect, get_object_or_404 
from django.forms import modelformset_factory
from django.conf import settings

from .forms import IdeaForm, IdeaTranslationsForm 
from .models import Idea, IdeaTranslations

@login_required
def add_or_change_idea(request, pk=None):
  idea = None 
  if pk:
    idea = get_object_or_404(Idea, pk=pk)
  IdeaTranslationsFormSet = modelformset_factory(
    IdeaTranslations, form=IdeaTranslationsForm,
    extra=0, can_delete=True
  )
  if request.method == "POST":
    form = IdeaForm(request, data=request.POST,
    files=request.FILES, instance=idea)
    translations_formset = IdeaTranslationsFormSet( 
      queryset=IdeaTranslations.objects.filter(idea=idea), 
      data=request.POST,
      files=request.FILES,
      prefix="translations",
      form_kwargs={"request": request},
    )
    if form.is_valid() and translations_formset.is_valid(): 
      idea = form.save()
      translations = translations_formset.save(
        commit=False
      )
      for translation in translations: 
        translation.idea = idea 
        translation.save()
      translations_formset.save_m2m() 
      for translation in translations_formset.deleted_objects: 
        translation.delete()
      return redirect("ideas:idea_detail", pk=idea.pk)
  else:
    form = IdeaForm(request, instance=idea) 
    translations_formset = IdeaTranslationsFormSet(
      queryset=IdeaTranslations.objects.filter(idea=idea),
      prefix="translations",
      form_kwargs={"request": request},
     )
    context = { 
      "idea": idea,
      "form": form,
      "translations_formset": translations_formset
    }
    return render(request, "ideas/idea_form.html", context)

4.  然后，编辑idea_form.html模板并在最后添加对inlines.js脚本的引用：

 ```
{# ideas/idea_form.html #}
    {% extends "base.html" %}
    {% load i18n crispy_forms_tags static %}

    {% block content %}
        <a href="{% url ">{% trans "List of ideas" %}</a>
        &lt;h1&gt;
            {% if idea %}
                {% blocktrans trimmed with title=idea.translated_title %} 
                    Change Idea "{{ title }}"
                {% endblocktrans %}
            {% else %}
                {% trans "Add Idea" %}
            {% endif %}
        &lt;/h1&gt;
        {% crispy form %}
    {% endblock %}

    {% block js %}
        &lt;script src="{% static 'site/js/inlines.js' %}"&gt;&lt;/script&gt;
    {% endblock %}

6.  最后，添加JavaScript来操作表单集：

$(function () {
    function reinit_widgets($formset_form) {
        $(window.WIDGET_INIT_REGISTER).each(function (index, func)
        {
            func($formset_form);
        });
    }

    function set_index_for_fields($formset_form, index) { 
        $formset_form.find(':input').each(function () {
            var $field = $(this); 
            if ($field.attr("id")) {
                $field.attr( 
                    "id",
                    $field.attr("id").replace(/-__prefix__-/, "-" + index + "-")
                ); 
            }
            if ($field.attr("name")) { 
                $field.attr(
                    "name",
                    $field.attr("name").replace( 
                        /-__prefix__-/, "-" + index + "-"
                    )
                );
            }
        });    
        $formset_form.find('label').each(function () { 
            var $field = $(this);
            if ($field.attr("for")) {
                $field.attr( 
                    "for",
                    $field.attr("for").replace( 
                        /-__prefix__-/, "-" + index + "-"
                    ) 
                );
            }
        });
        $formset_form.find('div').each(function () { 
            var $field = $(this);
            if ($field.attr("id")) {
                $field.attr( 
                    "id",
                    $field.attr("id").replace( 
                        /-__prefix__-/, "-" + index + "-"
                    ) 
                );
            }
        });
    }

    function add_delete_button($formset_form) { 
        $formset_form.find('input:checkbox[id$=DELETE]')
        .each(function () {
            var $checkbox = $(this); 
            var $deleteLink = $(
                '<button class="delete btn btn-sm btn-danger mb-3">Remove</button>'
            );
            $formset_form.append($deleteLink); 
            $checkbox.closest('.form-group').hide();
        }); 
    }

    $('.add-inline-form').click(function (e) { 
        e.preventDefault();
        var $formset = $(this).closest('.formset');
        var $total_forms = $formset.find('[id$="TOTAL_FORMS"]');
        var $new_form = $formset.find('.empty-form').clone(true).attr("id", null); 
        $new_form.removeClass('empty-form d-none').addClass('formset-form'); 
        set_index_for_fields($new_form, parseInt($total_forms.val(), 10)); 
        $formset.find('.formset-forms').append($new_form); 
        add_delete_button($new_form); 
        $total_forms.val(parseInt($total_forms.val(), 10) + 1); 
        reinit_widgets($new_form);
    });
    $('.formset-form').each(function () {
        $formset_form = $(this); 
        add_delete_button($formset_form); 
        reinit_widgets($formset_form);
    });
    $(document).on('click', '.delete', function (e) {
        e.preventDefault();
        var $formset = $(this).closest('.formset-form'); 
        var $checkbox = $formset.find('input:checkbox[id$=DELETE]'); 
        $checkbox.attr("checked", "checked"); 
        $formset.hide();
    }); 
});

### 实现原理...

读者可能通过Django模型管理后台已经了解到表单集了。表单集在那里用于对于父模型拥有外键的子模型的行内机制。

本节中，我们使用django-crispy-forms对idea表单添加了表单集。结果如下：

![](https://upload-images.jianshu.io/upload_images/14565748-1cecf5c626343262.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

可以看出，我们不一定要在表单的结尾处插入表单集，而是在中间任意有作用之处皆可。本例中，把翻译放到可翻译字段之后有实际意义。

翻译表单的表单布局像IdeaForm的布局一样有fieldset，但除此之外，还有识别每个模型实例所需的id及进行删除时使用的DELETE字段。DELETE字段实际上是一个复选框，在选中时从数据库中删除相应内容。同时，翻译的表单helper中有form_tag=False，不生成<form>标签，disable_csrf=True会不包含CSRF令牌，因为我们已经在其父表单IdeaForm中进行过定义。

在表单中，如果请求由POST方法发送，且表单和表单集有效，那么会保存表单并创建相应的翻译实例，不事先进行保存。这通过commit=False属性实现。我们为每个翻译实例分配idea，然后将翻译内容保存到数据库中。最后，查看表单集中的表单是有否标记为删除的并从数据库中进行相应的删除。

在translations.html模板中，我们在表单集中渲染每个表单，然后添加一个额外的隐藏空表单，它由JavaScript用来在表单集中生成动态添加的新表单。

表单集中的每个表单对每个字段有前缀。如，表单集的第一个表单的title字段会有一个HTML字段名translations-0-title，同一表单集中的DELETE字段拥有HTML字段名translations-0- DELETE。空表单使用的是__prefix__来代替索引号，如translations-__prefix__-title。这在Django层进行的抽象，但在通过JavaScript操作表单集中表单时需要知晓。

inlines.js JavaScript脚本执行了如下操作：

*   对表单集中的已有表单，它初始化JavaScript驱动的组件（可以使用提示消息、日期或颜色拾取器、地图等）并创建一个删除按钮，用于代替DELETE复选框进行显示。
*   在点击删除按钮时，它会勾选DELETE复选框并对用户隐藏表单。
*   在点击添加按钮时，它会复制一个空表单并将__prefix__替换为下一个可用索引、向列表添加新表单并初始化JavaScript驱动的组件。

### 扩展知识...

JavaScript使用数组window.WIDGET_INIT_REGISTER，它包含应由给定表单初始化组件时调用的函数。要在另一个JavaScript文件中注册新函数时，可以使用如下代码：

这会对所有包含data-toggle="tooltip"和title属性的表单应用提示消息功能，如下例所示：

### 相关内容

*   *通过django-crispy-forms创建表单布局*一节
*   [**第4章 模板和JavaScript**](https://alanhou.org/django3-templates-javascript/)中的*编排base.html模板*一节

## 过滤对象列表

在网页开发中，除带表单的视图外，对象列表视图和详情视图也很常见。列表视图可以简单列举已排序的对象，如，按字母排序或创建日期排序；但庞大的数据量对用户不友好。为实现最好的可用性和便捷性，应当能够通过所有可用分类对内容进行过滤。本节中，我们将学习用于对过分类号过滤列表视图的模式。

我们会创建一个ideas的列表视图，可通过作者、分类或评分进行过滤。应用了Bootstrap 4之后效果类似下面这样：

![](https://upload-images.jianshu.io/upload_images/14565748-07e5025af08137aa.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

### 准备工作

这个过滤示例，我们将使用Idea模型关联作者和分类进行过滤。也可以通过评分进行过滤，即带选项的PositiveIntegerField。我们使用的是前面小节中所创建的ideas应用。

### 如何实现...

按照如下步骤完成本小节的学习：

1.  创建IdeaFilterForm进行可用分类的过滤：

from django import forms
from django.utils.translation import ugettext_lazy as _ 
from django.db import models
from django.contrib.auth import get_user_model

from myproject.apps.categories.models import Category

from .models import RATING_CHOICES

User = get_user_model()

class IdeaFilterForm(forms.Form): 
    author = forms.ModelChoiceField(
        label=_("Author"), 
        required=False, 
        queryset=User.objects.annotate(
            idea_count=models.Count("authored_ideas") 
        ).filter(idea_count__gt=0),
    )
    category = forms.ModelChoiceField(
        label=_("Category"), 
        required=False, 
        queryset=Category.objects.annotate(
            idea_count=models.Count("category_ideas") 
        ).filter(idea_count__gt=0),
    )
    rating = forms.ChoiceField(
        label=_("Rating"), required=False, choices=RATING_CHOICES 
    )

2.  创建idea_list视图来列举过滤后的ideas：

from django.shortcuts import render, redirect, get_object_or_404 
from django.conf import settings

from .forms import IdeaFilterForm
from .models import Idea, RATING_CHOICES

PAGE_SIZE = getattr(settings, "PAGE_SIZE", 24)

def idea_list(request):
    qs = Idea.objects.order_by("title") 
    form = IdeaFilterForm(data=request.GET)

    facets = { 
        "selected": {},
        "categories": {
            "authors": form.fields["author"].queryset, 
            "categories": form.fields["category"].queryset, 
            "ratings": RATING_CHOICES,
        }, 
    }

    if form.is_valid(): 
        filters = (
            # query parameter, filter parameter
            ("author", "author"),
            ("category", "categories"),
            ("rating", "rating"),
        )
        qs = filter_facets(facets, qs, form, filters)

    context = {"form": form, "facets": facets, "object_list": qs} 
    return render(request, "ideas/idea_list.html", context)

3.  在同一个文件中添加帮助函数filter_facets()：

4.  如未创建，请创建base.html模板。可以参照[**第4章 模板和JavaScript**](https://alanhou.org/django3-templates-javascript/)中的*编排base.html模板*一节的示例。
5.  创建idea_list.html 模型并添加如下内容：

 ```
{# ideas/idea_list.html #}
    {% extends "base.html" %} 
    {% load i18n utility_tags %}

    {% block sidebar %}
      {% include "ideas/includes/filters.html" %}
    {% endblock %}

    {% block main %}
      <h1>{% trans "Ideas" %}</h1>
      {% if object_list %}
        {% for idea in object_list %}
          <a href="{{ idea.get_url_path }}">
            &lt;div class="card"&gt;
              &lt;img src="{{ idea.picture_thumbnail.url }}" alt="" /&gt;
              &lt;div class="card-body"&gt;
                &lt;p class="card-text"&gt;{{ idea.translated_title }}&lt;/p&gt;
              &lt;/div&gt;
            &lt;/div&gt;
          </a>
        {% endfor %}
      {% else %}
        &lt;p&gt;{% trans "There are no ideas yet." %}&lt;/p&gt;
      {% endif %}
      <a href="{% url 'ideas:add_idea' %}">{% trans "Add idea" %}</a>
    {% endblock %}

7.  每个分类在边栏中遵循通用的模式，因此我们可以创建并包含带有通用部分的模板。首先有过滤头部，对应文件为 misc/includes/filter_heading.html，如下：

8.  然后每个过滤器会包含重置该分类过滤器的链接，这里位于misc/includes/filter_all.html。这个模板还使用{% modify_query %}模板标签，参见[**第5章 自定义模板过滤器和标签**](https://alanhou.org/django3-custom-template-filters-tags/)中的*创建模板标签来修改请求查询参数*一节：

9.  这个idea列表需要添加到ideas应用的URL中：

from django.urls import path

from .views import idea_list

urlpatterns = [
  path("", idea_list, name="idea_list"), 
  # other paths...
]

### 实现原理...

我们使用facets字典，传递给模板上文来知道有哪些过滤器以及选中了哪些过滤器。再深入一点，facets字典包含两块：categories字典和selected字典。categories字典包含查询集或所有分类的选项。selected字典包含当前每个分类的选中值。在IdeaFilterForm中，我们确保只有至少包含一个idea的分类和作者被列举出来。

在视图中，我们检查表单中的查询参数是否有效，然后根据所选中分类过滤对象的查询集。此外，我们为facets字典设置所选中的值，这个字典会传递给模板。

在模板中，对facets字典中的每个分类，我们列举出所有分类并当前选中的分类为活跃状态。如果未选中所给定分类，我们默认标记All为活跃值。

### 相关内容

*   *管理分页列表*一节
*   *编写基于类的视图*一节
*   [**第4章 模板和JavaScript**](https://alanhou.org/django3-templates-javascript/)中*安排base.html模板*一节
*   [**第5章 自定义模板过滤器和标签**](https://alanhou.org/django3-custom-template-filters-tags/)中的*创建模板标签来修改请求查询参数*一节

## 管理分页列表

如果动态地修改了对象列表或其总数超过24等数，很有可能会需要通过分页来提供更好的用户体验。分页不是查询全部集合，而是在数据集中取出对应一页数量的指定个数据项。我们还提供链接来让用户访问组成完整数据的其它页面。Django有一个管理分页数据的类，本节中我们就来学习如何使用。

### 准备工作

我们使用*过滤对象列表一节*中ideas应用的模型、表单和视图。

### 如何实现...

按照如下步骤来向ideas的列表视图添加分页功能：

1.  在views.py文件中导入Django分页类。我们将在过滤代码后对idea_list视图添加分页管理。同时，还会通过向object_list键分配page来微调上下文字典：

 ```
# myproject/apps/ideas/views.py
    from django.shortcuts import render, redirect, get_object_or_404 
    from django.conf import settings
    from django.core.paginator import (EmptyPage, PageNotAnInteger, Paginator)

    from .forms import IdeaFilterForm

    from .models import Idea, RATING_CHOICES

    PAGE_SIZE = getattr(settings, "PAGE_SIZE", 24)

    def idea_list(request):

      qs = Idea.objects.order_by("title") 
      form = IdeaFilterForm(data=request.GET)
      facets = { 
        "selected": {},
        "categories": {
          "authors": form.fields["author"].queryset, 
          "categories": form.fields["category"].queryset, 
          "ratings": RATING_CHOICES,
        }, 
      }

      if form.is_valid(): 
        filters = (
          # query parameter, filter parameter
          ("author", "author"),
          ("category", "categories"),
          ("rating", "rating"),
        )
        qs = filter_facets(facets, qs, form, filters)

      paginator = Paginator(qs, PAGE_SIZE) 
      page_number = request.GET.get("page") 
      try:
        page = paginator.page(page_number) 
      except PageNotAnInteger:
        # If page is not an integer, show first page.
        page = paginator.page(1) 
      except EmptyPage:
        # If page is out of range, show last existing page. 
        page = paginator.page(paginator.num_pages)

      context = { 
        "form": form,
        "facets": facets,
        "object_list": page, 
      }
      return render(request, "ideas/idea_list.html", context)

{% block sidebar %}
  {% include "ideas/includes/filters.html" %}
{% endblock %}

{% block main %}
  <h1>{% trans "Ideas" %}</h1>
  {% if object_list %}
    {% for idea in object_list %}
      <a href="{{ idea.get_url_path }}"> 
        &lt;div class="card"&gt;
          &lt;img src="{{ idea.picture_thumbnail.url }}" alt="" /&gt;
          &lt;div class="card-body"&gt;
            &lt;p class="card-text"&gt;{{ idea.translated_title }}&lt;/p&gt;
          &lt;/div&gt;
        &lt;/div&gt; 
      </a>
    {% endfor %}
    {% include "misc/includes/pagination.html" %}
  {% else %}
    &lt;p&gt;{% trans "There are no ideas yet." %}&lt;/p&gt;
  {% endif %}
  <a href="{% url 'ideas:add_idea' %}">{% trans "Add idea" %}</a>
{% endblock %}

3.  创建分类组件模板：

    <ul>
      {% if object_list.has_previous %}
        <li><a href="{% modify_query page=object_list.previous_page_number %}">{% trans "Previous" %}</a></li>
      {% else %}
        <li>&lt;span class="page- link"&gt;{% trans "Previous" %}&lt;/span&gt;</li>
      {% endif %}

      {% for page_number in object_list.paginator .page_range %}
        {% if page_number == object_list.number %} 
          <li>
            &lt;span class="page-link"&gt;{{ page_number }} 
              &lt;span class="sr-only"&gt;{% trans "(current)" %}&lt;/span&gt;
            &lt;/span&gt;
          </li>
        {% else %}
          <li>
            <a href="{% modify_query page=page_number %}">{{ page_number }}</a>
          </li>
        {% endif %}
      {% endfor %}

      {% if object_list.has_next %}
        <li><a href="{% modify_query page=object_list.next_page_number %}"> {% trans "Next" %}</a></li>
      {% else %}
        <li>&lt;span class="page-link"&gt;{% trans "Next" %}&lt;/span&gt;</li>
      {% endif %}
    </ul> 
  &lt;/nav&gt;
{% endif %}

### 实现原理...

在浏览器中查看结果时，会看到类似下面这样的分页控制器：

![](https://upload-images.jianshu.io/upload_images/14565748-d06d7019b2dbf647.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

这是如何实现的呢？在过滤好查询集合后，我们会创建一个paginator对象，传递查询集合及每页希望显示的最大条数，本例中为24。然后，我们会通过查询参数page读取当前页数。下一步是通过paginator获取当前页对象。如果页数不是整型，则获取第一页。如果页数超出可显示页面数，获取最后一页。page对象中有上图所示分页组件所需的方法和属性。同时，page类似查询集合，可以进行遍历并取出页面中的部分项。

模板中所示的代码片断用Bootstrap 4前端框架创建一个分页组件。仅在页面多于当前页时才会显示分页控件。里面有上一页、下一页，以及组件中所有页码的列表。当前页码进行了高亮显示。我们使用{% modify_query %}来将链接生成URL，这部分在稍后的[**第5章 自定义模板过滤器和标签**](https://alanhou.org/django3-custom-template-filters-tags/)中的*创建模板标签来修改请求查询参数*一节中会进行详细讲解。

### 相关内容

*   *过滤对象列表*一节
*   *编写基于类的视图*一节
*   [**第5章 自定义模板过滤器和标签**](https://alanhou.org/django3-custom-template-filters-tags/)中的*创建模板标签来修改请求查询参数*一节

## 编写基于类的视图

Django视图是可接收请求并返回响应的可调用函数。除了函数形式的视图外，Django还提供了一种通过类定义视图的方式。这种方式在想要创建可复用的模块化视图或合并通用mixin的视图时非常有用。本小节中，我们会将前面的函数视图idea_list化为类视图IdeaListView。

### 准备工作

创建类似前面*过滤对象列表*和*管理分页列表*小节中的模型、表单和模板。

### 如何实现...

按照如下步骤来完成本小节的内容:

1.  我们的类视图IdeaListView继承Django的View类并重载get()方法：

from django.shortcuts import render, redirect, get_object_or_404 
from django.conf import settings
from django.core.paginator import (EmptyPage, PageNotAnInteger, Paginator)
from django.views.generic import View

from .forms import IdeaFilterForm
from .models import Idea, RATING_CHOICES

PAGE_SIZE = getattr(settings, "PAGE_SIZE", 24)

class IdeaListView(View):
  form_class = IdeaFilterForm 
  template_name = "ideas/idea_list.html"

  def get(self, request, *args, **kwargs):
    form = self.form_class(data=request.GET)
    qs, facets = self.get_queryset_and_facets(form) 
    page = self.get_page(request, qs)
    context = {"form": form, "facets": facets, "object_list": page}
    return render(request, self.template_name, context)

  def get_queryset_and_facets(self, form): 
    qs = Idea.objects.order_by("title") 
    facets = {
      "selected": {},
      "categories": {
        "authors": form.fields["author"].queryset, 
        "categories": form.fields["category"].queryset, 
        "ratings": RATING_CHOICES,
      }, 
    }

    if form.is_valid(): 
      filters = (
        # query parameter, filter parameter
        ("author", "author"),
        ("category", "categories"),
        ("rating", "rating"),
      )
      qs = self.filter_facets(facets, qs, form, filters) 
    return qs, facets

  @staticmethod
  def filter_facets(facets, qs, form, filters):
    for query_param, filter_param in filters: 
      value = form.cleaned_data[query_param] 
      if value:
        selected_value = value
        if query_param == "rating":
          rating = int(value) 
          selected_value = (rating, dict(RATING_CHOICES)[rating]) 
          facets["selected"][query_param] = selected_value 
          filter_args = {filter_param: value}
          qs = qs.filter(**filter_args).distinct()
      return qs

  def get_page(self, request, qs):
    paginator = Paginator(qs, PAGE_SIZE) 
    page_number = request.GET.get("page") 
    try:
      page = paginator.page(page_number) 
    except PageNotAnInteger:
      page = paginator.page(1) 
    except EmptyPage:
      page = paginator.page(paginator.num_pages) 
    return page

2.  我们需要在URL配置中使用视图类创建URL规则。你可能已经使用视图函数idea_list添加过规则，方法相似。在URL规则中包含视图类，需要使用as_view()方法如下：

from django.urls import path

from .views import IdeaListView

urlpatterns = [
  path("", IdeaListView.as_view(), name="idea_list"),
  # other paths... 
]

### 实现原理...

由HTTP GET请求所调用的get()方法中所执行的操作如下：

*   首先，我们创建了form对象，对其传递类似字典的request.GET对象。request.GET对象包含所有使用GET方法传递的查询变量。
*   然后，form被传递给get_queryset_and_facets()方法，它通过包含两个元素的元组返回关联值，这两个元素分别为QuerySet和facets。
*   当前的请求对象及所获取的查询集合被传递给get_page()方法，该方法返回页面对象。
*   最后，我们创建一个上下文字典并渲染请求的响应。

我们也可以提供由HTTP POST请求所调用的 post()方法来进行相应的支持。

### 扩展知识...

可以看到，get() 和get_page()方法很通用，因此我们可以在core应用中创建带有这两个方法的FilterableListView通用类。然后，在需要使用可过滤列表的应用中，可以创建继承FilterableListView的视图类处理这种场景。这一继承类只需要定义form_class和template_name属性以及get_queryset_and_facets()方法。这种模板化和扩展性代表了视图类的主要好处。

### 相关内容

*   *过滤对象列表*一节
*   *管理分页列表*一节

## 添加Open Graph和Twitter Card数据

如果希望在社交网站上分享网站的内容，则至少应实现Open Graph和Twitter Card标签。这些元标签定义了网页如何在Facebook或Twitter信息流中显示：展示什么标题和描述，设置什么图片以及关联的URL。本小节中我们将为社交分享准备idea_detail.html模板。

### 准备工作

我们继续使用前面小节中的ideas应用。

### 如何实现...

按照如下步骤来完成本小节的学习：

1.  确保Idea模板创建了图片字段及各个图片版本规格。参见*使用CRUDL函数创建应用*一节和*上传图片*一节了解更多信息。
2.  准备好ideas详情视图。参见*使用CRUDL函数创建应用*一节了解如何添加。
3.  将详情视图插入到URL配置中。相关配置参见*使用CRUDL函数创建应用*一节。
4.  在具体环境的设置中，定义WEBSITE_URL和作为完整媒体文件URL的MEDIA_URL，如下例所示：

 ```
# myproject/settings/dev.py
    from ._base import *

    DEBUG = True
    WEBSITE_URL = "http://127.0.0.1:8000" # without trailing slash 
    MEDIA_URL = f"{WEBSITE_URL}/media/"

from django.conf import settings

def website_url(request):
  return {
    "WEBSITE_URL": settings.WEBSITE_URL,
  }

6.  在设置中插入上下文处理器：

 ```
# myproject/settings/_base.py
    TEMPLATES = [ 
      {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [os.path.join(BASE_DIR, "myproject", "templates")], 
        "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", 
            "django.template.context_processors.media", 
            "django.template.context_processors.static", 
            "myproject.apps.core.context_processors.website_url",
          ]
        } 
      }
    ]

{% block meta_tags %}
  <meta property="og:type" content="website" />
  <meta property="og:url" content="{{ WEBSITE_URL }}{{ request.path }}" />
  <meta property="og:title" content="{{ idea.translated_title }}" />
  {% if idea.picture_social %}
    <meta property="og:image" content= "{{ idea.picture_social.url }}" />

    <meta property="og:image:width" content="{{ idea.picture_social.width }}" /> 
    <meta property="og:image:height" content="{{ idea.picture_social.height }}" /> 
  {% endif %}
  <meta property="og:description" content= "{{ idea.translated_content }}" />
  <meta property="og:site_name" content="MyProject" />
  <meta property="og:locale" content="{{ LANGUAGE_CODE }}" />

  <meta name="twitter:card" content="summary_large_image">
  <meta name="twitter:site" content="@DjangoTricks">
  <meta name="twitter:creator" content="@archatas">
  <meta name="twitter:url" content="{{ WEBSITE_URL }}{{ request.path }}">
  <meta name="twitter:title" content="{{ idea.translated_title }}">
  <meta name="twitter:description" content="{{ idea.translated_content }}"> 
  {% if idea.picture_social %}
    <meta name="twitter:image" content= "{{ idea.picture_social.url }}">
  {% endif %}
{% endblock %}

{% block content %}
  <a href="{% url ">
    {% trans "List of ideas" %}</a>
  &lt;h1&gt;
    {% blocktrans trimmed with title=idea.translated_title %} 
      Idea "{{ title }}"
    {% endblocktrans %}
  &lt;/h1&gt;
  &lt;img src="{{ idea.picture_large.url }}" alt="" /&gt; 
  {{ idea.translated_content|linebreaks|urlize }} 
  &lt;p&gt;
    {% for category in idea.categories.all %} 
      &lt;span class="badge badge-pill badge-info"&gt;
        {{ category.translated_title }}
      &lt;/span&gt; 
    {% endfor %}
  &lt;/p&gt;
  <a href="{% url 'ideas:change_idea' pk=idea.pk %}">{% trans "Change this idea" %}</a> 
  <a href="{% url 'ideas:delete_idea' pk=idea.pk %}">{% trans "Delete this idea" %}</a> 
{% endblock %}

### 实现原理...

Open Graph标签是以og:打头特殊名称的元标签，Twitter card标签是以twitter:打头特殊名称的元标签。这些元标签定义了URL、标签、描述和当前页面的图片、站点名、作者和地理位置。在这里要提供完整路径，只提供后面的路径是不够的。

我们使用picture_social图片版本，它是针对社交网站的优化尺寸：1024 × 512 px。

可以通过https://developers.facebook.com/tools/debug/来验证Open Graph的实现情况。

通过https://cards-dev.twitter.com/validator可以验证Twitter Card的实现情况。

### 相关内容

*   *使用CRUDL函数创建应用*一节
*   *上传图片*一节
*   *添加schema.org用词*一节

## 添加schema.org用词

搜索引擎优化SEO需要遵循语法的标记。但更进一步提升搜索引擎排名，根据schema.org的用词提供结构化数据是大有裨益的。很多来自谷歌、微软、Pinterest和Yandex等的应用都使用schema.org结构来创造丰富可扩展的体验，如在搜索结果在活动、电脑、作者等的特殊一致性卡片展示。

有一些编码，包括RDFa、Microdata和JSON-LD，可用于创建schema.org用词。本小节中，我们将以JSON-LD格式来为Idea模板准备结构化数据，这一格式是谷歌所推荐的。

### 准备工作

在项目的虚拟环境中安装django-json-ld包（并将其添加到requirements/_base.txt中）：

在设置中将django_json_ld添加到INSTALLED_APPS中：

### 如何实现...

按照如下步骤来完成本小节的学习：

1.  在Idea模型中使用如下内容添加structured_data属性：

 ```
# myproject/apps/ideas/models.py
    from django.db import models
    from django.utils.translation import gettext_lazy as _

    from myproject.apps.core.models import ( 
      CreationModificationDateBase, UrlBase 
    )

    class Idea(CreationModificationDateBase, UrlBase):
      # attributes, fields, properties, and methods...
      @property
      def structured_data(self):
        from django.utils.translation import get_language

        lang_code = get_language()
        data = {
          "@type": "CreativeWork",
          "name": self.translated_title, 
          "description": self.translated_content, 
          "inLanguage": lang_code,
        }
        if self.author:
          data["author"] = {
            "@type": "Person",
            "name": self.author.get_full_name() or
            self.author.username, 
          }
        if self.picture:
          data["image"] = self.picture_social.url
        return data

{% block meta_tags %}
  {# Open Graph and Twitter Card meta tags here... #}

  {% render_json_ld idea.structured_data %}
{% endblock %}

{% block content %}
  <a href="{% url ">
    {% trans "List of ideas" %}</a>
  &lt;h1&gt;
    {% blocktrans trimmed with title=idea.translated_title %} 
      Idea "{{ title }}"
    {% endblocktrans %}
  &lt;/h1&gt;
  &lt;img src="{{ idea.picture_large.url }}" alt="" /&gt; 
  {{ idea.translated_content|linebreaks|urlize }} 
  &lt;p&gt;
    {% for category in idea.categories.all %}
      &lt;span class="badge badge-pill badge-info"&gt; {{ category.translated_title }}&lt;/span&gt;
    {% endfor %}
  &lt;/p&gt;
  <a href="{% url 'ideas:change_idea' pk=idea.pk %}">{% trans "Change this idea" %}</a>
  <a href="{% url 'ideas:delete_idea' pk=idea.pk %}">{% trans "Delete this idea" %}</a>
{% endblock %}

### 实现原理...

{% render_json_ld %}模板标签会像类似下面这样渲染script标签：

structured_data属性根据schema.org用词返回一个嵌套字典，这可由大部分主流搜索引擎所理解。

可通过查阅[官方文档](https://schema.org/docs/schemas.html)来决定对模型应用哪些用词。

### 相关内容

*   [**第2章 模型和数据库结构**](https://alanhou.org/models-database-structure/)中*创建模型mixin来处理元标签*一节
*   *使用CRUDL函数创建应用*一节
*   *上传图片*一节
*   *添加Open Graph和Twitter Card数据*一节

## 生成PDF文档

Django视图不止是能让我们创建HTML页面。还可以创建任意类型的文件。例如，在[**第4章 模板和JavaScript**](https://alanhou.org/django3-templates-javascript/)中的*在JavaScript暴露设置*一节中，我们视图的输出是JavaScript文件的形式而非HTML。也可以对发票、票务、收据、预订确认等创建PDF文件。本小节中，我们将展示如何为数据库中的每个创建生成传单。这里使用WeasyPrint库来用HTML模板生成PDF文档。

### 准备工作

WeasyPrint依赖于一些库，需要在电脑上进行安装。macOS中可以使用如下命令通过Homebrew来安装这些库：

然后，可以在项目的虚拟环境中安装WeasyPrint本尊。同样请在requirements/_base.txt中进行添加：

对于其它操作系统，请参照[安装教程](https://weasyprint.readthedocs.io/en/latest/install.html)。

另外我们将使用django-qr-code来生成快速链接回到网站的二维码。在虚拟环境中也对其进行安装（并在requirements/_base.txt中添加）：

在设置的INSTALLED_APPS中添加qr_code：

### 如何实现...

按照如下步骤来完成本节的学习：

1.  创建用于生成PDF文档的视图：

 ```
# myproject/apps/ideas/views.py
    from django.shortcuts import get_object_or_404 
    from .models import Idea

    def idea_handout_pdf(request, pk):
      from django.template.loader import render_to_string 
      from django.utils.timezone import now as timezone_now 
      from django.utils.text import slugify
      from django.http import HttpResponse

      from weasyprint import HTML
      from weasyprint.fonts import FontConfiguration

      idea = get_object_or_404(Idea, pk=pk) 
      context = {"idea": idea}
      html = render_to_string(
        "ideas/idea_handout_pdf.html", context 
      )

      response = HttpResponse(content_type="application/pdf") 
      response[
        "Content-Disposition"
      ] = "inline; filename={date}-{name}-handout.pdf".format(
        date=timezone_now().strftime("%Y-%m-%d"),
        name=slugify(idea.translated_title), 
      )

      font_config = FontConfiguration() 
      HTML(string=html).write_pdf(
        response, font_config=font_config 
      )

      return response

from django.urls import path

from .views import idea_handout_pdf 
urlpatterns = [
  # URL configurations... 
  path("<uuid:pk>/handout/", idea_handout_pdf, name="idea_handout"),
]

3.  为PDF文档创建一个模板：

 ```
{# ideas/idea_handout_pdf.html #}
    {% extends "base_pdf.html" %} 
    {% load i18n qr_code %}

    {% block content %}
      <h1 class="h3">{% trans "Handout" %}</h1>
      <h2 class="h1">{{ idea.translated_title }}</h2> 
      <img src="{{ idea.picture_large.url }}" alt="" class="img-responsive w-100" />
      <div class="my-3">{{ idea.translated_content|linebreaks|urlize }}</div>
      <p>
        {% for category in idea.categories.all %} 
          <span class="badge badge-pill badge-info">
          {{ category.translated_title }}</span> 
        {% endfor %}
      </p>
      <h4>{% trans "See more information online:" %}</h4>
      {% qr_from_text idea.get_url size=20 border=0 as svg_code %} 
      <img alt="" src="data:image/svg+xml,
        {{ svg_code|urlencode }}" />
      <p class="mt-3 text-break">{{ idea.get_url }}</p>
    {% endblock %}

{% load i18n static %} 
<html lang="en"> 
<head>

  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">


  <link rel="stylesheet"
    href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css"
    integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
  <title>{% trans "Hello, World!" %}</title>

  <style>
  @page {
    size: "A4";
    margin: 2.5cm 1.5cm 3.5cm 1.5cm; 
  }
  footer {
    position: fixed; 
    bottom: -2.5cm; 
    width: 100%; 
    text-align: center; 
    font-size: 10pt;
  }
  footer img {
    height: 1.5cm; 
  }
  </style>

  {% block meta_tags %}{% endblock %}
</head>
<body>
  <main class="container">
    {% block content %}
    {% endblock %}
  </main>
  <footer>
  <img alt="" src="data:image/svg+xml,
    {# url-encoded SVG logo goes here #}" /> 
    <br />
    {% trans "Printed from MyProject" %}
  </footer>
</body>
</html>

### 实现原理...

WeasyPrint生成可供打印、像素精致的文档。本例中可在展示时分发给观众的传递类似下面这样：

![g](https://upload-images.jianshu.io/upload_images/14565748-e4a5deba05a8a8d7.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

> **译者注：**实际测试书中代码所添加的 BootStrap 样式不会生效，而因远程文件会报 ssl 相关错误，在idea_handout_pdf我使用的本地 css  （线上下载的 BootStrap 4 css 代码）的方式生成的 PDF，代码如下：
> 
> 

> 测试时发现 font_config 配置并不会产生什么影响，根据官方文档它主要用于兼容@font-face，总体测试发现 WeasyPrint与 BootStrap 的兼容性存在一定问题，如上图中可以看到使用 BootStrap 4时数字的显示存在问题，使用 BootStrap 3时则无此问题，调试时发现 HTML代码显示也是正常的，如果有知道问题的读者欢迎在评论区中告知。

文档的布局由HTML 和CSS进行定义。WeasyPrint有其自身的渲染引擎。阅读[官方文档](https://weasyprint.readthedocs.io/en/latest/features.html)获取更多支持功能。

可以使用保存为矢量图而非位图的SVG图像，这样传单会更为精致。当前还不支持行内SVG，但可以使用带有数据源或外部URL的<img>标签。本例中，我们对二维码及底部的logo使用了SVG图像。

我们来过一下视图中的代码。通过所选的idea来作为html字符串来渲染idea_handout_pdf.html模板。然后，我们创建PDF内容类型的HttpResponse对象，文件名由当前日期转为链接的idea的标题所构成。然后，我们通过HTML创建了一个WeasyPrint的HTML对象，并像写入文件中那样将其写入到响应中。此外，我们使用FontConfiguration对象，它让我们可以在布局的CSS配置中添加并使用网页字体。最后，我们返回响应对象。

### 相关内容

*   *使用CRUDL函数创建应用*一节
*   *上传图片*一节
*   [**第4章 模板和JavaScript**](https://alanhou.org/django3-templates-javascript/)中的*在JavaScript暴露设置*一节

## 通过Haystack和Whoosh实现多语言搜索

内容网站的一个主要功能是全文本搜索。Haystack是一个支持Solr、Elasticsearch、Whoosh和Xapian搜索引擎的模块化搜索API。对于项目中希望可进行搜索的模型，需要定义一个可通过模型读取文本信息并将其放到后台中的索引。本节中，我们将学习如何通过Haystack和基于Python的搜索语言来为多语言网站配置搜索。

### 准备工作

我们使用此前定义的categories和ideas应用。

确保在虚拟环境中安装了django-haystack和Whoosh（并将它们添加到requirements/_base.txt中）：

### 如何实现...

执行如下步骤来通过Haystack和Whoosh来设置多语种搜索：

1.  创建一个search应用，其中包含MultilingualWhooshEngine以及对ideas的搜索索引。搜索引擎放到multilingual_whoosh_backend.py文件：

from django.conf import settings
from django.utils import translation
from haystack.backends.whoosh_backend import (
  WhooshSearchBackend,
  WhooshSearchQuery,
  WhooshEngine,
)
from haystack import connections
from haystack.constants import DEFAULT_ALIAS

class MultilingualWhooshSearchBackend(WhooshSearchBackend): 
  def update(self, index, iterable, commit=True, language_specific=False):
    if not language_specific and self.connection_alias == "default":
      current_language = (translation.get_language() or
      settings.LANGUAGE_CODE)[:2]
      for lang_code, lang_name in settings.LANGUAGES:
        lang_code_underscored = lang_code.replace("-", "_") 
        using = f"default_{lang_code_underscored}" 
        translation.activate(lang_code)
        backend = connections[using].get_backend()
        backend.update(index, iterable, commit, language_specific=True)
        translation.activate(current_language) 
    elif language_specific:
      super().update(index, iterable, commit)

class MultilingualWhooshSearchQuery(WhooshSearchQuery): 
  def __init__(self, using=DEFAULT_ALIAS):
    lang_code_underscored = translation.get_language().replace("-", "_") 
    using = f"default_{lang_code_underscored}" 
    super().__init__(using=using)

class MultilingualWhooshEngine(WhooshEngine): 
  backend = MultilingualWhooshSearchBackend 
  query = MultilingualWhooshSearchQuery

2.  创建搜索索引如下：

from haystack import indexes

from myproject.apps.ideas.models import Idea

class IdeaIndex(indexes.SearchIndex, indexes.Indexable): 
  text = indexes.CharField(document=True)

  def get_model(self):
    return Idea

  def index_queryset(self, using=None): 
    """
    Used when the entire index for model is updated. 
    """
    return self.get_model().objects.all()

  def prepare_text(self, idea):
    """
    Called for each language / backend 
    """
    fields = [
      idea.translated_title, idea.translated_content 
    ]
    fields += [ 
      category.translated_title
      for category in idea.categories.all() 
    ]
    return "\n".join(fields)

3.  使用MultilingualWhooshEngine配置设置文件：

 ```
# myproject/settings/_base.py
    import os
    BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(
       os.path.abspath(__file__) 
    )))

    #...

    INSTALLED_APPS = [ 
       # contributed
       #...
       # third-party
       #...
       "haystack",
       # local 
       "myproject.apps.core", 
       "myproject.apps.categories", 
       "myproject.apps.ideas", 
       "myproject.apps.search",
    ]

    LANGUAGE_CODE = "en"

    # All official languages of European Union 
    LANGUAGES = [
       ("bg", "Bulgarian"),
       ("hr", "Croatian"),
       ("cs", "Czech"),
       ("da", "Danish"),
       ("nl", "Dutch"),
       ("en", "English"),
       ("et", "Estonian"),
       ("fi", "Finnish"),
       ("fr", "French"),
       ("de", "German"),
       ("el", "Greek"),
       ("hu", "Hungarian"),
       ("ga", "Irish"),
       ("it", "Italian"),
       ("lv", "Latvian"),
       ("lt", "Lithuanian"),
       ("mt", "Maltese"),
       ("pl", "Polish"),
       ("pt", "Portuguese"),
       ("ro", "Romanian"),
       ("sk", "Slovak"),
       ("sl", "Slovene"),
       ("es", "Spanish"),
       ("sv", "Swedish"),
    ]

    HAYSTACK_CONNECTIONS = {}
    for lang_code, lang_name in LANGUAGES:
       lang_code_underscored = lang_code.replace("-", "_") 
       HAYSTACK_CONNECTIONS[f"default_{lang_code_underscored}"] = { 
          "ENGINE": "myproject.apps.search.multilingual_whoosh_backend.MultilingualWhooshEngine",
          "PATH": os.path.join(BASE_DIR, "tmp", f"whoosh_index_{lang_code_underscored}"),
       }
    lang_code_underscored = LANGUAGE_CODE.replace("-", "_") 
    HAYSTACK_CONNECTIONS["default"] = HAYSTACK_CONNECTIONS[ 
       f"default_{lang_code_underscored}"
    ]

from django.contrib import admin
from django.conf.urls.i18n import i18n_patterns 
from django.urls import include, path
from django.conf import settings
from django.conf.urls.static import static 
from django.shortcuts import redirect

urlpatterns = i18n_patterns(
   path("", lambda request: redirect("ideas:idea_list")), 
   path("admin/", admin.site.urls),
   path("accounts/", include("django.contrib.auth.urls")), 
   path("ideas/", include(("myproject.apps.ideas.urls", "ideas"), namespace="ideas")),
   path("search/", include("haystack.urls")),
)
urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
urlpatterns += static("/media/", document_root=settings.MEDIA_ROOT)

5.  需要一个针对搜索表单和搜索结果的模板，如下：

 ```
{# search/search.html #}
    {% extends "base.html" %} 
    {% load i18n %}

    {% block sidebar %}
      <form method="get" action="{{ request.path }}">
        <div class="well clearfix"> 
          {{ form.as_p }}
          <p class="pull-right">
            <button type="submit" class="btn btn-primary">
              {% trans "Search" %}</button>
          </p>
         </div>
      </form>
     {% endblock %}

    {% block main %}
      {% if query %}
        <h1>{% trans "Search Results" %}</h1>

        {% for result in page.object_list %} 
          {% with idea=result.object %}
            <a href="{{ idea.get_url_path }}">
              &lt;div class="card"&gt;
                &lt;img src="{{ idea.picture_thumbnail.url }}" alt="" /&gt;
                &lt;div class="card-body"&gt;
                  &lt;p class="card-text"&gt;
                  {{ idea.translated_title }}&lt;/p&gt;
                &lt;/div&gt;
                &lt;/div&gt;
            </a>
          {% endwith %}
        {% empty %}
          &lt;p&gt;{% trans "No results found." %}&lt;/p&gt;
        {% endfor %}

        {% include "misc/includes/pagination.html" with object_list=page %}
      {% endif %}
    {% endblock %}

(env)$ python manage.py rebuild_index --noinput

$ brew install elasticsearch

(env)$ pip install django-elasticsearch-dsl==6.4.1

### 如何实现...

我们来通过如下步骤借助 Elasticsearch DSL设置多语言搜索：

1.  修改配置文件、添加django_elasticsearch_dsl到INSTALLED_APPS中，并配置ELASTICSEARCH_DSL如下：

 ```
# myproject/settings/_base.py
    INSTALLED_APPS = [ 
      # other apps...
      "django_elasticsearch_dsl", 
    ]

    ELASTICSEARCH_DSL={
      'default': {
        'hosts': 'localhost:9200'
      },
    }

from django.conf import settings
from django.utils.translation import get_language, activate 
from django.db import models

from django_elasticsearch_dsl import fields 
from django_elasticsearch_dsl.documents import (
  Document,
  model_field_class_to_field_class,
)
from django_elasticsearch_dsl.registries import registry

from myproject.apps.categories.models import Category 
from .models import Idea

def _get_url_path(instance, language): 
  current_language = get_language() 
  activate(language)
  url_path = instance.get_url_path() 
  activate(current_language)
  return url_path

@registry.register_document 
class IdeaDocument(Document):
  author = fields.NestedField( 
    properties={
      "first_name": fields.StringField(), 
      "last_name": fields.StringField(), 
      "username": fields.StringField(), 
      "pk": fields.IntegerField(),
    },
    include_in_root=True, 
  )
  title_bg = fields.StringField()
  title_hr = fields.StringField()
  # other title_* fields for each language in the LANGUAGES setting...
  content_bg = fields.StringField()
  content_hr = fields.StringField()
  # other content_* fields for each language in the LANGUAGES setting...

  picture_thumbnail_url = fields.StringField()
  categories = fields.NestedField( 
    properties=dict(
      pk=fields.IntegerField(), 
      title_bg=fields.StringField(), 
      title_hr=fields.StringField(),
      # other title_* definitions for each language in the LANGUAGES setting... 
    ),
    include_in_root=True,
  )
  url_path_bg = fields.StringField()
  url_path_hr = fields.StringField()
  # other url_path_* fields for each language in the LANGUAGES setting...

  class Index:
    name = "ideas"
    settings = {"number_of_shards": 1, "number_of_replicas": 0}

  class Django: 
    model = Idea
    # The fields of the model you want to be indexed in Elasticsearch
    fields = ["uuid", "rating"] 
    related_models = [Category]

  def get_instances_from_related(self, related_instance):
    if isinstance(related_instance, Category):
      category = related_instance
      return category.category_ideas.all()

3.  在IdeaDocument中添加prepare_*方法来准备索引的数据：

def prepare_picture_thumbnail_url(self, instance): 
  if not instance.picture:
    return ""
  return instance.picture_thumbnail.url

def prepare_author(self, instance): 
  author = instance.author
  if not author:
    return [] 
  author_dict = {
    "pk": author.pk,
    "first_name": author.first_name, 
    "last_name": author.last_name, 
    "username": author.username,
  }
  return [author_dict]

def prepare_categories(self, instance): 
  categories = []
  for category in instance.categories.all(): 
    category_dict = {"pk": category.pk} 
    lang_code_underscored = settings.LANGUAGE_CODE.replace("-", "_") 
    category_dict[f"title_{lang_code_underscored}"] = category.title
    for lang_code, lang_name in settings.LANGUAGES_EXCEPT_THE_DEFAULT: 
      lang_code_underscored = lang_code.replace("-", "_") 
      category_dict[f"title_{lang_code_underscored}"] = "" 
      translations = category.translations.filter(language= lang_code).first()
      if translations:
        category_dict[f"title_{lang_code_underscored}"] = translations.title 
    categories.append(category_dict)
  return categories

4.  对IdeaDocument添加一些属性和方法，从索引文档中返回翻译内容：

@property
def translated_content(self):
  lang_code_underscored = get_language().replace("-", "_") 
  return getattr(self, f"content_{lang_code_underscored}", "")

def get_url_path(self):
  lang_code_underscored = get_language().replace("-", "_") 
  return getattr(self, f"url_path_{lang_code_underscored}", "")

def get_categories(self):
  lang_code_underscored = get_language().replace("-", "_") 
  return [
    dict( 
      translated_title=category_dict[f"title_{lang_code_underscored}"],
      **category_dict,
    )
    for category_dict in self.categories 
  ]

5.  在documents.py文件中还要做的一件事是对UUIDField打猴子补丁，因默认Django Elasticsearch DSL不支持这种字段。只需要在导入区块之后添加如下代码即可：

6.  在ideas应用的forms.py中创建IdeaSearchForm：

from django import forms
from django.utils.translation import ugettext_lazy as _

from crispy_forms import helper, layout

class IdeaSearchForm(forms.Form):
  q = forms.CharField(label=_("Search for"), required=False)

  def __init__(self, request, *args, **kwargs): 
    self.request = request 
    super().__init__(*args, **kwargs)

    self.helper = helper.FormHelper() 
    self.helper.form_action = self.request.path 
    self.helper.form_method = "GET" 
    self.helper.layout = layout.Layout(
      layout.Field("q", css_class="input-block-level"),
      layout.Submit("search", _("Search")), 
    )

7.  添加使用Elasticsearch进行搜索的视图：

from django.shortcuts import render
from django.conf import settings
from django.core.paginator import EmptyPage, PageNotAnInteger, Paginator
from django.utils.functional import LazyObject

from .forms import IdeaSearchForm

PAGE_SIZE = getattr(settings, "PAGE_SIZE", 24)

class SearchResults(LazyObject):
  def __init__(self, search_object):
    self._wrapped = search_object

  def __len__(self):
    return self._wrapped.count()

  def __getitem__(self, index): 
    search_results = self._wrapped[index] 
    if isinstance(index, slice):
      search_results = list(search_results) 
    return search_results

def search_with_elasticsearch(request): 
  from .documents import IdeaDocument 
  from elasticsearch_dsl.query import Q

  form = IdeaSearchForm(request, data=request.GET)

  search = IdeaDocument.search()

  if form.is_valid():
    value = form.cleaned_data["q"]
    lang_code_underscored = request.LANGUAGE_CODE.replace("-", "_")
    search = search.query(
      Q("match_phrase", 
        **{f"title_{lang_code_underscored}":
        value})
      | Q("match_phrase", **{f"content_{
          lang_code_underscored}": value})
      | Q(
          "nested",
          path="categories", 
          query=Q(
            "match_phrase",
            **{f"categories__title_{
            lang_code_underscored}": value},
          ),
        )
    )

    search_results = SearchResults(search)

    paginator = Paginator(search_results, PAGE_SIZE) 
    page_number = request.GET.get("page")
    try:
      page = paginator.page(page_number) 
    except PageNotAnInteger:
      # If page is not an integer, show first page.
      page = paginator.page(1) 
    except EmptyPage:
      # If page is out of range, show last existing page. 
      page = paginator.page(paginator.num_pages)

    context = {"form": form, "object_list": page}
    return render(request, "ideas/idea_search.html", context)

8.  对搜索表单和搜索结果创建idea_search.html模板：

{% block sidebar %}
  {% crispy form %}
{% endblock %}

{% block main %}
  <h1>{% trans "Search Results" %}</h1>
  {% if object_list %}
    {% for idea in object_list %}
      <a href="{{ idea.get_url_path }}">
        &lt;div class="card"&gt;
          &lt;img src="{{ idea.picture_thumbnail_url }}" alt="" /&gt;
          &lt;div class="card-body"&gt;
            &lt;p class="card-text"&gt;{{ idea.translated_title }}&lt;/p&gt;
          &lt;/div&gt;
        &lt;/div&gt;
      </a>
    {% endfor %}
    {% include "misc/includes/pagination.html" %} 
  {% else %}
    &lt;p&gt;{% trans "No ideas found." %}&lt;/p&gt; 
  {% endif %}
{% endblock %}

9.  像*管理分页列表*一节中那样在 misc/includes/pagination.html中添加分页模板。
10.  调用search_index --rebuild管理命令来索引数据库数据并准备用于搜索的全文本：

 ```
(env)$ python manage.py search_index --rebuild