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

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

class Idea(CreationModificationDateBase, MetaTagsBase, UrlBase): 
  title = models.CharField(
    _("Title"),
    max_length=200, 
  )
  content = models.TextField( 
    _("Content"),
  )
  # other fields...

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

  def __str__(self): 
    return self.title

  def get_url_path(self):
    return reverse("idea_details", kwargs={
      "idea_id": str(self.pk), 
    })

>>> class A(object):
...   def test(self):
...     print("A.test() called") 
...

>>> class B(object):
...   def test(self):
...     print("B.test() called") 
...

>>> class C(object):
...   def test(self):
...     print("C.test() called") 
...

>>> class D(A, B, C):
...   def test(self): 
...     super().test()
...     print("D.test() called")

>>> d = D() 
>>> d.test()
A.test() called 
D.test() called

2.  向开发、测试、预发布和生产设置添加WEBSITE_URL设置，后面不带斜线。例如，开发环境的设置如下：

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

    DEBUG = True
    WEBSITE_URL = "http://127.0.0.1:8000" # 最后面不带斜线

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

    from myproject.apps.core.models import UrlBase 

    class Idea(UrlBase):
      # 字段、属性、私有属性和方法... 
      def get_url_path(self):
        return reverse("idea_details", kwargs={ 
          "idea_id": str(self.pk),
        })

<a href="{{ idea.get_url_path }}">{{ idea.title }}</a>

<a href="{{ idea.get_url }}">{{ idea.title }}</a>

class Idea(UrlBase):
    slug = models.SlugField(_("Slug for URLs"), max_length=50)

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

class CreationModificationDateBase(models.Model): 
  """
  Abstract base class with a creation and modification date and time
  """
  created = models.DateTimeField( 
    _("Creation Date and Time"), 
    auto_now_add=True,
  )
  modified = models.DateTimeField( 
    _("Modification Date and Time"), 
    auto_now=True,
  )

  class Meta:
    abstract = True

# myproject/apps/ideas/models.py
from django.db import models

from myproject.apps.core.models import CreationModificationDateBase

class Idea(CreationModificationDateBase):
    # other fields, attributes, properties, and methods...

