Django menyertakan sebuah aplikasi contenttypes yang dapat melacak semua model-model terpasang dalam proyek Django-powered anda, menyediakan tingkat-tinggi, antarmuka umum untuk bekerja dengan model-model anda.
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.
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:
\nApliaksi 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.
ContentTypeLink to this heading#Setiap instance dari ContentType mempunyai dua bidang yang, diambil bersama-sama, secara unik menggambarkan sebuah model terpasang:
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.
Nama dari kelas model.
\nSebagai tambahan, sifat berikut tersedia:
\nNama 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:
ContentTypeLink to this heading#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:
Takes a set of valid lookup arguments for the\nmodel the ContentType\nrepresents, and does\na get() lookup\non that model, returning the corresponding object. The using argument\ncan be used to specify a different database than the default one.
Mengembalikan kelas model diwakilkan oleh instance ContentType ini.
For example, we could look up the\nContentType for the\nUser model:
>>> from django.contrib.contenttypes.models import ContentType\n>>> user_type = ContentType.objects.get(app_label="auth", model="user")\n>>> user_type\n<ContentType: user>\nAnd then use it to query for a particular\nUser, or to get access\nto the User model class:
>>> user_type.model_class()\n<class 'django.contrib.auth.models.User'>\n>>> user_type.get_object_for_this_type(username="Guido")\n<User: Guido>\nBersama-sama, meth:~django.contrib.contenttypes.models.ContentType.get_object_for_this_type dan model_class() mengadakan dua sangat penting penggunaan kasus:
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.
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".
ContentTypeManagerLink to this heading#ContentType juga mempunyai pengelola penyesuaian, ContentTypeManager, yang menambahkan metode berikut:
Bersihkan cache internal digunakan oleh ContentType untuk menjaga lintasan dari model-model untuk yang itu telah membuat instance ContentType. Anda mungkin tidak pernah butuh memanggil metode ini anda sendiri; Django akan memanggil itu secara otomatis ketika itu dibutuhkan.
Pencarian ContentType berdasarkan ID. Sejak metode ini menggunakan cache dibagi yang sama seperti get_for_model(), itu lebih disukai untuk menggunakan metode ini terhadap ContentType.objects.get(pk=id) biasa
Ambil antara sebuah kelas model atau sebuah instance dari model, dan kembalikan instance ContentType mewakili model itu. for_concrete_model=False mengizinkan mengambil ContentType dari model proxy.
Mengambil sejumlah variabel apapun dari kelas-kelas model, dan mengembalikan sebuah kamus memetakan kelas-kelas model pada instance ContentType mewakili mereka. for_concrete_models=False mengizinkan mengambil ContentType dari model proxy.
Mengembalikan instance ContentType secara unik dicirikan dengan label aplikasi yang diberikan dan nama model. Tujuan utama dari metode ini adalah mengizinkan obyek ContentType untuk diacukan melalui natural key1 selama deserialisasi.
The get_for_model() method is especially\nuseful when you know you need to work with a\nContentType but don't\nwant to go to the trouble of obtaining the model's metadata to perform a manual\nlookup:
>>> from django.contrib.auth.models import User\n>>> ContentType.objects.get_for_model(User)\n<ContentType: user>\nMenambahkan 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.
Sebagai contoh, itu dapat digunakan untuk sistem pe etiketan seperti itu:
\nfrom django.contrib.contenttypes.fields import GenericForeignKey\nfrom django.contrib.contenttypes.models import ContentType\nfrom django.db import models\n\n\nclass TaggedItem(models.Model):\n tag = models.SlugField()\n content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)\n object_id = models.PositiveBigIntegerField()\n content_object = GenericForeignKey("content_type", "object_id")\n\n def __str__(self):\n return self.tag\n\n class Meta:\n indexes = [\n models.Index(fields=["content_type", "object_id"]),\n ]\nSebuah 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.
Terdapat tiga bagian untuk mengatur GenericForeignKey:
Berikan model anda sebuah ForeignKey pada ContentType. Nama biasa untuk bidang ini adalah "content_type".
Give your model a field that can store primary key values from the\nmodels you'll be relating to. For most models, this means a\nPositiveBigIntegerField. The usual name\nfor this field is "object_id".
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.
Unlike for the ForeignKey, a database index is\nnot automatically created on the\nGenericForeignKey, so it's\nrecommended that you use\nMeta.indexes to add your own\nmultiple column index. This behavior may change in the\nfuture.
Jika False, bidang akan dapat mengacukan model-model proxy. Awalan adalah True. Ini mencerminkan argumen for_concrete_model pada get_for_model().
This will enable an API similar to the one used for a normal\nForeignKey;\neach TaggedItem will have a content_object field that returns the\nobject it's related to, and you can also assign to that field or use it when\ncreating a TaggedItem:
>>> from django.contrib.auth.models import User\n>>> guido = User.objects.get(username="Guido")\n>>> t = TaggedItem(content_object=guido, tag="bdfl")\n>>> t.save()\n>>> t.content_object\n<User: Guido>\nIf the related object is deleted, the content_type and object_id fields\nremain set to their original values and the GenericForeignKey returns\nNone:
>>> guido.delete()\n>>> t.content_object # returns None\nDue to the way GenericForeignKey\nis implemented, you cannot use such fields directly with filters (filter()\nand exclude(), for example) via the database API. Because a\nGenericForeignKey isn't a\nnormal field object, these examples will not work:
# This will fail\n>>> TaggedItem.objects.filter(content_object=guido)\n# This will also fail\n>>> TaggedItem.objects.get(content_object=guido)\nLikewise, GenericForeignKeys\ndo not appear in ModelForms.
Hubungan pada obyek terkait kembali ke obyek ini tidak ada secara awalan. Pengaturan related_query_name membuat sebuah hubungan dari obyek terkait kembali ke satu ini. Ini mengizinkan meminta dan menyaring dari obyek terkait.
Jika anda mengetahui model-model mana anda akan menggunakan paling sering, anda dapat juga menambahkan hubungan umum "reverse" untuk mengadakan sebuah tambahan API. Sebagai contoh:
\nfrom django.contrib.contenttypes.fields import GenericRelation\nfrom django.db import models\n\n\nclass Bookmark(models.Model):\n url = models.URLField()\n tags = GenericRelation(TaggedItem)\nBookmark instances will each have a tags attribute, which can\nbe used to retrieve their associated TaggedItems:
>>> b = Bookmark(url="https://www.djangoproject.com/")\n>>> b.save()\n>>> t1 = TaggedItem(content_object=b, tag="django")\n>>> t1.save()\n>>> t2 = TaggedItem(content_object=b, tag="python")\n>>> t2.save()\n>>> b.tags.all()\n<QuerySet [<TaggedItem: django>, <TaggedItem: python>]>\nYou can also use add(), create(), or set() to create\nrelationships:
>>> t3 = TaggedItem(tag="Web development")\n>>> b.tags.add(t3, bulk=False)\n>>> b.tags.create(tag="Web framework")\n<TaggedItem: Web framework>\n>>> b.tags.all()\n<QuerySet [<TaggedItem: django>, <TaggedItem: python>, <TaggedItem: Web development>, <TaggedItem: Web framework>]>\n>>> b.tags.set([t1, t3])\n>>> b.tags.all()\n<QuerySet [<TaggedItem: django>, <TaggedItem: Web development>]>\nThe remove() call will bulk delete the specified model objects:
>>> b.tags.remove(t3)\n>>> b.tags.all()\n<QuerySet [<TaggedItem: django>]>\n>>> TaggedItem.objects.all()\n<QuerySet [<TaggedItem: django>]>\nThe clear() method can be used to bulk delete all related objects for an\ninstance:
>>> b.tags.clear()\n>>> b.tags.all()\n<QuerySet []>\n>>> TaggedItem.objects.all()\n<QuerySet []>\nMenentukan GenericRelation dengan kumpulan related_query_name mengizinkan meminta dari obyek terkait:
tags = GenericRelation(TaggedItem, related_query_name="bookmark")\nThis enables filtering, ordering, and other query operations on Bookmark\nfrom TaggedItem:
>>> # Get all tags belonging to bookmarks containing `django` in the url\n>>> TaggedItem.objects.filter(bookmark__url__contains="django")\n<QuerySet [<TaggedItem: django>, <TaggedItem: python>]>\nIf you don't add the related_query_name, you can do the same types of\nlookups manually:
>>> bookmarks = Bookmark.objects.filter(url__contains="django")\n>>> bookmark_type = ContentType.objects.get_for_model(Bookmark)\n>>> TaggedItem.objects.filter(content_type__pk=bookmark_type.id, object_id__in=bookmarks)\n<QuerySet [<TaggedItem: django>, <TaggedItem: python>]>\nSama seperti GenericForeignKey menerima nama-nama dari bidang content-type dan object-ID sebagai argumen, begitu juga GenericRelation; jika model yang mempunyai foreign key umum menggunakan nama bukan-awalan untuk bidang-bidang tersebut, anda harus melewatkan nama-nama dari bidang ketika mengatur sebuah GenericRelation untuk itu. Sebagai contoh, jika model TaggedItem mengacu pada diatas menggunakan bidang bernama content_type_fk dan object_primary_key untuk membuat foreign key umumnya, kemudian GenericRelation kembali ke itu akan butuh ditentukan seperti itu:
tags = GenericRelation(\n TaggedItem,\n content_type_field="content_type_fk",\n object_id_field="object_primary_key",\n)\nCatat juga, bahwa jika anda menghapus sebuah obyek yang mempunyai sebuah GenericRelation, obyek apapun yang mempunyai GenericForeignKey menunjuk ke itu akan dihapus juga. Dalam contoh diatas, ini berarti bahwa jika sebuah obyek Bookmark dihapus, obyek TaggedItem apapun menunjuk pada itu akan dihapus pada waktu yang sama.
Unlike ForeignKey,\nGenericForeignKey does not accept\nan on_delete argument to customize this\nbehavior; if desired, you can avoid the cascade-deletion by not using\nGenericRelation, and alternate\nbehavior can be provided via the pre_delete\nsignal.
Django's database aggregation API works with a\nGenericRelation. For example, you\ncan find out how many tags all the bookmarks have:
>>> Bookmark.objects.aggregate(Count("tags"))\n{'tags__count': 3}\nModul django.contrib.contenttypes.forms menyediakan:
Pabrik formset, generic_inlineformset_factory(), untuk digunakan dengan GenericForeignKey.
Mengembalikan GenericInlineFormSet menggunakan modelformset_factory().
Anda harus menyediakan ct_field dan fk_field jika mereka berbeda dari awalan, content_type dan object_id masing-masing. Parameter lain adalah mirip ke yang didokumentasi di modelformset_factory() dan inlineformset_factory().
Argumen for_concrete_model berhubungan ke argumen for_concrete_model pada GenericForeignKey.
Modul django.contrib.contenttypes.admin menyediakan GenericTabularInline dan GenericStackedInline (subkelas-subkelas dari GenericInlineModelAdmin)
Kelas-kelas dan fungsi-fungsi ini mengadakan penggunaan hubungan umum di formulir dan admin. Lihat dokumentasi model formset dan admin untuk informasi lebih.
\nKelas GenericInlineModelAdmin mewarisi semua sifat-sifat dari sebuah kelas InlineModelAdmin. Bagaimanapun, itu menambahkan sebuah pasang dari itu sendiri untuk bekerja dengan hubungan umum:
Nama dari bidang foreign key ContentType pada model. Awalan pada content_type.
Nama dari bidang integer yang mewakili ID dari obyek terkait. Awalan pada object_id.
Subkelas-subkelas dari GenericInlineModelAdmin dengan tata letak bertumpuk dan datar, masing-masing.
GenericPrefetch()Link to this heading#This lookup is similar to Prefetch() and it should only be used on\nGenericForeignKey. The querysets argument accepts a list of querysets,\neach for a different ContentType. This is useful for GenericForeignKey\nwith non-homogeneous set of results.
>>> from django.contrib.contenttypes.prefetch import GenericPrefetch\n>>> bookmark = Bookmark.objects.create(url="https://www.djangoproject.com/")\n>>> animal = Animal.objects.create(name="lion", weight=100)\n>>> TaggedItem.objects.create(tag="great", content_object=bookmark)\n>>> TaggedItem.objects.create(tag="awesome", content_object=animal)\n>>> prefetch = GenericPrefetch(\n... "content_object", [Bookmark.objects.all(), Animal.objects.only("name")]\n... )\n>>> TaggedItem.objects.prefetch_related(prefetch).all()\n<QuerySet [<TaggedItem: Great>, <TaggedItem: Awesome>]>\n