Kerangka contenttypes¶

Ikhtisar¶

Di jantung dari aplikasi contenttype adalah model ContentType, yang tinggal di django.contrib.contenttypes.models.ContentType`. Instance dari ContentType mewakili dan menyimpan informasi tentang model-model terpasang dalam proyek anda, dan instance baru dari ContentType otomatis dibuat ketika model-model baru terpasang.

Instance dari ContentType mempunai metode-metode untuk mengembalikan kelas-kelas model mereka wakilkan dan untuk meminta obyek dari model-model itu. ContentType juga mempunyai sebuah custom manager 1 yang menambahkan metode untuk bekerja dengan ContentType dan untuk mendapatkan instance dari ContentType untuk model tertentu.

Hubungan diantara model-model anda dan ContentType dapat juga digunakan untuk mengadakan hubungan "umum" diantara sebuah instance dari satu dari model-model anda dan instance dari model apapun anda telah pasang.

Memasang kerangka contenttypes¶

Kerangka kerja contenttype disertakan dalam daftar INSTALLED_APPS awalan dibuat oleh django-admin startproject, tetapi jika anda telah memindahkan itu atau jika anda secara manual menyetel daftar INSTALLED_APPS anda, anda dapat mengadakan itu dengan menambahkan 'django.contrib.contenttypes' ke pengaturan INSTALLED_APPS anda.

Umumnya ide bagus memiliki kerangka contenttype terpasang; beberapa aplikasi gabungan lain Django membutuhkan itu:

• Apliaksi admin menggunakan itu utuk mencatat riwayat dari setiap obyek ditambahkan atau dirubah melalui antarmuka admin.
• authentication framework Django menggunakan itu untuk mengikat perizinan pengguna pada model-model tertentu.

Model ContentType¶

class ContentType¶

Setiap instance dari ContentType mempunyai dua bidang yang, diambil bersama-sama, secara unik menggambarkan sebuah model terpasang:

app_label¶

Nama dari aplikasi model adalah bagian darinya. Ini diambil dari atribut app_label dari model, dan menyertakan hanya bagian terakhir dari django.contrib.contenttypes jalur impor Python aplikasi, sebagai contoh, menjadi app_label dari contenttypes.

model¶

Nama dari kelas model.

Sebagai tambahan, sifat berikut tersedia:

name¶

Nama dapat-dibaca-manusia dari jenis isi. Ini adalah diambil dari atribut verbose_name dari model.

Mari kita lihat sebuah contoh untuk melihat bagaimana ini bekerja. Jika anda seudah memiliki aplikasi contenttypes terpasang, dan kemudian tambah the sites application ke pengaturan INSTALLED_APPS anda dan menjalankan manage.py migrate untuk memasangnya, model django.contrib.sites.models.Site akan dipasang kedalam basisdata anda. Bersama dengan itu sebuah instance baru dari ContentType akan dibuat dengan nilai-nilai berikut:

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

Metode pada instance ContentType¶

Setiap instance ContentType mempunyai metode-metode yang mengizinkan anda mendapatkan dari sebuah instance ContentType pada model yang itu wakili, atau untuk mengambil obyek-obyek dari model itu:

ContentType.get_object_for_this_type(**kwargs)¶

Mengambil sekumpulan dari perwakilan lookup arguments 1 for the model the ContentType sah, dan melakukan a get() lookup pada model itu, mengembalikan obyek yang sesuai.

ContentType.model_class()¶

Mengembalikan kelas model diwakilkan oleh instance ContentType ini.

Sebagai contoh, kami dapat mencari ContentType untuk model User:

>>> 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. Menggunakan metode ini, anda dapat menulis kode umum tingkat-tinggi yang melakukan permintaan pada mode terpasang apapun -- daripada mengimpor dan menggunakan kelas model khusus, anda dapat melewatkan sebuah app_label dan model kedalam sebuah pencarian ContentType pada waktu berjalan dan kemudian bekerja dengan kelas model atau mengambil obyek dari itu.
2. Anda dapat menghubungkan model lain ke ContentType sebagai sebuah cara dari mengikat instance dari itu ke kelas-kelas model tertentu, dan gunakan metode ini untuk mendapatkan akses ke kelas-kelas model tersebut.

Beberapa dari aplikasi gabungan Django membuat dari teknik terakhir. Sebagai contoh, the permissions system dalam kerangka kerja autentifikasi Django menggunakan model Permission dengan sebuah foreign key pada ContentType; ini membuat Permission mewakili konsep-konsep seperti "dapat menambah masukan blog" atau "dapat menghapus cerita berita".

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

Hubungan umum¶

Menambahkan sebuah foreign key dari satu dari model anda sendiri pada ContentType mengizinkan model anda secara efektif mengikat diri sendiri ke kelas model lain, seperti dalam contoh dari model Permission diatas. Tetapi itu memungkinkan pergi satu langkah lebih jauh dan menggunakan ContentType untuk mengadakan hubungan umum sebenarnya (terkadang disebut "polimorfik") diantara model.

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 GenericForeignKey¶

Terdapat tiga bagian untuk mengatur GenericForeignKey:

1. Berikan model anda sebuah ForeignKey pada ContentType. Nama biasa untuk bidang ini adalah "content_type".
2. Berikan model anda sebuah bidang yang dapat menyimpan nilai-nilai primary key dari model-model anda akan kaitkan. Untuk kebanyakan model, ini berarti PositiveIntegerField. Nama biasa untuk bidang ini adalah "object_id".
3. Berikan model anda GenericForeignKey, dan lewatkan itu nama-nama dari dua bidang digambarkan diatas. Jika bidang-bidang ini bernama "content_type" dan "object_id", anda dapat mengabaikan ini --yaitu nama-nama bidang awalan GenericForeignKey akan mencari.

for_concrete_model¶

Jika False, bidang akan dapat mengacukan model-model proxy. Awalan adalah True. Ini mencerminkan argumen for_concrete_model pada get_for_model().

Ini akan mengadakan sebuah API mitip pada satu digunakan untuk ForeignKey; biasa setiap TaggedItem akan mempunyai sebuah bidang content_object yang mengembalikan obyek yang terkait dengan, dan anda dapat juga menugaskan ke bidang itu atau menggunakan itu ketika membuat sebuah 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>

Dikarenakan cara GenericForeignKey diterapkan, anda tidak dapat menggunakan bidang-bidang itu langsung dengan penyaring (filter() dan exclude(), sebagai contoh) melalui API basisdata. Karena GenericForeignKey bukan obyek bisang biasa, contoh-contoh ini akan tidak bekerja:

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

Juga, GenericForeignKey tidak muncul dalam ModelForm.

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}