{# templates/core/includes/meta.html #}
    <meta name="{{ name }}" content="{{ content }}" />

# myproject/apps/core/models.py
    from django.conf import settings
    from django.db import models
    from django.utils.translation import gettext_lazy as _ 
    from django.utils.safestring import mark_safe
    from django.template.loader import render_to_string

    class MetaTagsBase(models.Model): 
      """
      Abstract base class for generating meta tags 
      """
      meta_keywords = models.CharField(
        _("Keywords"),
        max_length=255,
        blank=True,
        help_text=_("Separate keywords with commas."),
      )
      meta_description = models.CharField(
        _("Description"), 
        max_length=255, 
        blank=True,
      )
      meta_author = models.CharField(
        _("Author"), 
        max_length=255, 
        blank=True,
      )
      meta_copyright = models.CharField(
        _("Copyright"), 
        max_length=255, 
        blank=True,
      )
      class Meta: 
        abstract = True

      def get_meta_field(self, name, content): 
        tag = ""
        if name and content:
        tag = render_to_string("core/includes/meta.html", {
          "name": name,
          "content": content,
        })
        return mark_safe(tag)

      def get_meta_keywords(self):
        return self.get_meta_field("keywords", self.meta_keywords)

      def get_meta_description(self):
        return self.get_meta_field("description", self.meta_description)

      def get_meta_author(self):
        return self.get_meta_field("author", self.meta_author)

      def get_meta_copyright(self):
        return self.get_meta_field("copyright", self.meta_copyright)

      def get_meta_tags(self):
      return mark_safe("\n".join((
        self.get_meta_keywords(), 
        self.get_meta_description(), 
        self.get_meta_author(), 
        self.get_meta_copyright(),
      )))

{% block meta_tags %} 
{{ block.super }}
{{ idea.get_meta_tags }} 
{% endblock %}

# myproject/settings/_base.py
INSTALLED_APPS = [ 
  # contributed
  "django.contrib.admin", 
  "django.contrib.auth", 
  "django.contrib.contenttypes", 
  "django.contrib.sessions", 
  "django.contrib.messages", 
  "django.contrib.staticfiles", 
  # third-party
  # ...
  # local 
  "myproject.apps.core", 
  "myproject.apps.categories", 
  "myproject.apps.ideas",
]

# myproject/apps/core/models.py
    from django.db import models
    from django.utils.translation import gettext_lazy as _
    from django.contrib.contenttypes.models import ContentType
    from django.contrib.contenttypes.fields import GenericForeignKey 
    from django.core.exceptions import FieldError

    def object_relation_base_factory( 
      prefix=None,
      prefix_verbose=None, 
      add_related_name=False, 
      limit_content_type_choices_to=None, 
      is_required=False):
      """
      Returns a mixin class for generic foreign keys using "Content type - object ID" with dynamic field names. This function is just a class generator.
      Parameters:
      prefix: a prefix, which is added in front of the fields

      prefix_verbose: a verbose name of the prefix, used to generate a title for the field column of the content object in the Admin
      add_related_name: a boolean value indicating, that a related name for the generated content type foreign key should be added. This value should be true, if you use more than one ObjectRelationBase in your model.

      The model fields are created using this naming scheme:
        <<prefix>>_content_type
        <<prefix>>_object_id
        <<prefix>>_content_object
      """
      p = ""
      if prefix:
        p = f"{prefix}_"
        prefix_verbose = prefix_verbose or _("Related object") 
        limit_content_type_choices_to = limit_content_type_choices_to or {}
      content_type_field = f"{p}content_type" 
      object_id_field = f"{p}object_id" content_object_field = f"{p}content_object"

      class TheClass(models.Model): 
        class Meta:
          abstract = True

      if add_related_name:
        if not prefix:
          raise FieldError("if add_related_name is set to "
                          "True, a prefix must be given")
          related_name = prefix 
      else:
        related_name = None

      optional = not is_required

      ct_verbose_name = _(f"{prefix_verbose}'s type (model)")

      content_type = models.ForeignKey( 
        ContentType,
        verbose_name=ct_verbose_name, 
        related_name=related_name,
        blank=optional,
        null=optional,
        help_text=_("Please select the type (model) "
                    "for the relation, you want to build."), 
        limit_choices_to=limit_content_type_choices_to,
        on_delete=models.CASCADE)

      fk_verbose_name = prefix_verbose

      object_id = models.CharField( 
        fk_verbose_name,
        blank=optional,
        null=False,
        help_text=_("Please enter the ID of the related object."), 
        max_length=255,
        default="") # for migrations

      content_object = GenericForeignKey( 
        ct_field=content_type_field, 
        fk_field=object_id_field)

      TheClass.add_to_class(content_type_field, content_type) 
      TheClass.add_to_class(object_id_field, object_id) 
      TheClass.add_to_class(content_object_field, content_object)

      return TheClass

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

    from myproject.apps.core.models import ( 
      object_relation_base_factory as generic_relation,
    )

    FavoriteObjectBase = generic_relation( 
      is_required=True,
    )

    OwnerBase = generic_relation( 
      prefix="owner",
      prefix_verbose=_("Owner"), 
      is_required=True, 
      add_related_name=True, 
      limit_content_type_choices_to={
        "model__in": (
          "user",
          "group", 
        )
      } 
    )

    class Like(FavoriteObjectBase, OwnerBase): 
      class Meta:
        verbose_name = _("Like") 
        verbose_name_plural = _("Likes")

      def __str__(self):
        return _("{owner} likes {object}").format(
          owner=self.owner_content_object,
          object=self.content_object
        )

# myproject/apps/core/model_fields.py
    from django.conf import settings
    from django.db import models
    from django.utils.translation import get_language 
    from django.utils import translation

    class MultilingualField(models.Field):
      SUPPORTED_FIELD_TYPES = [models.CharField, models.TextField]

      def __init__(self, verbose_name=None, **kwargs): 
        self.localized_field_model = None
        for model in MultilingualField.SUPPORTED_FIELD_TYPES:
          if issubclass(self.__class__, model): 
            self.localized_field_model = model
        self._blank = kwargs.get("blank", False) 
        self._editable = kwargs.get("editable", True) 
        super().__init__(verbose_name, **kwargs)

      @staticmethod
      def localized_field_name(name, lang_code):
        lang_code_safe = lang_code.replace("-", "_") 
        return f"{name}_{lang_code_safe}"

      def get_localized_field(self, lang_code, lang_name): 
        _blank = (self._blank
                  if lang_code == settings.LANGUAGE_CODE
                  else True)
        localized_field = self.localized_field_model(
          f"{self.verbose_name} ({lang_name})", 
          name=self.name, 
          primary_key=self.primary_key, 
          max_length=self.max_length, 
          unique=self.unique,
          blank=_blank,
          null=False, # we ignore the null argument! 
          db_index=self.db_index, 
          default=self.default or "", 
          editable=self._editable, 
          serialize=self.serialize, 
          choices=self.choices, 
          help_text=self.help_text,
          db_column=None, 
          db_tablespace=self.db_tablespace)
        return localized_field

      def contribute_to_class(self, cls, name, 
                              private_only=False,
                              virtual_only=False):
         def translated_value(self):
          language = get_language() 
          val = self.__dict__.get(
              MultilingualField.localized_field_name( 
                name, language))
          if not val:
            val = self.__dict__.get(
                MultilingualField.localized_field_name( 
                    name, settings.LANGUAGE_CODE))
        return val

      # generate language-specific fields dynamically 
      if not cls._meta.abstract:
        if self.localized_field_model:
          for lang_code, lang_name in settings.LANGUAGES:
            localized_field = self.get_localized_field( 
                lang_code, lang_name)
            localized_field.contribute_to_class(
                cls, MultilingualField.localized_field_name(
                          name, lang_code))
          setattr(cls, name, property(translated_value))
        else:
          super().contribute_to_class(
            cls, name, private_only, virtual_only)

class MultilingualCharField(models.CharField, MultilingualField): 
      pass

    class MultilingualTextField(models.TextField, MultilingualField): 
      pass

# myproject/apps/core/admin.py
    from django.conf import settings

    def get_multilingual_field_names(field_name): 
      lang_code_underscored = settings.LANGUAGE_CODE.replace("-", "_")
      field_names = [f"{field_name}_{lang_code_underscored}"] 
      for lang_code, lang_name in settings.LANGUAGES:
        if lang_code != settings.LANGUAGE_CODE: 
          lang_code_underscored = lang_code.replace("-", "_") 
          field_names.append(
                f"{field_name}_{lang_code_underscored}"
            )
      return field_names

# myproject/settings/_base.py 
    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"),
    ]

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

    from myproject.apps.core.model_fields import ( 
      MultilingualCharField, 
      MultilingualTextField,
    )

    class Idea(models.Model):
      title = MultilingualCharField(
        _("Title"),
        max_length=200, 
      )
      content = MultilingualTextField( 
        _("Content"),
      )

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

      def __str__(self): 
        return self.title

