Kerangka contenttypesLink to this heading#

IkhtisarLink to this heading#

At the heart of the contenttypes application is the ContentType model, which lives at django.contrib.contenttypes.models.ContentType. Instances of ContentType represent and store information about the models installed in your project, and new instances of ContentType are automatically created whenever new models are installed.

Instances of ContentType have methods for returning the model classes they represent and for querying objects from those models. ContentType also has a custom manager that adds methods for working with ContentType and for obtaining instances of ContentType for a particular model.

Relations between your models and ContentType can also be used to enable "generic" relationships between an instance of one of your models and instances of any model you have installed.

Memasang kerangka contenttypesLink to this heading#

The contenttypes framework is included in the default INSTALLED_APPS list created by django-admin startproject, but if you've removed it or if you manually set up your INSTALLED_APPS list, you can enable it by adding 'django.contrib.contenttypes' to your INSTALLED_APPS setting.

It's generally a good idea to have the contenttypes framework installed; several of Django's other bundled applications require it:

• The admin application uses it to log the history of each object added or changed through the admin interface.

• Django's authentication framework uses it to tie user permissions to specific models.

Model ContentTypeLink to this heading#

class ContentTypeLink to this definition#

Each instance of ContentType has two fields which, taken together, uniquely describe an installed model:

app_labelLink to this definition#

The name of the application the model is part of. This is taken from the app_label attribute of the model, and includes only the last part of the application's Python import path; django.contrib.contenttypes, for example, becomes an app_label of contenttypes.

modelLink to this definition#

Nama dari kelas model.

Additionally, the following property is available:

nameLink to this definition#

The human-readable name of the content type. This is taken from the verbose_name attribute of the model.

Let's look at an example to see how this works. If you already have the contenttypes application installed, and then add the sites application to your INSTALLED_APPS setting and run manage.py migrate to install it, the model django.contrib.sites.models.Site will be installed into your database. Along with it a new instance of ContentType will be created with the following values:

• app_label akan disetel menjadi 'sites' (bagian terakhir dari jalur Python django.contrib.sites).

• model akan disetel menjadi 'site'.

Metode pada instance ContentTypeLink to this heading#

Each ContentType instance has methods that allow you to get from a ContentType instance to the model it represents, or to retrieve objects from that model:

ContentType.get_object_for_this_type(**kwargs)Link to this definition#

Takes a set of valid lookup arguments for the model the ContentType represents, and does a get() lookup on that model, returning the corresponding object.

ContentType.model_class()Link to this definition#

Mengembalikan kelas model diwakilkan oleh instance ContentType ini.

For example, we could look up the ContentType for the User model:

>>> from django.contrib.contenttypes.models import ContentType
>>> ContentType.objects.get(app_label="auth", model="user")
<ContentType: user>

Dan kemudian gunakan itu pada permintaan untuk User tertentu, atau untuk mendapatkan akses ke kelas model User:

>>> user_type.model_class()
<class 'django.contrib.auth.models.User'>
>>> user_type.get_object_for_this_type(username='Guido')
<User: Guido>

Bersama-sama, meth:~django.contrib.contenttypes.models.ContentType.get_object_for_this_type dan model_class() mengadakan dua sangat penting penggunaan kasus:

1. Using these methods, you can write high-level generic code that performs queries on any installed model -- instead of importing and using a single specific model class, you can pass an app_label and model into a ContentType lookup at runtime, and then work with the model class or retrieve objects from it.

2. You can relate another model to ContentType as a way of tying instances of it to particular model classes, and use these methods to get access to those model classes.

Several of Django's bundled applications make use of the latter technique. For example, the permissions system in Django's authentication framework uses a Permission model with a foreign key to ContentType; this lets Permission represent concepts like "can add blog entry" or "can delete news story".

>>> from django.contrib.auth.models import User
>>> ContentType.objects.get_for_model(User)
<ContentType: user>

Hubungan umumLink to this heading#