# myproject/apps/ideas/admin.py
    from django.contrib import admin
    from django.utils.translation import gettext_lazy as _

    from myproject.apps.core.admin import get_multilingual_field_names 

    from .models import Idea

    @admin.register(Idea)
    class IdeaAdmin(admin.ModelAdmin):
      fieldsets = [
        (_("Title and Content"), {
        "fields": get_multilingual_field_names("title") + 
            get_multilingual_field_names("content")
        }), 
      ]

class Idea(models.Model): 
  title_bg = models.CharField(
    _("Title (Bulgarian)"),
    max_length=200, 
  )
  title_hr = models.CharField( 
    _("Title (Croatian)"), 
    max_length=200,
  )
  # titles for other languages... 
  title_sv = models.CharField(
    _("Title (Swedish)"),
    max_length=200, 
  )

  content_bg = MultilingualTextField( 
    _("Content (Bulgarian)"),
  )
  content_hr = MultilingualTextField(
    _("Content (Croatian)"),
  )
  # content for other languages... 
  content_sv = MultilingualTextField(
    _("Content (Swedish)"),
  )

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

  def __str__(self): 
    return self.title

<h1>{{ idea.title }}</h1>
<div>{{ idea.content|urlize|linebreaks }}</div>

>>> lang_code = input("Enter language code: ")
>>> lang_code_underscored = lang_code.replace("-", "_")
>>> qs = Idea.objects.order_by(f"title_{lang_code_underscored}")