Adding a foreign key from one of your own models to ContentType allows your model to effectively tie itself to another model class, as in the example of the Permission model above. But it's possible to go one step further and use ContentType to enable truly generic (sometimes called "polymorphic") relationships between models.

Contoh sederhana adalah sistem etiket, yang mungkin kelihatan seperti ini:

from django.db import models
from django.contrib.contenttypes.fields import GenericForeignKey
from django.contrib.contenttypes.models import ContentType

class TaggedItem(models.Model):
    tag = models.SlugField()
    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveIntegerField()
    content_object = GenericForeignKey('content_type', 'object_id')

    def __str__(self):              # __unicode__ on Python 2
        return self.tag

Sebuah ForeignKey biasa dapat hanya "menunjuk" satu model lain, yang berarti bahwa jika model TaggedItem menggunakan sebuah ForeignKey itu akan harus memilih satu dan hanya satu model untuk menyimpan etiket-etiket. Aplikasi contenttype menyediakan jenis bidang khusus (GenericForeignKey) yang memecahkan ini dan mengizinkan hubungan dengan model apapun.

class GenericForeignKeyLink to this definition#

Terdapat tiga bagian untuk mengatur GenericForeignKey:

1. Give your model a ForeignKey to ContentType. The usual name for this field is "content_type".

2. Give your model a field that can store primary key values from the models you'll be relating to. For most models, this means a PositiveIntegerField. The usual name for this field is "object_id".

3. Give your model a GenericForeignKey, and pass it the names of the two fields described above. If these fields are named "content_type" and "object_id", you can omit this -- those are the default field names GenericForeignKey will look for.

for_concrete_modelLink to this definition#

If False, the field will be able to reference proxy models. Default is True. This mirrors the for_concrete_model argument to get_for_model().

This will enable an API similar to the one used for a normal ForeignKey; each TaggedItem will have a content_object field that returns the object it's related to, and you can also assign to that field or use it when creating a TaggedItem:

>>> from django.contrib.auth.models import User
>>> guido = User.objects.get(username='Guido')
>>> t = TaggedItem(content_object=guido, tag='bdfl')
>>> t.save()
>>> t.content_object
<User: Guido>

Due to the way GenericForeignKey is implemented, you cannot use such fields directly with filters (filter() and exclude(), for example) via the database API. Because a GenericForeignKey isn't a normal field object, these examples will not work:

# This will fail
>>> TaggedItem.objects.filter(content_object=guido)
# This will also fail
>>> TaggedItem.objects.get(content_object=guido)

Likewise, GenericForeignKeys does not appear in ModelForms.

from django.db import models
from django.contrib.contenttypes.fields import GenericRelation

class Bookmark(models.Model):
    url = models.URLField()
    tags = GenericRelation(TaggedItem)

>>> b = Bookmark(url='https://www.djangoproject.com/')
>>> b.save()
>>> t1 = TaggedItem(content_object=b, tag='django')
>>> t1.save()
>>> t2 = TaggedItem(content_object=b, tag='python')
>>> t2.save()
>>> b.tags.all()
<QuerySet [<TaggedItem: django>, <TaggedItem: python>]>

tags = GenericRelation(TaggedItem, related_query_name='bookmarks')

>>> # Get all tags belonging to bookmarks containing `django` in the url
>>> TaggedItem.objects.filter(bookmarks__url__contains='django')
<QuerySet [<TaggedItem: django>, <TaggedItem: python>]>

>>> b = Bookmark.objects.get(url='https://www.djangoproject.com/')
>>> bookmark_type = ContentType.objects.get_for_model(b)
>>> TaggedItem.objects.filter(content_type__pk=bookmark_type.id, object_id=b.id)
<QuerySet [<TaggedItem: django>, <TaggedItem: python>]>

tags = GenericRelation(
    TaggedItem,
    content_type_field='content_type_fk',
    object_id_field='object_primary_key',
)

>>> Bookmark.objects.aggregate(Count('tags'))
{'tags__count': 3}