from django.conf import settings
from django.utils.translation import get_language 
from django.utils import translation

class TranslatedField(object):
  def __init__(self, field_name):
    self.field_name = field_name

  def __get__(self, instance, owner): 
    lang_code = translation.get_language() 
    if lang_code == settings.LANGUAGE_CODE:
      # The fields of the default language are in the main model
      return getattr(instance, self.field_name) 
    else:
      # The fields of the other languages are in the translation
      # model, but falls back to the main model 
      translations = instance.translations.filter(
        language=lang_code,
      ).first() or instance
      return getattr(translations, self.field_name)

2.  在core 应用中增加admin.py文件并添加如下内容：

from django import forms
from django.conf import settings
from django.utils.translation import gettext_lazy as _

class LanguageChoicesForm(forms.ModelForm): 
  def __init__(self, *args, **kwargs): 
    LANGUAGES_EXCEPT_THE_DEFAULT = [
      (lang_code, lang_name)
      for lang_code, lang_name in settings.LANGUAGES 
      if lang_code != settings.LANGUAGE_CODE
    ]
    super().__init__(*args, **kwargs) 
    self.fields["language"] = forms.ChoiceField(
      label=_("Language"), 
      choices=LANGUAGES_EXCEPT_THE_DEFAULT, 
      required=True,
    )

下面我们来实现多语言模型：

1.  首先在项目的设置中设置多语言。比如我们的网站支持欧盟的所有官方语言，英语是默认语言：

 ```
# myproject/settings/_base.py 
    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"),
    ]

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

    from myproject.apps.core.model_fields import TranslatedField

    class Idea(models.Model): 
      title = models.CharField(
        _("Title"),
        max_length=200, 
      )
      content = models.TextField( 
        _("Content"),
      )
      translated_title = TranslatedField("title")
      translated_content = TranslatedField("content")

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

      def __str__(self): 
        return self.title

    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/ideas/admin.py
    from django.contrib import admin
    from django.utils.translation import gettext_lazy as _

    from myproject.apps.core.admin import LanguageChoicesForm 

    from .models import Idea, IdeaTranslations

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

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

    @admin.register(Idea)
    class IdeaAdmin(admin.ModelAdmin):
      inlines = [IdeaTranslationsInline]
      fieldsets = [
        (_("Title and Content"), {
          "fields": ["title", "content"]
        }),
      ]

<h1>{{ idea.translated_title }}</h1>
<div>{{ idea.translated_content|urlize|linebreaks }}</div>

>>> from django.conf import settings
>>> from django.db import models
>>> lang_code = input("Enter language code: ")

>>> if lang_code == settings.LANGUAGE_CODE:
...   qs = Idea.objects.annotate(
...     title_translation=models.F("title"),
...     content_translation=models.F("content"), 
...   )
...  else:
...    qs = Idea.objects.filter(
...        translations__language=lang_code,    
...     ).annotate(
...        title_translation=models.F("translations__title"),
...        content_translation=models.F("translations__content"),
...     )
>>> qs = qs.order_by("title_translation")

>>> for idea in qs:
...   print(idea.title_translation)

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

    class Idea(models.Model): 
      author = models.ForeignKey(
        settings.AUTH_USER_MODEL, 
        verbose_name=_("Author"), 
        on_delete=models.SET_NULL, 
        blank=True,
        null=True, 
      )
      category = models.ForeignKey( 
        "categories.Category", 
        verbose_name=_("Category"), 
        blank=True,
        null=True,
        on_delete=models.SET_NULL, 
      )
      # other fields, attributes, properties and methods...

这里settings.AUTH_USER_MODEL是一个设置，带有auth.User这样的值

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

    class Category(models.Model):
      # fields, attributes, properties, and methods...

      def get_ideas_without_this_category(self):
        from myproject.apps.ideas.models import Idea
        return Idea.objects.exclude(category=self)

# myproject/settings/_base.py

    INSTALLED_APPS = [ 
      # contributed
      "django.contrib.admin", 
      "django.contrib.auth", 
      "django.contrib.contenttypes", 
      "django.contrib.sessions", 
      "django.contrib.messages", 
      "django.contrib.staticfiles", 
      # third-party
      # ...
      # local 
      "myproject.apps.core", 
      "myproject.apps.categories", 
      "myproject.apps.ideas",
    ]

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

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

class Idea(CreationModificationDateBase, MetaTagsBase, UrlBase):
  # fields, attributes, properties, and methods...

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

class Idea(models.Model): 
  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, 
  )

  class Meta:
    verbose_name = _("Idea") 
    verbose_name_plural = _("Ideas") 
    constraints = [
      models.UniqueConstraint( 
        fields=["title"], 
        condition=~models.Q(author=None), 
        name="unique_titles_for_each_author",
    ), 
    models.CheckConstraint(
      check=models.Q( 
        title__iregex=r"^\S.*\S$"
        # starts with non-whitespace, 
        # ends with non-whitespace, 
        # anything in the middle
    ),
    name="title_has_no_leading_and_trailing_whitespaces",
  )
]

ideas_with_authors = Idea.objects.exclude(author=None)
ideas_with_authors2 = Idea.objects.filter(~models.Q(author=None))

# myproject/apps/ideas/models.py
from django.db import models
from django.conf import settings
from django.core.exceptions import ValidationError 
from django.utils.translation import gettext_lazy as _

class Idea(models.Model): 
  author = models.ForeignKey(
    settings.AUTH_USER_MODEL, 
    verbose_name=_("Author"), 
    on_delete=models.SET_NULL, 
    blank=True,
    null=True,
    related_name="authored_ideas2",
  )
  title = models.CharField( 
    _("Title"),
    max_length=200, 
  )

  # other fields and attributes...

  class Meta:
    verbose_name = _("Idea") 
    verbose_name_plural = _("Ideas") 
    constraints = [
      models.UniqueConstraint( 
        fields=["title"], 
        condition=~models.Q(author=None), 
        name="unique_titles_for_each_author2",
      ), 
      models.CheckConstraint(
        check=models.Q( 
          title__iregex=r"^\S.*\S$"
          # starts with non-whitespace, 
          # ends with non-whitespace, 
          # anything in the middle
        ),
        name="title_has_no_leading_and_trailing_whitespaces2", 
      )
    ]

  def clean(self):
    import re
    if self.author and Idea.objects.exclude(pk=self.pk).filter(
      author=self.author,
      title=self.title, 
    ).exists():
      raise ValidationError(
        _("Each idea of the same user should have a unique title.")
      )
    if not re.match(r"^\S.*\S$", self.title):
      raise ValidationError(
        _("The title cannot start or end with a whitespace.")
      )

  # other properties and methods...

(env)$ python manage.py makemigrations ideas

(env)$ python manage.py migrate

在希望对所有应用执行新的迁移时运行该命令。

(env)$ python manage.py migrate ideas

(env)$ python manage.py makemigrations --name=subtitle_added ideas

但是，可以跳过 --name=subtitle_added字段的指定，因为大多数情况下Django会生成可说明含义的默认名称。

(env)$ python manage.py makemigrations --name=populate_subtitle \ 
    > --empty ideas

--empty参数告诉Django要创建一个框架数据迁移，在应用前需要修改以执行必要的数据操作。对于数据迁移，推荐设置名称。

(env)$ python manage.py showmigrations

已应用迁移列举时的前缀为[X] 。未应用的迁移列举时前缀为[ ] 。

(env)$ python manage.py showmigrations ideas

(env)$ python manage.py migrate ideas 0002

(env)$ python manage.py migrate ideas zero

# 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 MultilingualCharField

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

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

      def __str__(self): 
        return self.title

# myproject/apps/ideas/models.py
    from django.db import models
    from django.conf import settings
    from django.utils.translation import gettext_lazy as _
    from myproject.apps.core.model_fields

    import ( 
      MultilingualCharField, 
      MultilingualTextField,
    )

    class Idea(models.Model):
      title = MultilingualCharField(
        _("Title"),
        max_length=200, 
      )
      content = MultilingualTextField( 
        _("Content"),
      )
      category = models.ForeignKey( 
        "categories.Category", 
        verbose_name=_("Category"), 
        blank=True,
        null=True, 
        on_delete=models.SET_NULL, 
        related_name="category_ideas",
      )

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

      def __str__(self): 
        return self.title

### 如何实现...

以下步骤展示如何从外键切换为多对多关联，同时保留已有数据：

1.  新增多对多字段categories如下：

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

from myproject.apps.core.model_fields import ( 
  MultilingualCharField,
  MultilingualTextField,
)

class Idea(models.Model):
  title = MultilingualCharField(
    _("Title"),
    max_length=200, 
  )
  content = MultilingualTextField( 
    _("Content"),
  )
  category = models.ForeignKey(
    "categories.Category", 
    verbose_name=_("Category"), 
    blank=True,
    null=True, 
    on_delete=models.SET_NULL, 
    related_name="category_ideas",
  )
  categories = models.ManyToManyField( 
    "categories.Category", 
    verbose_name=_("Categories"), 
    blank=True, 
    related_name="ideas",
  )

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

  def __str__(self): 
    return self.title

2.  创建并运行模式迁移来对数据库添加新关联，如以下代码所示

3.  创建一个数据迁移来将categories从外键拷贝到多对多字段，如下：

4.  打开新创建的迁移文件（0003_copy_categories.py），并定义前台迁移指令，如以下代码所示：

    ```
# myproject/apps/ideas/migrations/0003_copy_categories.py
    from django.db import migrations

    def copy_categories(apps, schema_editor): 
      Idea = apps.get_model("ideas", "Idea") 
      for idea in Idea.objects.all():
        if idea.category: 
          idea.categories.add(idea.category)

    class Migration(migrations.Migration):

      dependencies = [
        ('ideas', '0002_idea_categories'),
      ]

      operations = [
        migrations.RunPython(copy_categories),
      ]

(env)$ python manage.py migrate ideas

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

    from myproject.apps.core.model_fields import ( 
      MultilingualCharField, 
      MultilingualTextField,
    )

    class Idea(models.Model):
      title = MultilingualCharField(
        _("Title"),
        max_length=200, 
      )
      content = MultilingualTextField(
        _("Content"),
      )

      categories = models.ManyToManyField( 
        "categories.Category", 
        verbose_name=_("Categories"), 
        blank=True, 
        related_name="ideas",
      )

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

      def __str__(self): 
        return self.title

(env)$ python manage.py makemigrations ideas 
(env)$ python manage.py migrate ideas