Django व्यवस्थापक साइट

Django के सबसे शक्तिशाली भागों में से एक स्वचालित व्यवस्थापक इंटरफ़ेस है। यह एक त्वरित, मॉडल-केंद्रित इंटरफ़ेस प्रदान करने के लिए आपके मॉडल से मेटाडेटा पढ़ता है जहां विश्वसनीय उपयोगकर्ता आपकी साइट पर सामग्री का प्रबंधन कर सकते हैं। व्यवस्थापक का अनुशंसित उपयोग संगठन के आंतरिक प्रबंधन उपकरण तक सीमित है। यह आपके पूरे सामने के अंत के निर्माण के लिए अभिप्रेत नहीं है।

अनुकूलन के लिए व्यवस्थापक के पास कई हुक हैं, लेकिन विशेष रूप से उन हुक का उपयोग करने की कोशिश करने से सावधान रहें। यदि आपको एक और अधिक प्रक्रिया-केंद्रित इंटरफ़ेस प्रदान करने की आवश्यकता है जो डेटाबेस तालिकाओं और क्षेत्रों के कार्यान्वयन के विवरण को दूर कर देता है, तो शायद यह आपके अपने विचारों को लिखने का समय है।

इस दस्तावेज़ में हम चर्चा करते हैं कि Django के व्यवस्थापक इंटरफ़ेस को कैसे सक्रिय करें, उपयोग करें और अनुकूलित करें।

अवलोकन

व्यवस्थापक startproject द्वारा उपयोग किए जाने वाले डिफ़ॉल्ट प्रोजेक्ट टेम्पलेट में सक्षम है।

संदर्भ के लिए, यहाँ आवश्यकताएँ हैं:

1. अपनी INSTALLED_APPS सेटिंग में 'django.contrib.admin' जोड़ें।
2. व्यवस्थापक की चार निर्भरताएं हैं - django.contrib.auth , django.contrib.contenttypes , django.contrib.messages और django.contrib.sessions । यदि ये एप्लिकेशन आपकी INSTALLED_APPS सूची में नहीं हैं, तो उन्हें जोड़ें।
3. django.contrib.auth.context_processors.auth और django.contrib.messages.context_processors.messages को अपने DjangoTemplates में DjangoTemplates बैकेंड के 'context_processors' DjangoTemplates 'context_processors' विकल्प के रूप में अच्छी तरह से django.contrib.auth.middleware.AuthenticationMiddleware django.contrib.messages.middleware.MessageMiddleware लिए। ये सभी डिफ़ॉल्ट रूप से सक्रिय हैं, इसलिए आपको केवल ऐसा करने की आवश्यकता है यदि आपने सेटिंग्स को मैन्युअल रूप से बदल दिया है।
4. निर्धारित करें कि आपके एप्लिकेशन के कौन से मॉडल को व्यवस्थापक इंटरफ़ेस में संपादन योग्य होना चाहिए।
5. उन मॉडलों में से प्रत्येक के लिए, वैकल्पिक रूप से एक ModelAdmin वर्ग बनाएं जो उस विशेष मॉडल के लिए अनुकूलित व्यवस्थापक कार्यक्षमता और विकल्पों को ModelAdmin करता है।
6. एक AdminSite और इसे अपने प्रत्येक मॉडल और ModelAdmin वर्गों के बारे में बताएं।
7. अपने URLconf में AdminSite उदाहरण को हुक करें।

आपके द्वारा ये कदम उठाए जाने के बाद, आप अपने Django व्यवस्थापक साइट का उपयोग उस URL पर जाकर कर सकते हैं जिसे आपने इसे ( /admin/ डिफ़ॉल्ट रूप से) झुका दिया है। यदि आपको लॉगिन करने के लिए उपयोगकर्ता बनाने की आवश्यकता है, तो आप createsuperuser कमांड का उपयोग कर सकते हैं।

अन्य विषय

• प्रशासन की कार्रवाई
• Django व्यवस्थापक प्रलेखन जनरेटर
• व्यवस्थापक में जावास्क्रिप्ट अनुकूलन

ModelAdmin ऑब्जेक्ट्स

class ModelAdmin [source]

ModelAdmin वर्ग व्यवस्थापक इंटरफ़ेस में एक मॉडल का प्रतिनिधित्व है। आमतौर पर, ये आपके एप्लिकेशन में admin.py नामक फ़ाइल में संग्रहीत होते हैं। आइए ModelAdmin एक बहुत ही सरल उदाहरण पर एक नज़र ModelAdmin :

from django.contrib import admin
from myproject.myapp.models import Author

class AuthorAdmin(admin.ModelAdmin):
    pass
admin.site.register(Author, AuthorAdmin)

क्या आपको एक ModelAdmin ऑब्जेक्ट की आवश्यकता है?

पूर्ववर्ती उदाहरण में, ModelAdmin वर्ग किसी भी कस्टम मान (अभी तक) को परिभाषित नहीं करता है। नतीजतन, डिफ़ॉल्ट व्यवस्थापक इंटरफ़ेस प्रदान किया जाएगा। यदि आप डिफ़ॉल्ट व्यवस्थापक इंटरफ़ेस से खुश हैं, तो आपको एक ModelAdmin ऑब्जेक्ट को बिल्कुल भी परिभाषित करने की आवश्यकता नहीं है - आप ModelAdmin विवरण प्रदान किए बिना मॉडल वर्ग को पंजीकृत कर सकते हैं। पूर्ववर्ती उदाहरण को सरल बनाया जा सकता है:

from django.contrib import admin
from myproject.myapp.models import Author

admin.site.register(Author)

register डेकोरेटर

register(*models, site=django.admin.sites.site) [source]

अपने ModelAdmin वर्गों को पंजीकृत करने के लिए एक डेकोरेटर भी है:

from django.contrib import admin
from .models import Author

@admin.register(Author)
class AuthorAdmin(admin.ModelAdmin):
    pass

ModelAdmin साथ पंजीकरण करने के लिए इसे एक या एक से अधिक मॉडल कक्षाएं दी ModelAdmin । यदि आप एक कस्टम AdminSite का उपयोग कर रहे हैं, तो इसे site कीवर्ड तर्क का उपयोग करके पास करें:

from django.contrib import admin
from .models import Author, Editor, Reader
from myproject.admin_site import custom_admin_site

@admin.register(Author, Reader, Editor, site=custom_admin_site)
class PersonAdmin(admin.ModelAdmin):
    pass

यदि आप अपने मॉडल व्यवस्थापक वर्ग को उसके __init__() पद्धति, उदाहरण के लिए super(PersonAdmin, self).__init__(*args, **kwargs) __init__() में संदर्भित करना चाहते हैं, तो आप इस डेकोरेटर का उपयोग नहीं कर सकते। आप super().__init__(*args, **kwargs) उपयोग कर सकते हैं।

व्यवस्थापक फ़ाइलों की खोज

जब आप अपनी INSTALLED_APPS सेटिंग में 'django.contrib.admin' , तो Django स्वचालित रूप से प्रत्येक एप्लिकेशन में एक admin मॉड्यूल की तलाश करता है और इसे आयात करता है।

class apps.AdminConfig

यह व्यवस्थापक के लिए डिफ़ॉल्ट AppConfig वर्ग है। यह Django शुरू होने पर autodiscover() कहता है।

class apps.SimpleAdminConfig

यह वर्ग AdminConfig तरह काम करता है, सिवाय इसके कि यह autodiscover() कॉल नहीं करता।

default_site

Django 2.1 में नया:

डिफ़ॉल्ट व्यवस्थापक साइट के वर्ग या किसी कॉल करने योग्य डॉटेड आयात पथ जो साइट उदाहरण देता है। 'django.contrib.admin.sites.AdminSite' लिए डिफ़ॉल्ट। उपयोग के लिए डिफ़ॉल्ट व्यवस्थापक साइट को ओवरराइड करना देखें।

autodiscover() [source]

यह फ़ंक्शन प्रत्येक इंस्टॉल किए गए एप्लिकेशन में एक admin मॉड्यूल आयात करने का प्रयास करता है। ऐसे मॉड्यूल से व्यवस्थापक के साथ मॉडल को पंजीकृत करने की अपेक्षा की जाती है।

आमतौर पर आपको इस फ़ंक्शन को सीधे कॉल करने की आवश्यकता नहीं होगी क्योंकि Django शुरू होने पर AdminConfig इसे कॉल करता है।

यदि आप एक कस्टम AdminSite का उपयोग कर रहे हैं, तो आपके कोड में सभी ModelAdmin उपवर्गों को आयात करना और उन्हें कस्टम AdminSite पंजीकृत करना AdminSite । उस स्थिति में, ऑटो-डिस्कवरी को अक्षम करने के लिए, आपको अपनी 'django.contrib.admin' सेटिंग में 'django.contrib.admin.apps.SimpleAdminConfig' बजाय 'django.contrib.admin.apps.SimpleAdminConfig' डालना चाहिए।

ModelAdmin विकल्प

ModelAdmin बहुत लचीला है। इंटरफ़ेस को कस्टमाइज़ करने के लिए इसके पास कई विकल्प हैं। सभी विकल्प ModelAdmin उपवर्ग पर परिभाषित किए गए हैं:

from django.contrib import admin

class AuthorAdmin(admin.ModelAdmin):
    date_hierarchy = 'pub_date'

ModelAdmin.actions

परिवर्तन सूची पृष्ठ पर उपलब्ध कराने के लिए क्रियाओं की एक सूची। विवरण के लिए व्यवस्थापक क्रियाएँ देखें।

ModelAdmin.actions_on_top

ModelAdmin.actions_on_bottom

नियंत्रण जहां पृष्ठ पर क्रिया बार दिखाई देता है। डिफ़ॉल्ट रूप से, व्यवस्थापक actions_on_top = True; actions_on_bottom = False पृष्ठ के शीर्ष पर क्रियाएँ प्रदर्शित करता है ( actions_on_top = True; actions_on_bottom = False )।

ModelAdmin.actions_selection_counter

यह नियंत्रित करता है कि एक्शन ड्रॉपडाउन के आगे चयन काउंटर प्रदर्शित किया गया है या नहीं। डिफ़ॉल्ट रूप से, व्यवस्थापक actions_selection_counter = True यह प्रदर्शित करेगा ( actions_selection_counter = True )।

ModelAdmin.date_hierarchy

अपने मॉडल में DateField या DateTimeField के नाम के लिए date_hierarchy सेट करें, और परिवर्तन सूची पृष्ठ में उस क्षेत्र द्वारा दिनांक-आधारित ड्रिलडाउन नेविगेशन शामिल होगा।

उदाहरण:

date_hierarchy = 'pub_date'

आप उदाहरण के लिए, __ लुकअप का उपयोग करके संबंधित मॉडल पर एक फ़ील्ड निर्दिष्ट कर सकते हैं:

date_hierarchy = 'author__pub_date'

यह होशियारी से उपलब्ध आंकड़ों के आधार पर खुद को आबाद करेगा, उदाहरण के लिए यदि सभी तिथियां एक महीने में हैं, तो यह केवल दिन-स्तर की ड्रिल-डाउन दिखाएगी।

ध्यान दें

date_hierarchy आंतरिक रूप से QuerySet.datetimes() का उपयोग करता है। जब समय समर्थन ( USE_TZ = True ) सक्षम हो, तो कुछ USE_TZ = True लिए इसके दस्तावेज़ देखें।

ModelAdmin.empty_value_display

यह विशेषता रिकॉर्ड के फ़ील्ड के लिए डिफ़ॉल्ट प्रदर्शन मान को ओवरराइड करती है जो खाली हैं ( None , खाली स्ट्रिंग, आदि)। डिफ़ॉल्ट मान है - (एक डैश)। उदाहरण के लिए:

from django.contrib import admin

class AuthorAdmin(admin.ModelAdmin):
    empty_value_display = '-empty-'

आप empty_value_display के साथ, या इस तरह के विशिष्ट क्षेत्रों के लिए सभी व्यवस्थापक पृष्ठों के लिए empty_value_display को भी ओवरराइड कर सकते हैं:

from django.contrib import admin

class AuthorAdmin(admin.ModelAdmin):
    fields = ('name', 'title', 'view_birth_date')

    def view_birth_date(self, obj):
        return obj.birth_date

    view_birth_date.empty_value_display = '???'

ModelAdmin.exclude

यह विशेषता, यदि दी गई है, तो फॉर्म से बाहर करने के लिए फ़ील्ड नामों की एक सूची होनी चाहिए।

उदाहरण के लिए, आइए निम्नलिखित मॉडल पर विचार करें:

from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)
    title = models.CharField(max_length=3)
    birth_date = models.DateField(blank=True, null=True)

यदि आप Author मॉडल के लिए एक फॉर्म चाहते हैं जिसमें केवल name और title फ़ील्ड शामिल हैं, तो आप fields निर्दिष्ट करेंगे या इस तरह से exclude करेंगे:

from django.contrib import admin

class AuthorAdmin(admin.ModelAdmin):
    fields = ('name', 'title')

class AuthorAdmin(admin.ModelAdmin):
    exclude = ('birth_date',)

चूंकि लेखक मॉडल में केवल तीन फ़ील्ड हैं, name , title और birth_date , उपरोक्त घोषणाओं के परिणामस्वरूप होने वाले रूपों में बिल्कुल समान फ़ील्ड होंगे।

ModelAdmin.fields

"ऐड" और "परिवर्तन" पेजों में फॉर्म में सरल लेआउट परिवर्तन करने के लिए fields विकल्प का उपयोग करें जैसे कि केवल उपलब्ध फ़ील्ड का सबसेट दिखाना, उनके आदेश को संशोधित करना या उन्हें पंक्तियों में समूहित करना। उदाहरण के लिए, आप django.contrib.flatpages.models.FlatPage मॉडल के लिए व्यवस्थापक फ़ॉर्म के एक सरल संस्करण को निम्नानुसार परिभाषित कर सकते हैं:

class FlatPageAdmin(admin.ModelAdmin):
    fields = ('url', 'title', 'content')

उपरोक्त उदाहरण में, केवल फ़ील्ड url , title और content को प्रदर्शित किया जाएगा, क्रमिक रूप से, प्रपत्र में। fields में केवल पढ़ने के लिए प्रदर्शित होने वाले ModelAdmin.readonly_fields में परिभाषित मूल्य हो सकते हैं।

अधिक जटिल लेआउट आवश्यकताओं के लिए, fieldsets विकल्प देखें।

fields विकल्प list_display के समान मानों को स्वीकार करता है, सिवाय इसके कि list_display स्वीकार नहीं किए जाते हैं। मॉडल और मॉडल व्यवस्थापक विधियों के नाम केवल तभी उपयोग किए जाएंगे जब वे ModelAdmin.readonly_fields में सूचीबद्ध हों।

एक ही पंक्ति में कई फ़ील्ड प्रदर्शित करने के लिए, उन फ़ील्ड्स को अपने स्वयं के ट्यूपल में लपेटें। इस उदाहरण में, url और title फ़ील्ड एक ही पंक्ति में प्रदर्शित होंगे और content फ़ील्ड उनके नीचे अपनी पंक्ति में प्रदर्शित होगी:

class FlatPageAdmin(admin.ModelAdmin):
    fields = (('url', 'title'), 'content')

ध्यान दें

यह fields विकल्प fields शब्दकोश कुंजी के साथ भ्रमित नहीं होना चाहिए जो fields विकल्प के भीतर है, जैसा कि अगले भाग में वर्णित है।

यदि न तो fields और न ही fieldsets विकल्प मौजूद हैं, तो Django प्रत्येक फ़ील्ड को प्रदर्शित करने के लिए डिफ़ॉल्ट होगा जो एक AutoField नहीं है और एक एकल AutoField में editable=True , उसी क्रम में जैसे फ़ील्ड मॉडल में परिभाषित किए गए हैं।

ModelAdmin.fieldsets

व्यवस्थापक "लेआउट" और "परिवर्तन" पृष्ठों के लेआउट को नियंत्रित करने के लिए fieldsets सेट करें।

fieldsets दो- fieldsets की एक सूची है, जिसमें प्रत्येक दो-टपल व्यवस्थापक प्रपत्र पृष्ठ पर एक <fieldset> प्रतिनिधित्व करता है। (ए <fieldset> फ़ॉर्म का "अनुभाग" है)

दो- (name, field_options) प्रारूप (name, field_options) , जहां name (name, field_options) के शीर्षक का प्रतिनिधित्व करने वाला एक स्ट्रिंग है और field_options बारे में जानकारी का एक शब्दकोश है, जिसमें प्रदर्शित किए जाने वाले फ़ील्ड की एक सूची भी शामिल है।

एक पूर्ण उदाहरण, django.contrib.flatpages.models.FlatPage मॉडल से लिया गया है:

from django.contrib import admin

class FlatPageAdmin(admin.ModelAdmin):
    fieldsets = (
        (None, {
            'fields': ('url', 'title', 'content', 'sites')
        }),
        ('Advanced options', {
            'classes': ('collapse',),
            'fields': ('registration_required', 'template_name'),
        }),
    )

इसके परिणामस्वरूप ऐसा व्यवस्थापक पृष्ठ दिखाई देता है:

यदि न तो fieldsets और न ही fields विकल्प मौजूद हैं, तो Django प्रत्येक फ़ील्ड को प्रदर्शित करने में डिफ़ॉल्ट होगा जो एक AutoField नहीं है और एक एकल AutoField में editable=True , उसी क्रम में जैसे फ़ील्ड मॉडल में परिभाषित किए गए हैं।

field_options शब्दकोश में निम्नलिखित कुंजी हो सकती हैं:

• fields

  इस फ़ील्ड में प्रदर्शित करने के लिए फ़ील्ड नामों का एक टपल। यह कुंजी आवश्यक है।

  उदाहरण:

  {
  'fields': ('first_name', 'last_name', 'address', 'city', 'state'),
  }
  

  fields विकल्प के साथ, एक ही पंक्ति में कई फ़ील्ड प्रदर्शित करने के लिए, उन फ़ील्ड को अपने स्वयं के ट्यूपल में लपेटें। इस उदाहरण में, first_name और last_name फ़ील्ड एक ही पंक्ति में प्रदर्शित होंगे:

  {
  'fields': (('first_name', 'last_name'), 'address', 'city', 'state'),
  }
  

  fields में ModelAdmin.readonly_fields लिए प्रदर्शित किए जाने वाले ModelAdmin.readonly_fields में परिभाषित मान शामिल हो सकते हैं।

  यदि आप fields कॉल करने योग्य का नाम जोड़ते fields , तो fields विकल्प के साथ भी यही नियम लागू होता है: कॉल करने योग्य को ModelAdmin.readonly_fields में सूचीबद्ध होना चाहिए।

• classes

  फ़ील्ड पर लागू करने के लिए अतिरिक्त सीएसएस कक्षाओं वाली एक सूची या टपल।

  उदाहरण:

  {
  'classes': ('wide', 'extrapretty'),
  }
  

  डिफ़ॉल्ट व्यवस्थापक साइट स्टाइलशीट द्वारा परिभाषित दो उपयोगी कक्षाएं collapse और wide । collapse शैली वाले फ़ील्ड्स को शुरू में व्यवस्थापक में ढहा दिया जाएगा और एक छोटे से "विस्तार के लिए क्लिक करें" लिंक के साथ बदल दिया जाएगा। wide शैली वाले फ़ील्ड को अतिरिक्त क्षैतिज स्थान दिया जाएगा।

• description

  प्रत्येक फ़ील्डसेट के शीर्ष पर प्रदर्शित होने वाले वैकल्पिक अतिरिक्त पाठ की एक स्ट्रिंग, फ़ील्ड के शीर्ष के नीचे। यह स्ट्रिंग अपने लेआउट के कारण TabularInline के लिए प्रदान नहीं की गई है।

  ध्यान दें कि जब यह व्यवस्थापक इंटरफ़ेस में प्रदर्शित होता है तो यह मान HTML- बच नहीं जाता है। यदि आप ऐसा चाहते हैं तो यह आपको HTML को शामिल करने देता है। वैकल्पिक रूप से आप किसी भी HTML विशेष वर्णों से बचने के लिए सादे पाठ और django.utils.html.escape() का उपयोग कर सकते हैं।

ModelAdmin.filter_horizontal

डिफ़ॉल्ट रूप से, एक ManyToManyField को व्यवस्थापक साइट में एक <select multiple> साथ प्रदर्शित किया जाता है। हालाँकि, कई आइटमों का चयन करते समय बहु-चयनित बक्से का उपयोग करना मुश्किल हो सकता है। इस सूची में ManyToManyField को जोड़ने के बजाय निफ्टी विनीत जावास्क्रिप्ट "फ़िल्टर" इंटरफ़ेस का उपयोग करेगा जो विकल्पों के भीतर खोज करने की अनुमति देता है। अचयनित और चयनित विकल्प अगल-बगल दो बॉक्स में दिखाई देते हैं। ऊर्ध्वाधर इंटरफ़ेस का उपयोग करने के लिए filter_vertical देखें।

ModelAdmin.filter_vertical

filter_horizontal रूप में समान है, लेकिन चयनित विकल्पों के बॉक्स के ऊपर दिखाई देने वाले अचयनित विकल्पों के बॉक्स के साथ फ़िल्टर इंटरफ़ेस का एक ऊर्ध्वाधर प्रदर्शन करता है।

ModelAdmin.form

डिफ़ॉल्ट रूप से एक ModelForm गतिशील रूप से आपके मॉडल के लिए बनाया जाता है। इसका उपयोग ऐड / चेंज पेज दोनों पर प्रस्तुत फॉर्म बनाने के लिए किया जाता है। आप ऐड / चेंज पेजों पर किसी भी डिफ़ॉल्ट फॉर्म व्यवहार को ओवरराइड करने के लिए आसानी से अपना खुद का ModelForm प्रदान कर सकते हैं। वैकल्पिक रूप से, आप ModelAdmin.get_form() पद्धति का उपयोग करके पूरी तरह से नया निर्दिष्ट करने के बजाय डिफ़ॉल्ट रूप को अनुकूलित कर सकते हैं।

एक उदाहरण के लिए व्यवस्थापक को कस्टम सत्यापन जोड़ना अनुभाग देखें।

ध्यान दें

यदि आप एक Meta.model पर Meta.model विशेषता को परिभाषित करते हैं, तो आपको Meta.fields विशेषता (या Meta.exclude विशेषता) को भी परिभाषित करना होगा। हालांकि, चूंकि व्यवस्थापक के पास खेतों को परिभाषित करने का अपना तरीका है, इसलिए Meta.fields विशेषता को अनदेखा किया जाएगा।

यदि ModelForm केवल व्यवस्थापक के लिए उपयोग होने जा रहा है, तो सबसे आसान उपाय Meta.model विशेषता को Meta.model है, क्योंकि ModelAdmin उपयोग करने के लिए सही मॉडल प्रदान करेगा। वैकल्पिक रूप से, आप ModelForm पर सत्यापन को संतुष्ट करने के लिए Meta क्लास में fields = [] सेट कर सकते हैं।

ध्यान दें

यदि आपका ModelForm और ModelAdmin दोनों एक exclude विकल्प को परिभाषित करते exclude तो ModelAdmin पूर्वता लेता है:

from django import forms
from django.contrib import admin
from myapp.models import Person

class PersonForm(forms.ModelForm):

    class Meta:
        model = Person
        exclude = ['name']

class PersonAdmin(admin.ModelAdmin):
    exclude = ['age']
    form = PersonForm

उपरोक्त उदाहरण में, "आयु" फ़ील्ड को बाहर कर दिया जाएगा लेकिन "नाम" फ़ील्ड को जनरेट किए गए फ़ॉर्म में शामिल किया जाएगा।

ModelAdmin.formfield_overrides

यह व्यवस्थापक में उपयोग के लिए Field विकल्पों में से कुछ को ओवरराइड करने का एक त्वरित और गंदा तरीका प्रदान करता है। formfield_overrides एक डिक्शनरी टाइम पर फील्ड में पास होने के लिए तर्कों की एक तानाशाही के लिए फील्ड क्लास मैपिंग है।

चूंकि यह थोड़ा सार है, आइए एक ठोस उदाहरण देखें। formfield_overrides का सबसे आम उपयोग एक निश्चित प्रकार के क्षेत्र के लिए एक कस्टम विजेट जोड़ना है। तो, कल्पना कीजिए कि हमने एक RichTextEditorWidget लिखा है जिसे हम डिफ़ॉल्ट <textarea> बजाय बड़े टेक्स्ट फ़ील्ड के लिए उपयोग करना चाहते हैं। यहां बताया गया है कि हम ऐसा कैसे करेंगे:

from django.contrib import admin
from django.db import models

# Import our custom widget and our model from where they're defined
from myapp.models import MyModel
from myapp.widgets import RichTextEditorWidget

class MyModelAdmin(admin.ModelAdmin):
    formfield_overrides = {
        models.TextField: {'widget': RichTextEditorWidget},
    }

ध्यान दें कि शब्दकोश में कुंजी वास्तविक फ़ील्ड वर्ग है, स्ट्रिंग नहीं । मान एक और शब्दकोश है; इन तर्कों को फॉर्म फील्ड की __init__() विधि से पास किया जाएगा। विवरण के लिए प्रपत्र एपीआई देखें।

चेतावनी

यदि आप किसी रिलेशनशिप फील्ड के साथ कस्टम विजेट का उपयोग करना चाहते हैं (जैसे कि radio_fields या radio_fields ), तो सुनिश्चित करें कि आपने उस क्षेत्र का नाम raw_id_fields , radio_fields या autocomplete_fields में शामिल नहीं किया है।

formfield_overrides आपको उन संबंध क्षेत्रों पर विजेट बदलने की अनुमति नहीं देगा जिनके पास raw_id_fields , radio_fields या autocomplete_fields सेट हैं। ऐसा इसलिए है क्योंकि raw_id_fields , radio_fields , और autocomplete_fields अपने स्वयं के कस्टम विगेट्स radio_fields हैं।

ModelAdmin.inlines

नीचे InlineModelAdmin ऑब्जेक्ट्स के साथ-साथ ModelAdmin.get_formsets_with_inlines() ।

ModelAdmin.list_display

व्यवस्थापक के परिवर्तन सूची पृष्ठ पर कौन से फ़ील्ड प्रदर्शित किए जाते हैं, इसे नियंत्रित करने के लिए list_display सेट करें।

उदाहरण:

list_display = ('first_name', 'last_name')

यदि आप list_display सेट नहीं करते हैं, तो व्यवस्थापक साइट एक एकल कॉलम प्रदर्शित __str__() जो प्रत्येक ऑब्जेक्ट के __str__() प्रतिनिधित्व करती है।

चार प्रकार के मान हैं जिनका उपयोग list_display में किया जा सकता है:

• एक मॉडल फ़ील्ड का नाम। उदाहरण के लिए:

  class PersonAdmin(admin.ModelAdmin):
      list_display = ('first_name', 'last_name')
  

• एक कॉल करने योग्य जो एक तर्क, मॉडल उदाहरण को स्वीकार करता है। उदाहरण के लिए:

  def upper_case_name(obj):
      return ("%s %s" % (obj.first_name, obj.last_name)).upper()
  upper_case_name.short_description = 'Name'
  
  class PersonAdmin(admin.ModelAdmin):
      list_display = (upper_case_name,)
  

• एक ModelAdmin विधि का प्रतिनिधित्व करने वाली एक स्ट्रिंग जो एक तर्क, मॉडल उदाहरण को स्वीकार करती है। उदाहरण के लिए:

  class PersonAdmin(admin.ModelAdmin):
      list_display = ('upper_case_name',)
  
      def upper_case_name(self, obj):
          return ("%s %s" % (obj.first_name, obj.last_name)).upper()
      upper_case_name.short_description = 'Name'
  

• एक मॉडल विशेषता या विधि का प्रतिनिधित्व करने वाला एक स्ट्रिंग (बिना किसी आवश्यक तर्क के)। उदाहरण के लिए:

  from django.contrib import admin
  from django.db import models
  
  class Person(models.Model):
      name = models.CharField(max_length=50)
      birthday = models.DateField()
  
      def decade_born_in(self):
          return self.birthday.strftime('%Y')[:3] + "0's"
      decade_born_in.short_description = 'Birth decade'
  
  class PersonAdmin(admin.ModelAdmin):
      list_display = ('name', 'decade_born_in')
  

list_display बारे में ध्यान देने योग्य कुछ विशेष मामले:

• यदि फ़ील्ड एक __str__() , तो Django संबंधित ऑब्जेक्ट के __str__() को प्रदर्शित करेगा।
• ManyToManyField फ़ील्ड्स समर्थित नहीं हैं, क्योंकि यह तालिका में प्रत्येक पंक्ति के लिए एक अलग SQL कथन निष्पादित करेगा। यदि आप फिर भी ऐसा करना चाहते हैं, तो अपने मॉडल को एक कस्टम विधि दें, और उस विधि का नाम list_display । ( list_display में कस्टम तरीकों के बारे में अधिक जानने के लिए नीचे देखें।)
• यदि फ़ील्ड एक BooleanField , तो Django True या False बजाय एक "ऑन" या "ऑफ" आइकन प्रदर्शित करेगा।

• यदि दी गई स्ट्रिंग मॉडल की एक विधि है, तो ModelAdmin या ModelAdmin करने योग्य, Django डिफ़ॉल्ट रूप से आउटपुट से HTML-एस्केप करेगा। उपयोगकर्ता इनपुट से बचने और अपने स्वयं के format_html() टैग की अनुमति देने के लिए, format_html() उपयोग करें।

  यहाँ एक पूर्ण उदाहरण मॉडल है:

  from django.contrib import admin
  from django.db import models
  from django.utils.html import format_html
  
  class Person(models.Model):
      first_name = models.CharField(max_length=50)
      last_name = models.CharField(max_length=50)
      color_code = models.CharField(max_length=6)
  
      def colored_name(self):
          return format_html(
              '<span style="color: #{};">{} {}</span>',
              self.color_code,
              self.first_name,
              self.last_name,
          )
  
  class PersonAdmin(admin.ModelAdmin):
      list_display = ('first_name', 'last_name', 'colored_name')
  

• जैसा कि कुछ उदाहरण पहले ही प्रदर्शित कर चुके हैं, जब ModelAdmin करने योग्य, मॉडल विधि, या ModelAdmin विधि का उपयोग करते हैं, तो आप ModelAdmin करने के लिए एक ModelAdmin विशेषता जोड़कर कॉलम के शीर्षक को अनुकूलित कर सकते हैं।

• यदि किसी फ़ील्ड का मान None , तो एक खाली स्ट्रिंग, या तत्वों के बिना चलने वाला, Django प्रदर्शित करेगा - (एक डैश)। आप AdminSite.empty_value_display साथ इसे ओवरराइड कर सकते हैं:

  from django.contrib import admin
  
  admin.site.empty_value_display = '(None)'
  

  आप ModelAdmin.empty_value_display भी उपयोग कर सकते हैं:

  class PersonAdmin(admin.ModelAdmin):
      empty_value_display = 'unknown'
  

  या एक क्षेत्र स्तर पर:

  class PersonAdmin(admin.ModelAdmin):
      list_display = ('name', 'birth_date_view')
  
      def birth_date_view(self, obj):
           return obj.birth_date
  
      birth_date_view.empty_value_display = 'unknown'
  

• यदि दी गई स्ट्रिंग मॉडल की एक विधि है, तो ModelAdmin या एक ModelAdmin करने योग्य जो सही या गलत Django लौटाता है, यदि आप विधि को एक boolean विशेषता देते हैं, जिसका मूल्य True है, तो "पर" या "बंद" आइकन प्रदर्शित करेगा।

  यहाँ एक पूर्ण उदाहरण मॉडल है:

  from django.contrib import admin
  from django.db import models
  
  class Person(models.Model):
      first_name = models.CharField(max_length=50)
      birthday = models.DateField()
  
      def born_in_fifties(self):
          return self.birthday.strftime('%Y')[:3] == '195'
      born_in_fifties.boolean = True
  
  class PersonAdmin(admin.ModelAdmin):
      list_display = ('name', 'born_in_fifties')
  

• __str__() विधि सिर्फ list_display में किसी अन्य मॉडल विधि के रूप में मान्य है, इसलिए यह करना ठीक है:

  list_display = ('__str__', 'some_other_field')
  

• आमतौर पर, list_display तत्व जो वास्तविक डेटाबेस फ़ील्ड नहीं हैं, उनका उपयोग सॉर्टिंग में नहीं किया जा सकता है (क्योंकि Django डेटाबेस स्तर पर सभी सॉर्टिंग करता है)।

  हालाँकि, अगर list_display का एक तत्व एक निश्चित डेटाबेस फ़ील्ड का प्रतिनिधित्व करता है, तो आप आइटम के admin_order_field विशेषता को सेट करके इस तथ्य को इंगित कर सकते हैं।

  उदाहरण के लिए:

  from django.contrib import admin
  from django.db import models
  from django.utils.html import format_html
  
  class Person(models.Model):
      first_name = models.CharField(max_length=50)
      color_code = models.CharField(max_length=6)
  
      def colored_first_name(self):
          return format_html(
              '<span style="color: #{};">{}</span>',
              self.color_code,
              self.first_name,
          )
  
      colored_first_name.admin_order_field = 'first_name'
  
  class PersonAdmin(admin.ModelAdmin):
      list_display = ('first_name', 'colored_first_name')
  

  जब व्यवस्थापक में colored_first_name द्वारा सॉर्ट करने का प्रयास करते हुए उपरोक्त Django को colored_first_name फ़ील्ड द्वारा ऑर्डर करने के लिए colored_first_name ।

  admin_order_field साथ अवरोही क्रम को इंगित करने के लिए आप फ़ील्ड नाम पर एक हाइफ़न उपसर्ग का उपयोग कर सकते हैं। उपरोक्त उदाहरण का उपयोग करते हुए, यह ऐसा दिखेगा:

  colored_first_name.admin_order_field = '-first_name'
  

  admin_order_field संबंधित मॉडलों पर मूल्यों के आधार पर क्वेरी लुकअप का समर्थन करता है। इस उदाहरण में सूची प्रदर्शन में एक "लेखक का पहला नाम" कॉलम शामिल है और इसे पहले नाम से क्रमबद्ध करने की अनुमति देता है:

  class Blog(models.Model):
      title = models.CharField(max_length=255)
      author = models.ForeignKey(Person, on_delete=models.CASCADE)
  
  class BlogAdmin(admin.ModelAdmin):
      list_display = ('title', 'author', 'author_first_name')
  
      def author_first_name(self, obj):
          return obj.author.first_name
  
      author_first_name.admin_order_field = 'author__first_name'
  

  क्वेरी अभिव्यक्तियों का उपयोग admin_order_field में किया जा सकता है। उदाहरण के लिए:

  from django.db.models import Value
  from django.db.models.functions import Concat
  
  class Person(models.Model):
      first_name = models.CharField(max_length=50)
      last_name = models.CharField(max_length=50)
  
      def full_name(self):
          return self.first_name + ' ' + self.last_name
      full_name.admin_order_field = Concat('first_name', Value(' '), 'last_name')
  

  Django 2.1 में नया:

  admin_order_field में अभिव्यक्तियों के लिए समर्थन जोड़ा गया था।

• list_display तत्व भी गुण हो सकते हैं। कृपया ध्यान दें, कि जिस तरह से पायथन में गुण काम करते हैं, उसके कारण property() फ़ंक्शन का उपयोग करते समय प्रॉपर्टी पर short_description सेट करना संभव है और @property डेकोरेटर के साथ नहीं ।

  उदाहरण के लिए:

  class Person(models.Model):
      first_name = models.CharField(max_length=50)
      last_name = models.CharField(max_length=50)
  
      def my_property(self):
          return self.first_name + ' ' + self.last_name
      my_property.short_description = "Full name of the person"
  
      full_name = property(my_property)
  
  class PersonAdmin(admin.ModelAdmin):
      list_display = ('full_name',)
  

• list_display में फ़ील्ड नाम HTML आउटपुट में सीएसएस कक्षाओं के रूप में भी दिखाई देंगे, प्रत्येक <th> तत्व पर column-<field_name> के रूप में। उदाहरण के लिए CSS फ़ाइल में कॉलम की चौड़ाई सेट करने के लिए इसका उपयोग किया जा सकता है।

• Django इस क्रम में list_display हर तत्व की व्याख्या करने की कोशिश करेगा:

  • मॉडल का एक क्षेत्र।
  • एक कॉल करने योग्य।
  • एक ModelAdmin विशेषता का प्रतिनिधित्व करने वाली एक स्ट्रिंग।
  • एक मॉडल विशेषता का प्रतिनिधित्व करने वाला एक स्ट्रिंग।

  उदाहरण के लिए यदि आपके पास एक मॉडल फ़ील्ड के रूप में ModelAdmin मॉडल है और एक ModelAdmin विशेषता के रूप में, मॉडल फ़ील्ड का उपयोग किया जाएगा।

ModelAdmin.list_display_links

list_display_links को नियंत्रित करने के लिए list_display_links का उपयोग करें और एक वस्तु के लिए "परिवर्तन" पृष्ठ पर कौन सा फ़ील्ड जोड़ा जाना चाहिए।

डिफ़ॉल्ट रूप से, परिवर्तन सूची पृष्ठ पहले कॉलम को लिंक करेगा - प्रत्येक आइटम के लिए परिवर्तन पृष्ठ पर list_display में निर्दिष्ट पहला फ़ील्ड। लेकिन list_display_links आपको इसे बदलने देता है:

• कोई लिंक नहीं पाने के लिए इसे None पर सेट करें।

• इसे एक सूची या फ़ील्ड के टपल पर सेट करें ( list_display के समान प्रारूप में) जिसके कॉलम आप लिंक में कनवर्ट करना चाहते हैं।

  आप एक या कई फ़ील्ड निर्दिष्ट कर सकते हैं। जब तक फ़ील्ड list_display में दिखाई list_display , तब तक Django को परवाह नहीं है कि कितने (या कितने) फ़ील्ड लिंक किए गए हैं। केवल आवश्यकता यह है कि यदि आप इस तरीके से list_display_links का उपयोग करना चाहते हैं, तो आपको list_display को परिभाषित करना होगा।

इस उदाहरण में, first_name और last_name फ़ील्ड परिवर्तन सूची पृष्ठ पर लिंक किए जाएंगे:

class PersonAdmin(admin.ModelAdmin):
    list_display = ('first_name', 'last_name', 'birthday')
    list_display_links = ('first_name', 'last_name')

इस उदाहरण में, परिवर्तन सूची पृष्ठ ग्रिड में कोई लिंक नहीं होगा:

class AuditEntryAdmin(admin.ModelAdmin):
    list_display = ('timestamp', 'message')
    list_display_links = None

ModelAdmin.list_editable

मॉडल पर फ़ील्ड नामों की सूची में list_editable सेट करें जो परिवर्तन सूची पृष्ठ पर संपादन की अनुमति देगा। यानी, list_editable में सूचीबद्ध फ़ील्ड को परिवर्तन सूची पृष्ठ पर फ़ॉर्म विजेट के रूप में प्रदर्शित किया जाएगा, जिससे उपयोगकर्ता एक साथ कई पंक्तियों को संपादित और सहेज सकते हैं।

ध्यान दें

list_editable विशेष तरीकों से अन्य विकल्पों में से एक जोड़े के साथ बातचीत करता है; आपको निम्नलिखित नियमों पर ध्यान देना चाहिए:

• list_editable कोई भी क्षेत्र list_editable भी होना चाहिए। आप उस फ़ील्ड को संपादित नहीं कर सकते जो प्रदर्शित नहीं है!
• समान फ़ील्ड को list_editable और list_display_links दोनों में सूचीबद्ध नहीं किया जा सकता है - एक फ़ील्ड फ़ॉर्म और लिंक दोनों नहीं हो सकता है।

यदि इन नियमों को तोड़ा जाता है, तो आपको एक सत्यापन त्रुटि मिलेगी।

ModelAdmin.list_filter

निम्न स्क्रीनशॉट में सचित्र, व्यवस्थापक के परिवर्तन सूची पृष्ठ के दाहिने साइडबार में फिल्टर सक्रिय करने के लिए list_filter सेट करें:

list_filter तत्वों की एक सूची या टपल होना चाहिए, जहां प्रत्येक तत्व निम्न प्रकारों में से एक होना चाहिए:

• एक फ़ील्ड नाम, जहाँ निर्दिष्ट फ़ील्ड या तो एक BooleanField , CharField , DateField , BooleanField , CharField , DateField या IntegerField उदाहरण के लिए होना चाहिए:

  class PersonAdmin(admin.ModelAdmin):
      list_filter = ('is_staff', 'company')
  

  list_filter में फ़ील्ड नाम, उदाहरण के लिए __ लुकअप का उपयोग करके संबंधों को list_filter सकते हैं:

  class PersonAdmin(admin.UserAdmin):
      list_filter = ('company__name',)
  

• django.contrib.admin.SimpleListFilter से विरासत में मिला एक वर्ग, जिसे आपको title और parameter_name विशेषताएँ प्रदान करने की आवश्यकता है, जो lookups और queryset तरीकों को ओवरराइड करता है, जैसे:

  from datetime import date
  
  from django.contrib import admin
  from django.utils.translation import gettext_lazy as _
  
  class DecadeBornListFilter(admin.SimpleListFilter):
      # Human-readable title which will be displayed in the
      # right admin sidebar just above the filter options.
      title = _('decade born')
  
      # Parameter for the filter that will be used in the URL query.
      parameter_name = 'decade'
  
      def lookups(self, request, model_admin):
          """
          Returns a list of tuples. The first element in each
          tuple is the coded value for the option that will
          appear in the URL query. The second element is the
          human-readable name for the option that will appear
          in the right sidebar.
          """
          return (
              ('80s', _('in the eighties')),
              ('90s', _('in the nineties')),
          )
  
      def queryset(self, request, queryset):
          """
          Returns the filtered queryset based on the value
          provided in the query string and retrievable via
          `self.value()`.
          """
          # Compare the requested value (either '80s' or '90s')
          # to decide how to filter the queryset.
          if self.value() == '80s':
              return queryset.filter(birthday__gte=date(1980, 1, 1),
                                      birthday__lte=date(1989, 12, 31))
          if self.value() == '90s':
              return queryset.filter(birthday__gte=date(1990, 1, 1),
                                      birthday__lte=date(1999, 12, 31))
  
  class PersonAdmin(admin.ModelAdmin):
      list_filter = (DecadeBornListFilter,)
  

  ध्यान दें

  एक सुविधा के रूप में, HttpRequest ऑब्जेक्ट को lookups और queryset तरीकों से पारित किया जाता है, उदाहरण के लिए:

  class AuthDecadeBornListFilter(DecadeBornListFilter):
  
      def lookups(self, request, model_admin):
          if request.user.is_superuser:
              return super().lookups(request, model_admin)
  
      def queryset(self, request, queryset):
          if request.user.is_superuser:
              return super().queryset(request, queryset)
  

  एक सुविधा के रूप में, ModelAdmin ऑब्जेक्ट को lookups विधि में पास किया जाता है, उदाहरण के लिए यदि आप उपलब्ध डेटा पर लुकअप को आधार बनाना चाहते हैं:

  class AdvancedDecadeBornListFilter(DecadeBornListFilter):
  
      def lookups(self, request, model_admin):
          """
          Only show the lookups if there actually is
          anyone born in the corresponding decades.
          """
          qs = model_admin.get_queryset(request)
          if qs.filter(birthday__gte=date(1980, 1, 1),
                        birthday__lte=date(1989, 12, 31)).exists():
              yield ('80s', _('in the eighties'))
          if qs.filter(birthday__gte=date(1990, 1, 1),
                        birthday__lte=date(1999, 12, 31)).exists():
              yield ('90s', _('in the nineties'))
  

• एक टपल, जहां पहला तत्व एक फील्ड नाम है और दूसरा तत्व django.contrib.admin.FieldListFilter से विरासत में मिला एक वर्ग है, उदाहरण के लिए:

  class PersonAdmin(admin.ModelAdmin):
      list_filter = (
          ('is_staff', admin.BooleanFieldListFilter),
      )
  

  आप संबंधित संबंध में संबंधित मॉडल के विकल्पों को सीमित कर सकते हैं संबंधित संबंध का उपयोग करते RelatedOnlyFieldListFilter ।

  class BookAdmin(admin.ModelAdmin):
      list_filter = (
          ('author', admin.RelatedOnlyFieldListFilter),
      )
  

  author को एक User मॉडल के लिए एक list_filter मान लें, यह उन उपयोगकर्ताओं के लिए list_filter विकल्पों को सीमित करेगा जिन्होंने सभी उपयोगकर्ताओं को सूचीबद्ध करने के बजाय एक पुस्तक लिखी है।

  ध्यान दें

  FieldListFilter API को आंतरिक माना जाता है और इसे बदला जा सकता है।

सूची फ़िल्टर आमतौर पर केवल तभी दिखाई देते हैं जब फ़िल्टर में एक से अधिक विकल्प हों। फ़िल्टर का has_output() विधि नियंत्रित करता है कि यह दिखाई देता है या नहीं।

सूची फिल्टर प्रदान करने के लिए एक कस्टम टेम्पलेट निर्दिष्ट करना संभव है:

class FilterWithCustomTemplate(admin.SimpleListFilter):
    template = "custom_template.html"

ठोस उदाहरण के लिए Django ( admin/filter.html ) द्वारा प्रदान किया गया डिफ़ॉल्ट टेम्पलेट देखें।

ModelAdmin.list_max_show_all

एक सूची "सभी दिखाएँ" व्यवस्थापक परिवर्तन सूची पृष्ठ पर कितने आइटम दिखाई दे सकते हैं यह नियंत्रित करने के लिए list_max_show_all सेट करें। व्यवस्थापक परिवर्तन सूची पर "सभी दिखाएँ" लिंक केवल तभी प्रदर्शित करेगा जब कुल परिणाम गिनती इस सेटिंग से कम या बराबर हो। डिफ़ॉल्ट रूप से, यह 200 सेट है।

ModelAdmin.list_per_page

प्रत्येक पेज पर दिए गए व्यवस्थापक परिवर्तन सूची पृष्ठ पर कितने आइटम दिखाई देते हैं, यह नियंत्रित करने के लिए list_per_page सेट करें। डिफ़ॉल्ट रूप से, यह 100 सेट है।

ModelAdmin.list_select_related

व्यवस्थापन सूची पृष्ठ पर वस्तुओं की सूची को पुनः प्राप्त करने के लिए select_related() का उपयोग करने के लिए Django को बताने के लिए list_select_related सेट करें। यह आपको डेटाबेस प्रश्नों का एक गुच्छा बचा सकता है।

मूल्य या तो एक बूलियन, एक सूची या एक टुपल होना चाहिए। डिफ़ॉल्ट False ।

जब मान True , तो select_related() हमेशा कहा जाएगा। जब मान False सेट होता है, तो Django list_display को list_display और select_related() कॉल select_related() यदि कोई ForeignKey मौजूद है।

यदि आपको अधिक महीन list_select_related नियंत्रण की आवश्यकता है, तो list_select_related मान के रूप में एक tuple (या सूची) का उपयोग करें। खाली ट्यूपल, Django को select_related को कॉल करने से select_related । मापदंडों के रूप में किसी अन्य tuple को सीधे select_related में पारित किया जाएगा। उदाहरण के लिए:

class ArticleAdmin(admin.ModelAdmin):
    list_select_related = ('author', 'category')

select_related('author', 'category') को कॉल करेगा।

यदि आपको अनुरोध के आधार पर एक गतिशील मूल्य निर्दिष्ट करने की आवश्यकता है, तो आप एक get_list_select_related() विधि को लागू कर सकते हैं।

ModelAdmin.ordering

Django व्यवस्थापक विचारों में ऑब्जेक्ट्स की सूची कैसे ordering की जानी चाहिए, यह निर्दिष्ट करने के लिए ordering सेट करें। यह एक मॉडल के ordering पैरामीटर के समान प्रारूप में एक सूची या टपल होना चाहिए।

यदि यह प्रदान नहीं किया जाता है, तो Django व्यवस्थापक मॉडल के डिफ़ॉल्ट ऑर्डर का उपयोग करेगा।

यदि आपको एक गतिशील आदेश (उदाहरण के लिए उपयोगकर्ता या भाषा के आधार पर) निर्दिष्ट करने की आवश्यकता है, तो आप एक get_ordering() विधि लागू कर सकते हैं ।

ModelAdmin.paginator

पेजिनेटर वर्ग का उपयोग पेजिनेशन के लिए किया जाता है। डिफ़ॉल्ट रूप से, django.core.paginator.Paginator का उपयोग किया जाता है। यदि कस्टम पेजिनेटर वर्ग के पास एक ही निर्माता इंटरफ़ेस नहीं है django.core.paginator.Paginator , तो आपको इसके लिए एक कार्यान्वयन भी प्रदान करना होगा ModelAdmin.get_paginator() ।

ModelAdmin.prepopulated_fields

prepopulated_fields फ़ील्ड से मैप करने के लिए एक शब्दकोश मैपिंग नाम पर सेट करें , इसे निम्न से हटाना चाहिए:

class ArticleAdmin(admin.ModelAdmin):
    prepopulated_fields = {"slug": ("title",)}

जब सेट किया जाता है, तो दिए गए फ़ील्ड असाइन किए गए फ़ील्ड से पॉप्युलेट करने के लिए जावास्क्रिप्ट के एक बिट का उपयोग करेंगे। इस कार्यक्षमता के लिए मुख्य उपयोग SlugField एक या एक से अधिक अन्य क्षेत्रों के लिए स्वचालित रूप से मान उत्पन्न करना है । उत्पन्न मान स्रोत फ़ील्ड के मानों को बदलते हुए, और फिर उस परिणाम को एक वैध स्लग (जैसे रिक्त स्थान के लिए डैश को प्रतिस्थापित करके), ASCII पत्रों को कम करके और विभिन्न अंग्रेजी स्टॉप शब्दों जैसे 'ए', 'ए' को हटाकर उत्पन्न किया जाता है , 'as', और समान)।

फ़ील्ड प्रपत्रों पर पूर्व-निर्धारित हैं, लेकिन परिवर्तन प्रपत्रों पर नहीं। यह आमतौर पर अवांछित होता है कि किसी ऑब्जेक्ट के बनने के बाद स्लग बदल जाते हैं (जिससे ऑब्जेक्ट का URL बदल जाएगा यदि स्लग का उपयोग किया जाता है)।

prepopulated_fields स्वीकार नहीं करता है DateTimeField , ForeignKey , OneToOneField , और ManyToManyField खेतों।

ModelAdmin.preserve_filters

व्यवस्थापक अब किसी ऑब्जेक्ट को बनाने, संपादित करने या हटाने के बाद सूची दृश्य पर फ़िल्टर संरक्षित करता है। आप इस विशेषता को सेट करके फ़िल्टर साफ़ करने के पिछले व्यवहार को पुनर्स्थापित कर सकते हैं False ।

ModelAdmin.radio_fields

डिफ़ॉल्ट रूप से, Django के व्यवस्थापक उन फ़ील्ड्स के लिए एक चयन-बॉक्स इंटरफ़ेस (<select>) का उपयोग करता है ForeignKey जो choices सेट या हैं । यदि कोई फ़ील्ड मौजूद है radio_fields , तो Django इसके बजाय एक रेडियो-बटन इंटरफ़ेस का उपयोग करेगा। मॉडल पर मान लिया गया group है : ForeignKey Person

class PersonAdmin(admin.ModelAdmin):
    radio_fields = {"group": admin.VERTICAL}

आपके पास मॉड्यूल से उपयोग करने HORIZONTAL या चुनने का विकल्प है । VERTICAL django.contrib.admin

radio_fields जब तक यह ForeignKey या choices सेट नहीं किया जाता है , तब तक एक फ़ील्ड शामिल न करें ।

ModelAdmin.autocomplete_fields

Django 2.0 में नया:

autocomplete_fields एक सूची ForeignKey और / या ManyToManyField फ़ील्ड है जिसे आप Select2 स्वतः पूर्ण इनपुट में बदलना चाहते हैं।

डिफ़ॉल्ट रूप से, व्यवस्थापक <select> उन फ़ील्ड के लिए एक चयन-बॉक्स इंटरफ़ेस ( ) का उपयोग करता है । कभी-कभी आप ड्रॉपडाउन में प्रदर्शित करने के लिए सभी संबंधित उदाहरणों के चयन के ओवरहेड को उकसाना नहीं चाहते हैं।

Select2 इनपुट डिफ़ॉल्ट इनपुट के समान दिखता है, लेकिन एक खोज सुविधा के साथ आता है जो विकल्पों को अतुल्यकालिक रूप से लोड करता है। यह तेजी से और अधिक उपयोगकर्ता के अनुकूल है यदि संबंधित मॉडल में कई उदाहरण हैं।

आपको search_fields संबंधित ऑब्जेक्ट पर परिभाषित करना होगा ModelAdmin क्योंकि स्वत: पूर्ण खोज इसका उपयोग करता है।

अनधिकृत डेटा प्रकटीकरण से बचने के लिए, उपयोगकर्ताओं के पास स्वतः पूर्ण का उपयोग करने के लिए संबंधित वस्तु की अनुमति view या change अनुमति होनी चाहिए ।

परिणामों के आदेश और पृष्ठांकन संबंधित ModelAdmin 's get_ordering() और ModelAdmin.get_paginator() विधियों द्वारा नियंत्रित किए जाते हैं ।

निम्नलिखित उदाहरण में, ChoiceAdmin के लिए एक स्वत: पूर्ण फ़ील्ड ForeignKey है Question । परिणाम question_text क्षेत्र द्वारा फ़िल्टर किए जाते हैं और फ़ील्ड द्वारा आदेशित किए जाते date_created हैं:

class QuestionAdmin(admin.ModelAdmin):
    ordering = ['date_created']
    search_fields = ['question_text']

class ChoiceAdmin(admin.ModelAdmin):
    autocomplete_fields = ['question']

बड़े डेटासेट के लिए प्रदर्शन विचार

उपयोग करने का आदेश देने से ModelAdmin.ordering प्रदर्शन की समस्याएं हो सकती हैं क्योंकि बड़ी क्वेरी पर छंटनी धीमी होगी।

इसके अलावा, यदि आपके खोज क्षेत्रों में डेटाबेस द्वारा अनुक्रमित नहीं किए गए फ़ील्ड शामिल हैं, तो आप बहुत बड़ी तालिकाओं पर खराब प्रदर्शन का सामना कर सकते हैं।

उन मामलों के लिए, ModelAdmin.get_search_results() एक पूर्ण-पाठ अनुक्रमित खोज का उपयोग करके अपने स्वयं के कार्यान्वयन को लिखना एक अच्छा विचार है ।

आप Paginator बहुत बड़ी तालिकाओं पर भी बदलाव करना चाह सकते हैं क्योंकि डिफ़ॉल्ट पेजिनेटर हमेशा एक count() क्वेरी करता है । उदाहरण के लिए, आप Paginator.count संपत्ति के डिफ़ॉल्ट कार्यान्वयन को ओवरराइड कर सकते हैं।

ModelAdmin.raw_id_fields

डिफ़ॉल्ट रूप से, Django के व्यवस्थापक उन फ़ील्ड्स के लिए एक चयन-बॉक्स इंटरफ़ेस (<select>) का उपयोग करता है ForeignKey । कभी-कभी आप ड्रॉप-डाउन में प्रदर्शित करने के लिए सभी संबंधित उदाहरणों का चयन करने के लिए ओवरहेड को उकसाना नहीं चाहते हैं।

raw_id_fields उन क्षेत्रों की सूची है जिन्हें आप या Input तो एक विजेट में बदलना चाहते हैं : ForeignKey ManyToManyField

class ArticleAdmin(admin.ModelAdmin):
    raw_id_fields = ("newspaper",)

raw_id_fields Input विजेट एक प्राथमिक कुंजी शामिल करना चाहिए यदि क्षेत्र एक है ForeignKey या अल्पविराम मानों की सूची अलग करता है, तो क्षेत्र एक है ManyToManyField । raw_id_fields विजेट एक आवर्धक कांच बटन क्षेत्र है जो उपयोगकर्ताओं के लिए खोज और एक मूल्य का चयन करने के लिए अनुमति देता है के बगल में पता चलता है:

ModelAdmin.readonly_fields

डिफ़ॉल्ट रूप से व्यवस्थापक सभी क्षेत्रों को संपादन योग्य दिखाता है। इस विकल्प में किसी भी क्षेत्र (जो एक होना चाहिए list या tuple ) ने अपने डेटा को प्रदर्शित करेगा के रूप में है और गैर-संपादन योग्य; उन्हें ModelForm बनाने और संपादित करने के लिए उपयोग से भी बाहर रखा गया है । ध्यान दें कि निर्दिष्ट करते समय fields या fieldsets केवल-पढ़ने के लिए फ़ील्ड को दिखाने के लिए मौजूद होना चाहिए (उन्हें अन्यथा अनदेखा किया जाता है)।

यदि readonly_fields स्पष्ट आदेश को परिभाषित किए बिना उपयोग किया जाता है fields या fieldsets उन्हें सभी संपादन योग्य क्षेत्रों के बाद अंतिम रूप से जोड़ा जाएगा।

एक रीड-ओनली फील्ड न केवल किसी मॉडल के क्षेत्र से डेटा प्रदर्शित कर सकता है, यह मॉडल के तरीके या ModelAdmin स्वयं कक्षा के तरीके के आउटपुट को भी प्रदर्शित कर सकता है। यह list_display व्यवहार करने के तरीके के समान है । यह उदाहरण के लिए संपादित की जा रही वस्तुओं की स्थिति पर प्रतिक्रिया प्रदान करने के लिए व्यवस्थापक इंटरफ़ेस का उपयोग करने का एक आसान तरीका प्रदान करता है:

from django.contrib import admin
from django.utils.html import format_html_join
from django.utils.safestring import mark_safe

class PersonAdmin(admin.ModelAdmin):
    readonly_fields = ('address_report',)

    def address_report(self, instance):
        # assuming get_full_address() returns a list of strings
        # for each line of the address and you want to separate each
        # line by a linebreak
        return format_html_join(
            mark_safe('<br>'),
            '{}',
            ((line,) for line in instance.get_full_address()),
        ) or mark_safe("<span class='errors'>I can't determine this address.</span>")

    # short_description functions like a model field's verbose_name
    address_report.short_description = "Address"

ModelAdmin.save_as

save_as व्यवस्थापक परिवर्तन फ़ॉर्म पर "नई के रूप में सहेजें" सुविधा को सक्षम करने के लिए सेट करें ।

आम तौर पर, ऑब्जेक्ट में तीन सहेजें विकल्प होते हैं: "सहेजें", "सहेजें और संपादन जारी रखें", और "सहेजें और दूसरे को जोड़ें"। यदि save_as है True , तो "सहेजें और दूसरे को जोड़ें" को "ऑब्जेक्ट के रूप में सहेजें" बटन द्वारा प्रतिस्थापित किया जाएगा जो मौजूदा ऑब्जेक्ट को अपडेट करने के बजाय एक नई ऑब्जेक्ट (नई आईडी के साथ) बनाता है।

डिफ़ॉल्ट रूप से, save_as पर सेट है False ।

ModelAdmin.save_as_continue

जब save_as=True , नई ऑब्जेक्ट को सहेजने के बाद डिफ़ॉल्ट पुनर्निर्देशित होता है, तो उस ऑब्जेक्ट के लिए परिवर्तन दृश्य है। यदि आप सेट करते हैं save_as_continue=False , तो रीडायरेक्ट चेंजेलिस्ट दृश्य के लिए होगा।

डिफ़ॉल्ट रूप से, save_as_continue पर सेट है True ।

ModelAdmin.save_on_top

save_on_top अपने व्यवस्थापक परिवर्तन फ़ॉर्म के शीर्ष पर सेव बटन जोड़ने के लिए सेट करें ।

आम तौर पर, सेव बटन केवल फॉर्म के निचले भाग में दिखाई देते हैं। यदि आप सेट करते हैं save_on_top , तो बटन ऊपर और नीचे दोनों तरफ दिखाई देंगे।

डिफ़ॉल्ट रूप से, save_on_top पर सेट है False ।

ModelAdmin.search_fields

search_fields व्यवस्थापक परिवर्तन सूची पृष्ठ पर एक खोज बॉक्स को सक्षम करने के लिए सेट करें । इसे उन फ़ील्ड नामों की सूची पर सेट किया जाना चाहिए, जब कोई भी व्यक्ति उस टेक्स्ट बॉक्स में खोज क्वेरी सबमिट करता है।

इन क्षेत्रों जैसे पाठ क्षेत्र, किसी तरह का होना चाहिए CharField या TextField । आप एक संबंधित लुकअप API ForeignKey या ManyToManyField "फॉलो" नोटेशन के साथ कर सकते हैं:

search_fields = ['foreign_key__related_fieldname']

उदाहरण के लिए, यदि आपके पास एक लेखक के साथ एक ब्लॉग प्रविष्टि है, तो निम्नलिखित परिभाषा लेखक की ईमेल पते द्वारा ब्लॉग प्रविष्टियों को खोजने में सक्षम होगी:

search_fields = ['user__email']

जब कोई व्यक्ति व्यवस्थापक खोज बॉक्स में खोज करता है, तो Django शब्दों में खोज क्वेरी को विभाजित करता है और सभी वस्तुओं को वापस करता है, जिसमें प्रत्येक शब्द, केस-असंवेदनशील ( icontains लुकअप का उपयोग करके ) होता है, जहां प्रत्येक शब्द कम से कम एक में होना चाहिए search_fields । उदाहरण के लिए, यदि search_fields करने के लिए सेट कर दिया जाता ['first_name', 'last_name'] है और किसी उपयोगकर्ता द्वारा john lennon , Django इस एसक्यूएल के बराबर हो जाएगा WHERE खंड:

WHERE (first_name ILIKE '%john%' OR last_name ILIKE '%john%')
AND (first_name ILIKE '%lennon%' OR last_name ILIKE '%lennon%')

यदि आप icontains लुकअप के रूप में उपयोग नहीं करना चाहते हैं , तो आप किसी भी लुकअप को फ़ील्ड में जोड़कर उपयोग कर सकते हैं। उदाहरण के लिए, आप exact सेटिंग search_fields पर जाकर उपयोग कर सकते हैं ['first_name__exact'] ।

खबरदार है कि क्योंकि क्वेरी की शर्तों को विभाजित किया गया है और जैसा कि पहले वर्णित है, exact केवल एक ही खोज शब्द के साथ दो या दो से अधिक शब्दों के साथ काम करना सभी एक सटीक मिलान नहीं हो सकता जब तक कि सभी शब्द समान न हों।

Django 2.1 में नया:

फ़ील्ड लुकअप निर्दिष्ट करने की क्षमता जोड़ी गई थी।

फ़ील्ड लुकअप निर्दिष्ट करने के लिए कुछ (पुराने) शॉर्टकट भी उपलब्ध हैं। आप search_fields निम्न वर्णों के साथ किसी फ़ील्ड को उपसर्ग कर सकते हैं और यह __<lookup> फ़ील्ड में जोड़ने के बराबर है :

उपसर्ग	देखो
^	startswith
=	iexact
@	search
कोई नहीं	icontains

यदि आपको खोज को अनुकूलित करने की आवश्यकता है तो आप ModelAdmin.get_search_results() अतिरिक्त या वैकल्पिक खोज व्यवहार प्रदान करने के लिए उपयोग कर सकते हैं ।

ModelAdmin.show_full_result_count

show_full_result_count यह नियंत्रित करने के लिए सेट करें कि क्या फ़िल्टर किए गए व्यवस्थापक पृष्ठ (जैसे 99 results (103 total) ) पर ऑब्जेक्ट की पूरी गणना प्रदर्शित होनी चाहिए । यदि यह विकल्प सेट है False , तो 99 results (Show all) इसके बजाय एक पाठ प्रदर्शित किया जाता है।

डिफ़ॉल्ट show_full_result_count=True तालिका पर पूर्ण गणना करने के लिए एक क्वेरी उत्पन्न करता है जो कि महंगी हो सकती है यदि तालिका में बड़ी संख्या में पंक्तियाँ हों।

ModelAdmin.sortable_by

Django 2.1 में नया:

डिफ़ॉल्ट रूप से, परिवर्तन सूची पृष्ठ सभी मॉडल फ़ील्ड (और कॉलबेल जिनके पास admin_order_field संपत्ति है) द्वारा निर्दिष्ट करने की अनुमति देता है list_display ।

आप कुछ स्तंभों के लिए छँटाई अक्षम करना चाहते हैं, सेट sortable_by एक संग्रह (जैसे करने के लिए list , tuple या set की उप-समूह की) list_display आप sortable होना चाहता हूँ कि। एक खाली संग्रह सभी कॉलमों के लिए छँटाई करता है।

यदि आपको गतिशील रूप से इस सूची को निर्दिष्ट करने की आवश्यकता है, तो get_sortable_by() इसके बजाय एक विधि लागू करें ।

ModelAdmin.view_on_site

view_on_site "साइट पर देखें" लिंक प्रदर्शित करने के लिए या नहीं, यह नियंत्रित करने के लिए सेट करें । यह लिंक आपको एक URL पर लाना चाहिए जहां आप सहेजे गए ऑब्जेक्ट को प्रदर्शित कर सकते हैं।

यह मान बूलियन ध्वज या कॉल करने योग्य हो सकता है। यदि True (डिफ़ॉल्ट), ऑब्जेक्ट का get_absolute_url() विधि url उत्पन्न करने के लिए उपयोग किया जाएगा।

यदि आपके मॉडल में एक get_absolute_url() विधि है, लेकिन आप "साइट पर देखें" बटन नहीं दिखाना चाहते हैं, तो आपको केवल इसके लिए सेट view_on_site करना होगा False :

from django.contrib import admin

class PersonAdmin(admin.ModelAdmin):
    view_on_site = False

यदि यह कॉल करने योग्य है, तो यह एक पैरामीटर के रूप में मॉडल के उदाहरण को स्वीकार करता है। उदाहरण के लिए:

from django.contrib import admin
from django.urls import reverse

class PersonAdmin(admin.ModelAdmin):
    def view_on_site(self, obj):
        url = reverse('person-detail', kwargs={'slug': obj.slug})
        return 'https://example.com' + url

कस्टम टेम्पलेट विकल्प

अधिभावी व्यवस्थापक टेम्पलेट्स अनुभाग ओवरराइड या डिफ़ॉल्ट व्यवस्थापक टेम्पलेट्स का विस्तार करने का तरीका बताता है। ModelAdmin विचारों द्वारा उपयोग किए गए डिफ़ॉल्ट टेम्प्लेट को ओवरराइड करने के लिए निम्नलिखित विकल्पों का उपयोग करें :

ModelAdmin.add_form_template

एक कस्टम टेम्पलेट का पथ, जिसका उपयोग किया जाता है add_view() ।

ModelAdmin.change_form_template

एक कस्टम टेम्पलेट का पथ, जिसका उपयोग किया जाता है change_view() ।

ModelAdmin.change_list_template

एक कस्टम टेम्पलेट का पथ, जिसका उपयोग किया जाता है changelist_view() ।

ModelAdmin.delete_confirmation_template

delete_view() एक या अधिक ऑब्जेक्ट हटाते समय पुष्टिकरण पृष्ठ प्रदर्शित करने के लिए उपयोग किए जाने वाले कस्टम टेम्पलेट का पथ ।

ModelAdmin.delete_selected_confirmation_template

एक कस्टम टेम्पलेट को पथ, delete_selected जो एक या अधिक वस्तुओं को हटाते समय पुष्टिकरण पृष्ठ प्रदर्शित करने के लिए क्रिया विधि द्वारा उपयोग किया जाता है । कार्रवाई के दस्तावेज देखें ।

ModelAdmin.object_history_template

एक कस्टम टेम्पलेट का पथ, जिसका उपयोग किया जाता है history_view() ।

ModelAdmin.popup_response_template

एक कस्टम टेम्पलेट के लिए पथ, द्वारा इस्तेमाल किया response_add() , response_change() , और response_delete() ।

ModelAdmin तरीकों

ModelAdmin.save_model(request, obj, form, change) [source]

save_model विधि दिया जाता है HttpRequest , एक मॉडल उदाहरण के लिए, एक ModelForm उदाहरण है, और यह जोड़ने या वस्तु से बदल रहा है कि क्या के आधार पर एक बूलियन मान। इस विधि को ओवरराइड करने से पूर्व या बाद के संचालन को करने की अनुमति मिलती है। super().save_model() ऑब्जेक्ट का उपयोग करके सहेजने के लिए कॉल करें Model.save() ।

उदाहरण के लिए request.user बचत से पहले वस्तु को संलग्न करना:

from django.contrib import admin

class ArticleAdmin(admin.ModelAdmin):
    def save_model(self, request, obj, form, change):
        obj.user = request.user
        super().save_model(request, obj, form, change)

ModelAdmin.delete_model(request, obj) [source]

delete_model विधि दी गई है HttpRequest और एक मॉडल उदाहरण। इस विधि को ओवरराइड करने से पूर्व या बाद के ऑपरेशन को करने की अनुमति मिलती है। super().delete_model() ऑब्जेक्ट का उपयोग करके हटाने के लिए कॉल करें Model.delete() ।

ModelAdmin.delete_queryset(request, queryset) [source]

Django 2.1 में नया:

यह delete_queryset() विधि दी गई है HttpRequest और QuerySet वस्तुओं को हटाने के लिए। "चयनित ऑब्जेक्ट हटाएं" कार्रवाई के लिए हटाने की प्रक्रिया को अनुकूलित करने के लिए इस विधि को ओवरराइड करें ।

ModelAdmin.save_formset(request, form, formset, change) [source]

यह save_formset विधि HttpRequest माता-पिता को दी जाती है , अभिभावक का ModelForm उदाहरण और एक बूलियन मूल्य जो कि वह मूल वस्तु को जोड़ या बदल रहा है।

उदाहरण के लिए, request.user प्रत्येक परिवर्तित स्वरूप मॉडल के उदाहरण के लिए संलग्न करने के लिए:

class ArticleAdmin(admin.ModelAdmin):
    def save_formset(self, request, form, formset, change):
        instances = formset.save(commit=False)
        for obj in formset.deleted_objects:
            obj.delete()
        for instance in instances:
            instance.user = request.user
            instance.save()
        formset.save_m2m()

फॉर्मेट में ऑब्जेक्ट्स सेव करना भी देखें ।

ModelAdmin.get_ordering(request)

get_ordering विधि एक लेता request पैरामीटर के रूप में और एक लौटने की उम्मीद है list या tuple करने के लिए इसी तरह के आदेश देने के लिए ModelAdmin.ordering विशेषता। उदाहरण के लिए:

class PersonAdmin(admin.ModelAdmin):

    def get_ordering(self, request):
        if request.user.is_superuser:
            return ['name', 'rank']
        else:
            return ['name']

ModelAdmin.get_search_results(request, queryset, search_term) [source]

get_search_results विधि उन है कि प्रदान की खोज शब्द से मेल में दिखाया गया है वस्तुओं की सूची को संशोधित करता है। यह अनुरोध को स्वीकार करता है, एक क्वेरीसेट जो वर्तमान फ़िल्टर और उपयोगकर्ता द्वारा प्रदान की गई खोज शब्द को लागू करता है। यह खोज को लागू करने के लिए संशोधित क्वेरीज़ युक्त एक टपल लौटाता है, और यह दर्शाता है कि परिणाम डुप्लिकेट हो सकते हैं।

डिफ़ॉल्ट कार्यान्वयन में नामित फ़ील्ड खोजता है search_fields ।

इस पद्धति को आपकी अपनी कस्टम खोज विधि से ओवरराइड किया जा सकता है। उदाहरण के लिए, आप किसी पूर्णांक फ़ील्ड द्वारा खोज करना चाहते हैं, या किसी बाहरी उपकरण जैसे कि Solr या Haystack का उपयोग कर सकते हैं। आपको यह पता लगाना चाहिए कि क्या आपके खोज विधि द्वारा कार्यान्वित क्वेरीज़ परिवर्तन परिणामों में डुप्लिकेट को लागू कर सकते हैं, और True वापसी मूल्य के दूसरे तत्व में वापस आ सकते हैं।

उदाहरण के लिए, द्वारा खोज करने के लिए name और age , आप उपयोग कर सकते हैं:

class PersonAdmin(admin.ModelAdmin):
    list_display = ('name', 'age')
    search_fields = ('name',)

    def get_search_results(self, request, queryset, search_term):
        queryset, use_distinct = super().get_search_results(request, queryset, search_term)
        try:
            search_term_as_int = int(search_term)
        except ValueError:
            pass
        else:
            queryset |= self.model.objects.filter(age=search_term_as_int)
        return queryset, use_distinct

यह कार्यान्वयन search_fields = ('name', '=age') संख्यात्मक क्षेत्र के लिए स्ट्रिंग तुलना में जिसके परिणामस्वरूप ... OR UPPER("polls_choice"."votes"::text) = UPPER('4') PostgreSQL पर उदाहरण के लिए अधिक कुशल है ।

ModelAdmin.save_related(request, form, formsets, change) [source]

save_related विधि दिया जाता है HttpRequest , माता पिता के ModelForm उदाहरण, इनलाइन formsets की सूची और माता पिता जोड़ा जा रहा है कि क्या है या बदल के आधार पर एक बूलियन मान। यहां आप माता-पिता से संबंधित वस्तुओं के लिए कोई भी पूर्व या बाद के संचालन को बचा सकते हैं। ध्यान दें कि इस बिंदु पर मूल वस्तु और उसका रूप पहले ही सहेजा जा चुका है।

ModelAdmin.get_autocomplete_fields(request)

Django 2.0 में नया:

get_autocomplete_fields() विधि दी गई है HttpRequest और एक लौटने की उम्मीद है list या tuple फ़ील्ड नाम के रूप में में ऊपर वर्णित एक स्वत: पूर्ण विजेट के साथ प्रदर्शित किया जाएगा के ModelAdmin.autocomplete_fields अनुभाग।

ModelAdmin.get_readonly_fields(request, obj=None)

get_readonly_fields विधि दी गई है HttpRequest और obj संपादित किया जा रहा है (या None एक ऐड फार्म पर) और एक लौटने की उम्मीद है list या tuple क्षेत्र के नाम के रूप में ऊपर वर्णित है कि, के रूप में केवल पढ़ने के लिए प्रदर्शित किया जाएगा के ModelAdmin.readonly_fields अनुभाग।

ModelAdmin.get_prepopulated_fields(request, obj=None)

get_prepopulated_fields विधि दी गई है HttpRequest और obj संपादित किया जा रहा है (या None एक ऐड फार्म पर) और एक लौटने की उम्मीद है dictionary के रूप में में ऊपर वर्णित है, ModelAdmin.prepopulated_fields खंड।

ModelAdmin.get_list_display(request) [source]

get_list_display विधि दी गई है HttpRequest और एक लौटने की उम्मीद है list या tuple फ़ील्ड नाम है कि परिवर्तन सूची दृश्य में ऊपर वर्णित के रूप में पर प्रदर्शित किया जाएगा के list_display अनुभाग।

ModelAdmin.get_list_display_links(request, list_display) [source]

get_list_display_links विधि दी गई है HttpRequest और list या tuple द्वारा लौटाए गए ModelAdmin.get_list_display() । यह या तो लौटने की उम्मीद है None या एक list या tuple परिवर्तन सूची में वर्णित के रूप में, परिवर्तन देखने से लिंक किया जाएगा पर फ़ील्ड नाम के ModelAdmin.list_display_links अनुभाग।

ModelAdmin.get_exclude(request, obj=None)

get_exclude विधि दी गई है HttpRequest और obj संपादित किया जा रहा है (या None एक ऐड फार्म पर) और में वर्णित है, क्षेत्रों की एक सूची लौटने की उम्मीद है ModelAdmin.exclude ।

ModelAdmin.get_fields(request, obj=None)

get_fields विधि दी गई है HttpRequest और obj संपादित किया जा रहा है (या None के रूप में में ऊपर वर्णित एक ऐड फार्म पर) और खेतों की एक सूची लौटने की उम्मीद है, fields खंड।

ModelAdmin.get_fieldsets(request, obj=None)

get_fieldsets विधि दी गई है HttpRequest और obj संपादित किया जा रहा है (या None एक ऐड फार्म पर) और दो tuples है, जिसमें प्रत्येक दो टपल एक का प्रतिनिधित्व करता है की एक सूची लौटने की उम्मीद है <fieldset> के रूप में में ऊपर वर्णित है, व्यवस्थापक प्रपत्र पृष्ठ पर fieldsets अनुभाग।

ModelAdmin.get_list_filter(request) [source]

get_list_filter विधि दी गई है HttpRequest और के लिए के रूप में अनुक्रम प्रकार के एक ही तरह लौटने की उम्मीद है list_filter विशेषता।

ModelAdmin.get_list_select_related(request) [source]

get_list_select_related विधि दी गई है HttpRequest और एक बूलियन या सूची लौटना चाहिए के रूप में ModelAdmin.list_select_related करता है।

ModelAdmin.get_search_fields(request) [source]

get_search_fields विधि दी गई है HttpRequest और के लिए के रूप में अनुक्रम प्रकार के एक ही तरह लौटने की उम्मीद है search_fields विशेषता।

ModelAdmin.get_sortable_by(request)

Django 2.1 में नया:

get_sortable_by() विधि पारित हो जाता है HttpRequest और एक संग्रह लौटने की उम्मीद है (उदाहरण के लिए list , tuple या set ) फ़ील्ड नाम है कि परिवर्तन सूची पृष्ठ में sortable होगा।

sortable_by यदि यह सेट है, तो इसका डिफ़ॉल्ट कार्यान्वयन लौटाता है , अन्यथा यह चूक जाता है ModelAdmin.get_list_display() ।

उदाहरण के लिए, एक या अधिक स्तंभों को छांटने से रोकने के लिए:

class PersonAdmin(admin.ModelAdmin):

    def get_sortable_by(self, request):
        return {*self.get_list_display(request)} - {'rank'}

ModelAdmin.get_inline_instances(request, obj=None) [source]

get_inline_instances विधि दी गई है HttpRequest और obj संपादित किया जा रहा है (या None एक ऐड फार्म पर) और एक लौटने की उम्मीद है list या tuple के InlineModelAdmin रूप में में नीचे वर्णित वस्तुओं, InlineModelAdmin खंड। उदाहरण के लिए, निम्नलिखित ऐड, डिफॉल्ट फ़िल्टरिंग, अनुमतियों और अनुमतियों के आधार पर डिफ़ॉल्ट फ़िल्टरिंग के बिना इनरलाइन लौटाएगा:

class MyModelAdmin(admin.ModelAdmin):
    inlines = (MyInline,)

    def get_inline_instances(self, request, obj=None):
        return [inline(self.model, self.admin_site) for inline in self.inlines]

यदि आप इस पद्धति को ओवरराइड करते हैं, तो सुनिश्चित करें कि लौटी हुई इनलाइनों को परिभाषित वर्गों के उदाहरण हैं inlines या आप संबंधित वस्तुओं को जोड़ते समय "खराब अनुरोध" त्रुटि का सामना कर सकते हैं।

ModelAdmin.get_urls() [source]

get_urls एक पर विधि ModelAdmin रिटर्न यूआरएल एक URLconf के रूप में एक ही तरीके से कि ModelAdmin के लिए प्रयोग की जाने वाली। इसलिए आप उन्हें URL प्रेषण में प्रलेखित के रूप में विस्तारित कर सकते हैं :

from django.contrib import admin
from django.template.response import TemplateResponse
from django.urls import path

class MyModelAdmin(admin.ModelAdmin):
    def get_urls(self):
        urls = super().get_urls()
        my_urls = [
            path('my_view/', self.my_view),
        ]
        return my_urls + urls

    def my_view(self, request):
        # ...
        context = dict(
           # Include common variables for rendering the admin template.
           self.admin_site.each_context(request),
           # Anything else you want in the context...
           key=value,
        )
        return TemplateResponse(request, "sometemplate.html", context)

यदि आप व्यवस्थापक लेआउट का उपयोग करना चाहते हैं, तो admin/base_site.html निम्न से विस्तार करें :

{% extends "admin/base_site.html" %}
{% block content %}
...
{% endblock %}

ध्यान दें

ध्यान दें कि कस्टम पैटर्न नियमित व्यवस्थापक URL से पहले शामिल किए गए हैं: व्यवस्थापक URL पैटर्न बहुत अनुमत हैं और लगभग किसी भी चीज़ से मेल खाएंगे, इसलिए आप आमतौर पर अपने कस्टम URL को अंतर्निहित लोगों को प्रस्तुत करना चाहते हैं।

इस उदाहरण में, my_view एक्सेस किया जाएगा /admin/myapp/mymodel/my_view/ (यह मानते हुए कि व्यवस्थापक URL शामिल हैं /admin/ )

हालाँकि, self.my_view ऊपर पंजीकृत फ़ंक्शन दो समस्याओं से ग्रस्त है:

• यह किसी भी अनुमति की जांच नहीं करेगा , इसलिए यह आम जनता के लिए सुलभ होगा।
• यह कैशिंग को रोकने के लिए कोई हेडर विवरण प्रदान नहीं करेगा। इसका मतलब है कि यदि पृष्ठ डेटाबेस से डेटा पुनर्प्राप्त करता है, और मिडलवेयर कैशिंग सक्रिय है, तो पृष्ठ पुरानी जानकारी दिखा सकता है।

चूंकि यह आमतौर पर आप क्या चाहते हैं, Django अनुमतियों की जांच करने के लिए एक सुविधा आवरण प्रदान करता है और गैर-देखने योग्य के रूप में दृश्य चिह्नित करता है। यह आवरण AdminSite.admin_view() ( उदाहरण के self.admin_site.admin_view अंदर ModelAdmin ) है; इसका इस्तेमाल ऐसे करें:

class MyModelAdmin(admin.ModelAdmin):
    def get_urls(self):
        urls = super().get_urls()
        my_urls = [
            path('my_view/', self.admin_site.admin_view(self.my_view))
        ]
        return my_urls + urls

ऊपर पांचवीं पंक्ति में लिपटे हुए दृश्य पर ध्यान दें:

path('my_view/', self.admin_site.admin_view(self.my_view))

यह रैपिंग self.my_view अनधिकृत पहुँच से सुरक्षा प्रदान करेगी और django.views.decorators.cache.never_cache() यह सुनिश्चित करने के लिए डेकोरेटर को लगाएगी कि कैश कैशवेयर सक्रिय है या नहीं।

यदि पृष्ठ उपलब्ध नहीं है, लेकिन आप अभी भी अनुमति की जांच करना चाहते हैं, तो आप एक cacheable=True तर्क दे सकते हैं AdminSite.admin_view() :

path('my_view/', self.admin_site.admin_view(self.my_view, cacheable=True))

ModelAdmin विचारों में model_admin विशेषताएँ हैं। अन्य AdminSite विचारों में admin_site विशेषताएँ हैं।

ModelAdmin.get_form(request, obj=None, **kwargs) [source]

ModelForm व्यवस्थापक ऐड में उपयोग के लिए एक क्लास लौटाता है और विचारों को बदलता है, देखें add_view() और change_view() ।

आधार कार्यान्वयन modelform_factory() उपवर्ग का उपयोग करता है form , जैसे कि विशेषताओं द्वारा संशोधित fields और ModelAdmin.exclude । इसलिए, उदाहरण के लिए, यदि आप सुपरयूजर्स को अतिरिक्त क्षेत्र प्रदान करना चाहते हैं, तो आप एक अलग आधार फॉर्म में स्वैप कर सकते हैं:

class MyModelAdmin(admin.ModelAdmin):
    def get_form(self, request, obj=None, **kwargs):
        if request.user.is_superuser:
            kwargs['form'] = MySuperuserForm
        return super().get_form(request, obj, **kwargs)

आप ModelForm सीधे कस्टम क्लास भी लौटा सकते हैं।

ModelAdmin.get_formsets_with_inlines(request, obj=None) [source]

पैदावार ( ) FormSet , InlineModelAdmin जोड़े के लिए व्यवस्थापक जोड़ें और विचारों को बदलने में उपयोग करते हैं।

उदाहरण के लिए यदि आप किसी विशेष इनलाइन को केवल परिवर्तन दृश्य में प्रदर्शित करना चाहते हैं, तो आप get_formsets_with_inlines निम्नानुसार ओवरराइड कर सकते हैं :

class MyModelAdmin(admin.ModelAdmin):
    inlines = [MyInline, SomeOtherInline]

    def get_formsets_with_inlines(self, request, obj=None):
        for inline in self.get_inline_instances(request, obj):
            # hide MyInline in the add view
            if not isinstance(inline, MyInline) or obj is not None:
                yield inline.get_formset(request, obj), inline

ModelAdmin.formfield_for_foreignkey(db_field, request, **kwargs)

एक formfield_for_foreignkey विधि पर ModelAdmin आप एक विदेशी कुंजी क्षेत्र के लिए डिफ़ॉल्ट फॉर्मफील्ड को ओवरराइड करने की अनुमति देता है। उदाहरण के लिए, उपयोगकर्ता के आधार पर इस विदेशी कुंजी क्षेत्र के लिए वस्तुओं का सबसेट वापस करने के लिए:

class MyModelAdmin(admin.ModelAdmin):
    def formfield_for_foreignkey(self, db_field, request, **kwargs):
        if db_field.name == "car":
            kwargs["queryset"] = Car.objects.filter(owner=request.user)
        return super().formfield_for_foreignkey(db_field, request, **kwargs)

यह HttpRequest उदाहरण के लिए Car स्वामित्व वाली कारों को प्रदर्शित करने के लिए विदेशी कुंजी फ़ील्ड को फ़िल्टर करने के लिए इंस्टेंस का उपयोग करता है User ।

ModelAdmin.formfield_for_manytomany(db_field, request, **kwargs)

formfield_for_foreignkey विधि की तरह , formfield_for_manytomany कई से कई फ़ील्ड के लिए डिफ़ॉल्ट फ़ॉर्मफ़ील्ड को बदलने के लिए विधि को ओवरराइड किया जा सकता है। उदाहरण के लिए, यदि एक मालिक कई कारों और कारों के मालिक हो सकते हैं, तो वे कई मालिकों के हो सकते हैं - कई कई रिश्ते - आप Car केवल अपने स्वामित्व वाली कारों को प्रदर्शित करने के लिए विदेशी कुंजी क्षेत्र को फ़िल्टर कर सकते हैं User :

class MyModelAdmin(admin.ModelAdmin):
    def formfield_for_manytomany(self, db_field, request, **kwargs):
        if db_field.name == "cars":
            kwargs["queryset"] = Car.objects.filter(owner=request.user)
        return super().formfield_for_manytomany(db_field, request, **kwargs)

ModelAdmin.formfield_for_choice_field(db_field, request, **kwargs)

जैसा formfield_for_foreignkey और formfield_for_manytomany विधियों, formfield_for_choice_field विधि एक क्षेत्र घोषित विकल्प है कि के लिए डिफ़ॉल्ट formfield बदलने के लिए अधिरोहित जा सकता है। उदाहरण के लिए, यदि एक सुपरयुसर के लिए उपलब्ध विकल्प नियमित कर्मचारियों के लिए उपलब्ध से अलग होना चाहिए, तो आप निम्नानुसार आगे बढ़ सकते हैं:

class MyModelAdmin(admin.ModelAdmin):
    def formfield_for_choice_field(self, db_field, request, **kwargs):
        if db_field.name == "status":
            kwargs['choices'] = (
                ('accepted', 'Accepted'),
                ('denied', 'Denied'),
            )
            if request.user.is_superuser:
                kwargs['choices'] += (('ready', 'Ready for deployment'),)
        return super().formfield_for_choice_field(db_field, request, **kwargs)

ध्यान दें

choices फॉर्मफील्ड पर सेट की गई कोई भी विशेषता केवल फॉर्म फील्ड तक सीमित होगी। यदि मॉडल पर संबंधित फ़ील्ड में विकल्प सेट हैं, तो फॉर्म को प्रदान किए गए विकल्प उन विकल्पों का एक मान्य सबसेट होना चाहिए, अन्यथा ValidationError मॉडल सबमिट करने से पहले फॉर्म सबमिट होने पर फॉर्म सबमिट करना विफल हो जाएगा ।

ModelAdmin.get_changelist(request, **kwargs) [source]

Changelist प्रविष्टि के लिए उपयोग किए जाने वाले वर्ग को लौटाता है । डिफ़ॉल्ट रूप से, django.contrib.admin.views.main.ChangeList का उपयोग किया जाता है। इस वर्ग को विरासत में देकर आप लिस्टिंग के व्यवहार को बदल सकते हैं।

ModelAdmin.get_changelist_form(request, **kwargs) [source]

चैंजिस्ट पृष्ठ पर ModelForm उपयोग के लिए एक वर्ग देता है Formset । उदाहरण के लिए, एक कस्टम फ़ॉर्म का उपयोग करने के लिए:

from django import forms

class MyForm(forms.ModelForm):
    pass

class MyModelAdmin(admin.ModelAdmin):
    def get_changelist_form(self, request, **kwargs):
        return MyForm

ध्यान दें

यदि आप Meta.model एक पर विशेषता को परिभाषित करते हैं ModelForm , तो आपको Meta.fields विशेषता (या Meta.exclude विशेषता) को भी परिभाषित करना होगा । हालाँकि, ModelAdmin इस मान को अनदेखा करता है, इसे ModelAdmin.list_editable विशेषता के साथ ओवरराइड करता है । सबसे आसान समाधान Meta.model विशेषता को छोड़ना है , क्योंकि ModelAdmin उपयोग करने के लिए सही मॉडल प्रदान करेगा।

ModelAdmin.get_changelist_formset(request, **kwargs) [source]

यदि उपयोग किया जाता है, तो चैंजिस्ट पेज पर एक ModelFormSet क्लास का उपयोग करता ModelAdmin.list_editable है। उदाहरण के लिए, कस्टम फॉर्मेट का उपयोग करने के लिए:

from django.forms import BaseModelFormSet

class MyAdminFormSet(BaseModelFormSet):
    pass

class MyModelAdmin(admin.ModelAdmin):
    def get_changelist_formset(self, request, **kwargs):
        kwargs['formset'] = MyAdminFormSet
        return super().get_changelist_formset(request, **kwargs)

ModelAdmin.lookup_allowed(lookup, value)

चेंजेलिस्ट पेज की वस्तुओं को URL के क्वेरी स्ट्रिंग से लुकअप के साथ फ़िल्टर किया जा सकता है। list_filter उदाहरण के लिए, यह कैसे काम करता है। लुकअप उसी तरह के होते हैं QuerySet.filter() जैसे कि (जैसे [email protected] ) में उपयोग किया जाता है । चूंकि क्वेरी स्ट्रिंग में लुकअप को उपयोगकर्ता द्वारा हेरफेर किया जा सकता है, इसलिए उन्हें अनधिकृत डेटा एक्सपोज़र को रोकने के लिए sanitized किया जाना चाहिए।

lookup_allowed() विधि क्वेरी स्ट्रिंग (जैसे से एक देखने पथ दिया जाता है 'user__email' ) और इसी मूल्य (जैसे '[email protected]' ), और एक बूलियन यह बताते हैं कि छानने परिवर्तन सूची के रिटर्न QuerySet पैरामीटर्स का उपयोग की अनुमति है। यदि lookup_allowed() रिटर्न False , DisallowedModelAdminLookup (उपवर्ग SuspiciousOperation ) उठाया जाता है।

डिफ़ॉल्ट रूप से, lookup_allowed() किसी मॉडल के स्थानीय फ़ील्ड, list_filter (लेकिन इसमें से पथ नहीं get_list_filter() ) में उपयोग किए गए फ़ील्ड पथ , और limit_choices_to सही ढंग से कार्य करने के लिए आवश्यक लुकअप तक पहुंच की अनुमति देता है raw_id_fields ।

अपने ModelAdmin उपवर्ग के लिए अनुमत लुकअप को अनुकूलित करने के लिए इस विधि को ओवरराइड करें ।

ModelAdmin.has_view_permission(request, obj=None)

Django 2.1 में नया:

True अगर देखने obj की अनुमति है तो वापस लौट जाना चाहिए False । यदि obj है None , तो वापस लौटना चाहिए True या False यह इंगित करना चाहिए कि क्या इस प्रकार की वस्तुओं को देखने की अनुमति सामान्य रूप से है (उदाहरण के लिए, False इसका अर्थ यह माना जाएगा कि वर्तमान उपयोगकर्ता को इस प्रकार की कोई भी वस्तु देखने की अनुमति नहीं है)।

True यदि उपयोगकर्ता के पास "परिवर्तन" या "दृश्य" अनुमति है, तो डिफ़ॉल्ट कार्यान्वयन वापस आ जाता है।

ModelAdmin.has_add_permission(request)

True यदि कोई ऑब्जेक्ट जोड़ने की अनुमति है, तो वापस लौटना चाहिए False ।

ModelAdmin.has_change_permission(request, obj=None)

True यदि संपादन obj की अनुमति है, तो वापस लौट जाना चाहिए False । यदि obj है None , तो वापस लौटना चाहिए True या False यह इंगित करना चाहिए कि क्या इस प्रकार की वस्तुओं का संपादन सामान्य रूप से करने की अनुमति है (उदाहरण के लिए, False इसका अर्थ यह होगा कि वर्तमान उपयोगकर्ता को इस प्रकार की किसी भी वस्तु को संपादित करने की अनुमति नहीं है)।

ModelAdmin.has_delete_permission(request, obj=None)

True यदि हटाने obj की अनुमति है, तो वापस लौटना चाहिए False । यदि obj है None , तो वापस लौटना चाहिए True या False यह इंगित करना चाहिए कि क्या इस प्रकार की वस्तुओं को हटाने की अनुमति सामान्य रूप से है (उदाहरण के लिए, False इसका अर्थ यह माना जाएगा कि वर्तमान उपयोगकर्ता को इस प्रकार की किसी भी वस्तु को हटाने की अनुमति नहीं है)।

ModelAdmin.has_module_permission(request)

True व्यवस्थापक सूचकांक पृष्ठ पर मॉड्यूल प्रदर्शित करने और मॉड्यूल के सूचकांक पृष्ठ तक पहुंचने की अनुमति दी जाए, False अन्यथा वापस आ जाना चाहिए । User.has_module_perms() डिफ़ॉल्ट रूप से उपयोग करता है। अधिभावी यह देखने के लिए उपयोग को प्रतिबंधित नहीं है जोड़ने के लिए, बदलने, या विचारों को हटाते हैं, has_view_permission() , has_add_permission() , has_change_permission() , और has_delete_permission() उस के लिए इस्तेमाल किया जाना चाहिए।

ModelAdmin.get_queryset(request)

get_queryset एक पर विधि ModelAdmin एक रिटर्न QuerySet सभी मॉडल उदाहरणों कि व्यवस्थापक साइट के द्वारा संपादित किया जा सकता की। इस पद्धति को ओवरराइड करने का एक उपयोग मामला लॉग-इन उपयोगकर्ता के स्वामित्व वाली वस्तुओं को दिखाना है:

class MyModelAdmin(admin.ModelAdmin):
    def get_queryset(self, request):
        qs = super().get_queryset(request)
        if request.user.is_superuser:
            return qs
        return qs.filter(author=request.user)

ModelAdmin.message_user(request, message, level=messages.INFO, extra_tags='', fail_silently=False) [source]

django.contrib.messages बैकएंड का उपयोग करके उपयोगकर्ता को एक संदेश भेजता है । कस्टम ModelAdmin उदाहरण देखें ।

कीवर्ड तर्क आपको संदेश स्तर बदलने, अतिरिक्त सीएसएस टैग जोड़ने या contrib.messages फ्रेमवर्क स्थापित न होने पर चुपचाप विफल होने की अनुमति देते हैं । ये कीवर्ड तर्क उन लोगों से मेल खाते हैं django.contrib.messages.add_message() , जो अधिक विवरण के लिए उस फ़ंक्शन के दस्तावेज़ देखते हैं। एक अंतर यह है कि स्तर पूर्णांक / स्थिर के अलावा एक स्ट्रिंग लेबल के रूप में पारित किया जा सकता है।

ModelAdmin.get_paginator(request, queryset, per_page, orphans=0, allow_empty_first_page=True) [source]

इस दृश्य का उपयोग करने के लिए पेजिनेटर का एक उदाहरण देता है। डिफ़ॉल्ट रूप से, इंस्टेंट को इंस्टेंट करता है paginator ।

ModelAdmin.response_add(request, obj, post_url_continue=None) [source]

मंच के HttpResponse लिए निर्धारित करता है add_view() ।

response_add के बाद कहा जाता है कि व्यवस्थापक फॉर्म जमा होने के बाद और ऑब्जेक्ट के बाद और सभी संबंधित इंस्टेंस बनाए और सहेजे गए हैं। ऑब्जेक्ट बनने के बाद डिफ़ॉल्ट व्यवहार को बदलने के लिए आप इसे ओवरराइड कर सकते हैं।

ModelAdmin.response_change(request, obj) [source]

मंच के HttpResponse लिए निर्धारित करता है change_view() ।

response_change व्यवस्थापक प्रपत्र सबमिट करने के बाद और ऑब्जेक्ट के बाद और सभी संबंधित उदाहरण सहेजे जाने के बाद कॉल किया जाता है। ऑब्जेक्ट परिवर्तित होने के बाद डिफ़ॉल्ट व्यवहार को बदलने के लिए आप इसे ओवरराइड कर सकते हैं।

ModelAdmin.response_delete(request, obj_display, obj_id) [source]

मंच के HttpResponse लिए निर्धारित करता है delete_view() ।

response_delete ऑब्जेक्ट डिलीट होने के बाद कॉल किया जाता है। ऑब्जेक्ट हटाए जाने के बाद डिफ़ॉल्ट व्यवहार को बदलने के लिए आप इसे ओवरराइड कर सकते हैं।

obj_display हटाए गए ऑब्जेक्ट के नाम के साथ एक स्ट्रिंग है।

obj_id हटाए जाने वाले ऑब्जेक्ट को पुनः प्राप्त करने के लिए उपयोग किया जाने वाला क्रमबद्ध पहचानकर्ता है।

ModelAdmin.get_changeform_initial_data(request) [source]

व्यवस्थापक परिवर्तन के प्रारंभिक डेटा के लिए एक हुक रूपों। डिफ़ॉल्ट रूप से, फ़ील्ड को GET मापदंडों से प्रारंभिक मान दिया जाता है । उदाहरण के लिए, क्षेत्र के प्रारंभिक मान को ?name=initial_value निर्धारित करेगा । name initial_value

इस विधि को प्रपत्र में एक शब्दकोश लौटना चाहिए {'fieldname': 'fieldval'} :

def get_changeform_initial_data(self, request):
    return {'name': 'custom_initial_value'}

ModelAdmin.get_deleted_objects(objs, request) [source]

Django 2.1 में नया:

delete_view() "हटाने और चयनित" कार्रवाई को हटाने की प्रक्रिया को अनुकूलित करने के लिए एक हुक ।

objs तर्क वस्तुओं की एक सजातीय iterable (एक है QuerySet या मॉडल की कई घटनाओं के) हटाए जाने के लिए, और request है HttpRequest ।

इस विधि को 4-ट्यूपल को वापस करना होगा (deleted_objects, model_count, perms_needed, protected) ।

deleted_objects उन सभी वस्तुओं का प्रतिनिधित्व करने वाले तार की एक सूची है जिन्हें हटा दिया जाएगा। यदि कोई संबंधित ऑब्जेक्ट हटाए जाने हैं, तो सूची को नेस्टेड किया गया है और उन संबंधित वस्तुओं को शामिल किया गया है। सूची को unordered_list फिल्टर का उपयोग करके टेम्पलेट में स्वरूपित किया गया है ।

model_count एक शब्दकोश है जो verbose_name_plural नष्ट हो जाएगा वस्तुओं की संख्या के लिए प्रत्येक मॉडल की मैपिंग है।

perms_needed verbose_name उन मॉडलों के सेट का एक सेट है जिन्हें उपयोगकर्ता को हटाने की अनुमति नहीं है।

protected सभी संरक्षित संबंधित वस्तुओं का प्रतिनिधित्व करने वाले तार की एक सूची है जिसे हटाया नहीं जा सकता है। सूची टेम्पलेट में प्रदर्शित की गई है।

अन्य विधियाँ

ModelAdmin.add_view(request, form_url='', extra_context=None) [source]

मॉडल उदाहरण जोड़ पृष्ठ के लिए Django दृश्य। नीचे दिए गए नोट देखें।

ModelAdmin.change_view(request, object_id, form_url='', extra_context=None) [source]

मॉडल उदाहरण संपादन पृष्ठ के लिए Django दृश्य। नीचे दिए गए नोट देखें।

ModelAdmin.changelist_view(request, extra_context=None) [source]

मॉडल उदाहरणों के लिए Django दृश्य सूची / कार्य पृष्ठ बदलते हैं। नीचे दिए गए नोट देखें।

ModelAdmin.delete_view(request, object_id, extra_context=None) [source]

मॉडल उदाहरण (ओं) को हटाने की पुष्टि पृष्ठ के लिए Django दृश्य। नीचे दिए गए नोट देखें।

ModelAdmin.history_view(request, object_id, extra_context=None) [source]

पेज के लिए Django दृश्य जो किसी दिए गए मॉडल उदाहरण के लिए संशोधन इतिहास दिखाता है।

ModelAdmin पिछले अनुभाग में विस्तृत हुक-प्रकार के तरीकों के विपरीत , ये पांच तरीके वास्तविकता में डिज़ाइन किए गए हैं जो कि Django के विचारों के रूप में डिज़ाइन किए गए व्यवस्थापक एप्लिकेशन URL से हैंडलर को उन पृष्ठों को प्रस्तुत करने के लिए भेजते हैं जो मॉडल इंस्टेंसेस CRUD ऑपरेशन से निपटते हैं। नतीजतन, इन तरीकों को पूरी तरह से ओवरराइड करने से व्यवस्थापक एप्लिकेशन के व्यवहार में काफी बदलाव आएगा।

इन तरीकों को ओवरराइड करने का एक सामान्य कारण उस संदर्भ डेटा को बढ़ाना है जो उस टेम्पलेट को प्रदान किया जाता है जो दृश्य प्रदान करता है। निम्नलिखित उदाहरण में, परिवर्तन दृश्य ओवरराइड किया गया है ताकि प्रदान किए गए टेम्पलेट को कुछ अतिरिक्त मैपिंग डेटा प्रदान किया जाए जो अन्यथा उपलब्ध नहीं होगा:

class MyModelAdmin(admin.ModelAdmin):

    # A template for a very customized change view:
    change_form_template = 'admin/myapp/extras/openstreetmap_change_form.html'

    def get_osm_info(self):
        # ...
        pass

    def change_view(self, request, object_id, form_url='', extra_context=None):
        extra_context = extra_context or {}
        extra_context['osm_data'] = self.get_osm_info()
        return super().change_view(
            request, object_id, form_url, extra_context=extra_context,
        )

ये दृश्य TemplateResponse ऐसे उदाहरण हैं जो आपको रेंडर करने से पहले आसानी से प्रतिक्रिया डेटा को अनुकूलित करने की अनुमति देते हैं। अधिक जानकारी के लिए, टेम्प्लेट रिप्लेसमेंट प्रलेखन देखें ।

ModelAdmin संपत्ति की परिभाषा

कई बार आप सीएसएस / और जावास्क्रिप्ट को जोड़ने / बदलने के विचारों में से कुछ जोड़ना चाहेंगे। यह Media अपने पर एक आंतरिक वर्ग का उपयोग करके पूरा किया जा सकता है ModelAdmin :

class ArticleAdmin(admin.ModelAdmin):
    class Media:
        css = {
            "all": ("my_styles.css",)
        }
        js = ("my_code.js",)

StaticFiles एप्लिकेशन पहले जोड़ता है STATIC_URL (या MEDIA_URL अगर STATIC_URL है None ) किसी भी संपत्ति रास्तों को। रूपों पर नियमित संपत्ति परिभाषाओं के समान नियम लागू होते हैं ।

jQuery

Django व्यवस्थापक जावास्क्रिप्ट jQuery पुस्तकालय का उपयोग करता है ।

उपयोगकर्ता द्वारा प्रदत्त स्क्रिप्ट या पुस्तकालयों के साथ संघर्ष से बचने के लिए, Django के jQuery (संस्करण 3.3.1) को नाम दिया गया है django.jQuery । यदि आप दूसरी कॉपी को शामिल किए बिना अपने स्वयं के व्यवस्थापक जावास्क्रिप्ट में jQuery का उपयोग करना चाहते हैं, तो आप django.jQuery चैंजिस्ट पर ऑब्जेक्ट का उपयोग कर सकते हैं और दृश्य जोड़ / संपादित कर सकते हैं।

ModelAdmin वर्ग डिफ़ॉल्ट रूप से jQuery की आवश्यकता है, तो अपने को jQuery जोड़ने के लिए कोई जरूरत नहीं है ModelAdmin मीडिया संसाधनों की की सूची जब तक आप एक विशिष्ट की जरूरत है। उदाहरण के लिए, यदि आपको वैश्विक नामस्थान में jQuery लाइब्रेरी की आवश्यकता है (उदाहरण के लिए, थर्ड-पार्टी jQuery प्लगइन्स का उपयोग करते समय) या यदि आपको jQuery के नए संस्करण की आवश्यकता है, तो आपको अपनी प्रति शामिल करनी होगी।

Django, क्रमशः jquery.js और jquery.min.js क्रमशः , jQuery के दोनों असम्पीडित और 'छोटा' संस्करण प्रदान करता है।

ModelAdmin और InlineModelAdmin एक media संपत्ति है Media जो वस्तुओं की एक सूची देता है जो प्रपत्र और / या फ़ॉर्मेट के लिए जावास्क्रिप्ट फ़ाइलों को पथ संग्रहीत करता है। अगर DEBUG है True यह विभिन्न JavaScript फ़ाइलों को शामिल करने की असम्पीडित संस्करणों वापस आ जाएगी jquery.js ; यदि नहीं, तो यह 'कीमाधारित' संस्करण लौटाएगा।

व्यवस्थापक के लिए कस्टम सत्यापन जोड़ना

व्यवस्थापक में डेटा का कस्टम सत्यापन जोड़ना काफी आसान है। स्वत: व्यवस्थापक इंटरफ़ेस पुन: उपयोग करता है django.forms , और ModelAdmin वर्ग आपको अपनी स्वयं की प्रपत्र को परिभाषित करने की क्षमता देता है:

class ArticleAdmin(admin.ModelAdmin):
    form = MyArticleAdminForm

MyArticleAdminForm जब तक आप आयात कर सकते हैं, तब तक कहीं भी परिभाषित किया जा सकता है। अब अपने फॉर्म के भीतर आप किसी भी क्षेत्र के लिए अपना स्वयं का कस्टम सत्यापन जोड़ सकते हैं:

class MyArticleAdminForm(forms.ModelForm):
    def clean_name(self):
        # do something that validates your data
        return self.cleaned_data["name"]

यह महत्वपूर्ण है कि आप ModelForm यहां का उपयोग करें अन्यथा चीजें टूट सकती हैं। कस्टम सत्यापन पर forms दस्तावेज़ देखें , और अधिक विशेष रूप से, मॉडल अधिक जानकारी के लिए सत्यापन नोट बनाता है ।

InlineModelAdmin वस्तुओं

class InlineModelAdmin

class TabularInline [source]

class StackedInline [source]

व्यवस्थापक इंटरफ़ेस में माता-पिता मॉडल के रूप में एक ही पृष्ठ पर मॉडल को संपादित करने की क्षमता है। इन्हें इनलाइन कहा जाता है। मान लीजिए कि आपके पास ये दो मॉडल हैं:

from django.db import models

class Author(models.Model):
   name = models.CharField(max_length=100)

class Book(models.Model):
   author = models.ForeignKey(Author, on_delete=models.CASCADE)
   title = models.CharField(max_length=100)

आप लेखक द्वारा लिखित पुस्तकों को लेखक पृष्ठ पर संपादित कर सकते हैं। आप किसी मॉडल में उन्हें निर्दिष्ट करके इनलाइन जोड़ते हैं ModelAdmin.inlines :

from django.contrib import admin

class BookInline(admin.TabularInline):
    model = Book

class AuthorAdmin(admin.ModelAdmin):
    inlines = [
        BookInline,
    ]

Django दो उपवर्ग प्रदान करता है InlineModelAdmin और वे हैं:

• TabularInline
• StackedInline

इन दोनों के बीच अंतर केवल उन्हें रेंडर करने के लिए उपयोग किए जाने वाले टेम्पलेट का है।

InlineModelAdmin विकल्प

InlineModelAdmin समान विशेषताओं में से कई को साझा करता है ModelAdmin , और अपने स्वयं के कुछ जोड़ता है (साझा सुविधाओं को वास्तव में BaseModelAdmin सुपरक्लास में परिभाषित किया गया है )। साझा विशेषताएं हैं:

• form
• fieldsets
• fields
• formfield_overrides
• ModelAdmin.exclude
• filter_horizontal
• filter_vertical
• ModelAdmin.ordering
• ModelAdmin.prepopulated_fields
• get_queryset()
• radio_fields
• ModelAdmin.readonly_fields
• raw_id_fields
• formfield_for_choice_field()
• formfield_for_foreignkey()
• formfield_for_manytomany()
• has_module_permission()

InlineModelAdmin वर्ग कहते हैं या अनुकूलित:

InlineModelAdmin.model

जो मॉडल इनलाइन का उपयोग कर रहा है। यह आवश्यक है।

InlineModelAdmin.fk_name

मॉडल पर विदेशी कुंजी का नाम। ज्यादातर मामलों में यह स्वचालित रूप से निपटा जाएगा, लेकिन fk_name स्पष्ट रूप से निर्दिष्ट किया जाना चाहिए यदि एक ही मूल मॉडल के लिए एक से अधिक विदेशी कुंजी हैं।

InlineModelAdmin.formset

यह करने के लिए चूक BaseInlineFormSet । अपने स्वयं के फॉर्मेट का उपयोग करने से आपको अनुकूलन की कई संभावनाएं मिल सकती हैं। इनलाइनों को ModelFormSet आसपास बनाया गया है ।

InlineModelAdmin.form

के लिए form चूक के लिए मूल्य ModelForm । inlineformset_factory() इस इनलाइन के लिए फॉर्मेट बनाते समय इसे पास किया जाता है ।

InlineModelAdmin.classes

इनस्क्रिप्ट के लिए प्रदान की गई फ़ील्डसेट पर लागू करने के लिए अतिरिक्त CSS कक्षाओं वाली एक सूची या टपल। के लिए चूक None । जैसा कि कॉन्फ़िगर की गई कक्षाओं के साथ fieldsets , एक collapse कक्षा के साथ इनलाइन शुरू में ढह जाएगा और उनके हेडर में एक छोटा "शो" लिंक होगा।

InlineModelAdmin.extra

यह अतिरिक्त रूपों की संख्या को नियंत्रित करता है जो प्रारंभिक रूपों के अलावा फॉर्मेट प्रदर्शित करेगा। देखें formsets प्रलेखन अधिक जानकारी के लिए।

जावास्क्रिप्ट-सक्षम ब्राउज़र वाले उपयोगकर्ताओं के लिए, extra तर्क के परिणामस्वरूप प्रदान की गई अतिरिक्त इनलाइनों को जोड़ने के लिए "अन्य जोड़ें" लिंक प्रदान की जाती है ।

यदि वर्तमान में प्रदर्शित प्रपत्रों की संख्या पार हो गई है max_num , या यदि उपयोगकर्ता के पास जावास्क्रिप्ट सक्षम नहीं है, तो डायनेमिक लिंक दिखाई नहीं देगा ।

InlineModelAdmin.get_extra() आपको अतिरिक्त रूपों की संख्या को अनुकूलित करने की अनुमति देता है।

InlineModelAdmin.max_num

यह इनलाइन दिखाने के लिए अधिकतम रूपों को नियंत्रित करता है। यह सीधे वस्तुओं की संख्या से संबंधित नहीं है, लेकिन अगर मूल्य काफी छोटा है अधिक जानकारी के लिए संपादन योग्य वस्तुओं की संख्या सीमित करना देखें ।

InlineModelAdmin.get_max_num() आपको अतिरिक्त रूप से अधिकतम संख्या को अनुकूलित करने की अनुमति देता है।

InlineModelAdmin.min_num

यह इनलाइन दिखाने के लिए न्यूनतम रूपों को नियंत्रित करता है। modelformset_factory() अधिक जानकारी के लिए देखें ।

InlineModelAdmin.get_min_num() आपको प्रदर्शित प्रपत्रों की न्यूनतम संख्या को अनुकूलित करने की अनुमति देता है।

InlineModelAdmin.raw_id_fields

डिफ़ॉल्ट रूप से, Django के व्यवस्थापक उन फ़ील्ड्स के लिए एक चयन-बॉक्स इंटरफ़ेस (<select>) का उपयोग करता है ForeignKey । कभी-कभी आप ड्रॉप-डाउन में प्रदर्शित करने के लिए सभी संबंधित उदाहरणों का चयन करने के लिए ओवरहेड को उकसाना नहीं चाहते हैं।

raw_id_fields उन क्षेत्रों की सूची है जिन्हें आप या Input तो एक विजेट में बदलना चाहते हैं : ForeignKey ManyToManyField

class BookInline(admin.TabularInline):
    model = Book
    raw_id_fields = ("pages",)

InlineModelAdmin.template

टेम्पलेट पृष्ठ पर इनलाइन को प्रस्तुत करने के लिए उपयोग किया जाता है।

InlineModelAdmin.verbose_name

verbose_name मॉडल के आंतरिक Meta वर्ग में पाया जाने वाला ओवरराइड ।

InlineModelAdmin.verbose_name_plural

verbose_name_plural मॉडल के आंतरिक Meta वर्ग में पाया जाने वाला ओवरराइड ।

InlineModelAdmin.can_delete

निर्दिष्ट करता है कि इनलाइन में ऑब्जेक्ट्स को इनलाइन डिलीट किया जा सकता है या नहीं। True अवहेलना।

InlineModelAdmin.show_change_link

निर्दिष्ट करता है कि इनलाइन ऑब्जेक्ट्स को व्यवस्थापक में बदला जा सकता है या नहीं, उनके पास परिवर्तन फ़ॉर्म का लिंक है। False करने के लिए चूक।

InlineModelAdmin.get_formset(request, obj=None, **kwargs)

BaseInlineFormSet व्‍यवस्‍थापक जोड़ने / विचार बदलने के लिए उपयोग के लिए एक वर्ग देता है । के लिए उदाहरण देखें ModelAdmin.get_formsets_with_inlines() ।

InlineModelAdmin.get_extra(request, obj=None, **kwargs)

उपयोग करने के लिए अतिरिक्त इनलाइन रूपों की संख्या लौटाता है। डिफ़ॉल्ट रूप से, InlineModelAdmin.extra विशेषता लौटाता है ।

प्रोग्राम को अतिरिक्त इनलाइन रूपों की संख्या निर्धारित करने के लिए इस विधि को ओवरराइड करें। उदाहरण के लिए, यह मॉडल उदाहरण (कीवर्ड तर्क के रूप में पारित obj ) पर आधारित हो सकता है :

class BinaryTreeAdmin(admin.TabularInline):
    model = BinaryTree

    def get_extra(self, request, obj=None, **kwargs):
        extra = 2
        if obj:
            return extra - obj.binarytree_set.count()
        return extra

InlineModelAdmin.get_max_num(request, obj=None, **kwargs)

उपयोग करने के लिए अतिरिक्त इनलाइन फ़ॉर्म की अधिकतम संख्या लौटाता है। डिफ़ॉल्ट रूप से, InlineModelAdmin.max_num विशेषता लौटाता है ।

इस विधि को प्रोग्रामेटिक रूप से अधिकतम इनलाइन फ़ॉर्म निर्धारित करने के लिए ओवरराइड करें। उदाहरण के लिए, यह मॉडल उदाहरण (कीवर्ड तर्क के रूप में पारित obj ) पर आधारित हो सकता है :

class BinaryTreeAdmin(admin.TabularInline):
    model = BinaryTree

    def get_max_num(self, request, obj=None, **kwargs):
        max_num = 10
        if obj and obj.parent:
            return max_num - 5
        return max_num

InlineModelAdmin.get_min_num(request, obj=None, **kwargs)

उपयोग करने के लिए इनलाइन फ़ॉर्म की न्यूनतम संख्या लौटाता है। डिफ़ॉल्ट रूप से, InlineModelAdmin.min_num विशेषता लौटाता है ।

इस विधि को प्रोग्रामेटिक रूप से न्यूनतम इनलाइन रूपों की संख्या निर्धारित करने के लिए ओवरराइड करें। उदाहरण के लिए, यह मॉडल उदाहरण (कीवर्ड तर्क के रूप में पारित obj ) पर आधारित हो सकता है ।

InlineModelAdmin.has_add_permission(request, obj)

True यदि कोई इनलाइन ऑब्जेक्ट जोड़ने की अनुमति है, तो वापस लौटना चाहिए False । obj क्या अभिभावक वस्तु को संपादित किया जा रहा है या None नए माता-पिता को जोड़ते समय।

Django 2.1 में परिवर्तित:

obj तर्क जोड़ दिया गया।

InlineModelAdmin.has_change_permission(request, obj=None)

यदि True इनलाइन ऑब्जेक्ट को संपादित करने की अनुमति है तो वापस लौटना चाहिए , False अन्यथा। obj माता-पिता द्वारा संपादित की जा रही वस्तु है।

InlineModelAdmin.has_delete_permission(request, obj=None)

True यदि कोई इनलाइन ऑब्जेक्ट हटाने की अनुमति है, तो वापस लौटना चाहिए False । obj माता-पिता द्वारा संपादित की जा रही वस्तु है।

एक ही मूल मॉडल के लिए दो या अधिक विदेशी कुंजियों वाले मॉडल के साथ काम करना

कभी-कभी एक ही मॉडल के लिए एक से अधिक विदेशी कुंजी रखना संभव है। उदाहरण के लिए इस मॉडल को लें:

from django.db import models

class Friendship(models.Model):
    to_person = models.ForeignKey(Person, on_delete=models.CASCADE, related_name="friends")
    from_person = models.ForeignKey(Person, on_delete=models.CASCADE, related_name="from_friends")

यदि आप Person व्यवस्थापक ऐड / चेंज पेज पर इनलाइन दिखाना चाहते हैं तो आपको विदेशी कुंजी को स्पष्ट रूप से परिभाषित करने की आवश्यकता है क्योंकि यह स्वचालित रूप से करने में असमर्थ है:

from django.contrib import admin
from myapp.models import Friendship

class FriendshipInline(admin.TabularInline):
    model = Friendship
    fk_name = "to_person"

class PersonAdmin(admin.ModelAdmin):
    inlines = [
        FriendshipInline,
    ]

कई-कई मॉडलों के साथ काम करना

डिफ़ॉल्ट रूप से, कई-से-कई संबंधों के लिए व्यवस्थापक विगेट्स जो भी मॉडल पर दिखाई देगा, उसका वास्तविक संदर्भ होता है ManyToManyField । आपकी ModelAdmin परिभाषा के आधार पर , आपके मॉडल में कई-से-कई फ़ील्ड एक मानक HTML <select multiple> , एक क्षैतिज या ऊर्ध्वाधर फ़िल्टर या एक raw_id_admin विजेट द्वारा दर्शाए जाएंगे । हालाँकि, इन विजेट्स को इनलाइन के साथ बदलना भी संभव है।

मान लें कि हमारे पास निम्नलिखित मॉडल हैं:

from django.db import models

class Person(models.Model):
    name = models.CharField(max_length=128)

class Group(models.Model):
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(Person, related_name='groups')

यदि आप इनलाइन का उपयोग करके कई-से-कई संबंध प्रदर्शित करना चाहते हैं, तो आप InlineModelAdmin रिश्ते के लिए एक वस्तु को परिभाषित करके ऐसा कर सकते हैं :

from django.contrib import admin

class MembershipInline(admin.TabularInline):
    model = Group.members.through

class PersonAdmin(admin.ModelAdmin):
    inlines = [
        MembershipInline,
    ]

class GroupAdmin(admin.ModelAdmin):
    inlines = [
        MembershipInline,
    ]
    exclude = ('members',)

इस उदाहरण में ध्यान देने योग्य दो विशेषताएं हैं।

सबसे पहले - MembershipInline वर्ग संदर्भ Group.members.through । through विशेषता मॉडल है कि कई-से-अनेक संबंध का प्रबंधन करता है के लिए एक संदर्भ है। यह मॉडल स्वचालित रूप से Django द्वारा बनाया गया है जब आप कई-से-कई फ़ील्ड परिभाषित करते हैं।

दूसरे, क्षेत्र GroupAdmin को मैन्युअल रूप से बाहर करना चाहिए members । Django मॉडल पर कई-से-कई फ़ील्ड के लिए एक व्यवस्थापक विजेट प्रदर्शित करता है जो संबंध (इस मामले में Group ) को परिभाषित करता है । यदि आप कई-से-कई संबंधों का प्रतिनिधित्व करने के लिए इनलाइन मॉडल का उपयोग करना चाहते हैं, तो आपको Django के व्यवस्थापक को इस विजेट को प्रदर्शित नहीं करने के लिए कहना होगा - अन्यथा आप संबंध को प्रबंधित करने के लिए अपने व्यवस्थापक पृष्ठ पर दो विजेट के साथ समाप्त हो जाएंगे।

ध्यान दें कि इस तकनीक का उपयोग करते समय m2m_changed सिग्नल ट्रिगर नहीं होते हैं। ऐसा इसलिए है क्योंकि जहां तक ​​एडमिन की बात है, through तो कई-कई रिलेशन के बजाय सिर्फ दो फॉरेन की फील्ड वाले मॉडल हैं।

अन्य सभी मामलों में, InlineModelAdmin किसी भी अन्य के समान ही है। आप किसी भी सामान्य ModelAdmin गुण का उपयोग करके उपस्थिति को अनुकूलित कर सकते हैं।

कई-कई-कई मध्यस्थ मॉडल के साथ काम करना

जब आप through तर्क का उपयोग करके एक मध्यस्थ मॉडल निर्दिष्ट करते हैं ManyToManyField , तो व्यवस्थापक डिफ़ॉल्ट रूप से एक विजेट प्रदर्शित नहीं करेगा। ऐसा इसलिए है क्योंकि उस मध्यस्थ मॉडल के प्रत्येक उदाहरण के लिए एक ही विजेट में प्रदर्शित होने की तुलना में अधिक जानकारी की आवश्यकता होती है, और कई विजेट के लिए आवश्यक लेआउट मध्यवर्ती मॉडल के आधार पर भिन्न होंगे।

हालाँकि, हम अभी भी उस सूचना को इनलाइन संपादित करने में सक्षम होना चाहते हैं। सौभाग्य से, यह इनलाइन एडमिन मॉडल के साथ करना आसान है। मान लें कि हमारे पास निम्नलिखित मॉडल हैं:

from django.db import models

class Person(models.Model):
    name = models.CharField(max_length=128)

class Group(models.Model):
    name = models.CharField(max_length=128)
    members = models.ManyToManyField(Person, through='Membership')

class Membership(models.Model):
    person = models.ForeignKey(Person, on_delete=models.CASCADE)
    group = models.ForeignKey(Group, on_delete=models.CASCADE)
    date_joined = models.DateField()
    invite_reason = models.CharField(max_length=64)

व्यवस्थापक में इस मध्यवर्ती मॉडल को प्रदर्शित करने का पहला कदम मॉडल के लिए एक इनलाइन वर्ग को परिभाषित करना है Membership :

class MembershipInline(admin.TabularInline):
    model = Membership
    extra = 1

यह सरल उदाहरण मॉडल के InlineModelAdmin लिए डिफ़ॉल्ट मानों का उपयोग करता है Membership , और अतिरिक्त ऐड फॉर्म को एक तक सीमित करता है। यह InlineModelAdmin कक्षाओं के लिए उपलब्ध किसी भी विकल्प का उपयोग करके अनुकूलित किया जा सकता है ।

अब मॉडल Person और Group मॉडल के लिए व्यवस्थापक दृश्य बनाएं :

class PersonAdmin(admin.ModelAdmin):
    inlines = (MembershipInline,)

class GroupAdmin(admin.ModelAdmin):
    inlines = (MembershipInline,)

अंत में, अपने रजिस्टर Person और Group व्यवस्थापक साइट के साथ मॉडल:

admin.site.register(Person, PersonAdmin)
admin.site.register(Group, GroupAdmin)

अब आपकी व्यवस्थापक साइट Membership ऑब्जेक्ट इनलाइन Person या Group डिटेल पृष्ठों से संपादित करने के लिए सेट की गई है ।

इनलाइन के रूप में सामान्य संबंधों का उपयोग करना

सामान्य रूप से संबंधित वस्तुओं के साथ इनलाइन का उपयोग करना संभव है। मान लें कि आपके पास निम्नलिखित मॉडल हैं:

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

class Image(models.Model):
    image = models.ImageField(upload_to="images")
    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
    object_id = models.PositiveIntegerField()
    content_object = GenericForeignKey("content_type", "object_id")

class Product(models.Model):
    name = models.CharField(max_length=100)

आप संपादन अनुमति देने के लिए और एक बनाने चाहते हैं Image पर उदाहरण Product , जोड़ें / विचारों आप उपयोग कर सकते हैं बदलने GenericTabularInline या GenericStackedInline (दोनों उपवर्गों GenericInlineModelAdmin द्वारा प्रदान की) admin । वे इनलाइन ऑब्जेक्ट्स का प्रतिनिधित्व करने वाले रूपों के लिए सारणीबद्ध और स्टैक्ड विज़ुअल लेआउट को अपने गैर-सामान्य समकक्षों की तरह ही लागू करते हैं। वे किसी अन्य इनलाइन की तरह ही व्यवहार करते हैं। admin.py इस उदाहरण ऐप के लिए अपने में :

from django.contrib import admin
from django.contrib.contenttypes.admin import GenericTabularInline

from myproject.myapp.models import Image, Product

class ImageInline(GenericTabularInline):
    model = Image

class ProductAdmin(admin.ModelAdmin):
    inlines = [
        ImageInline,
    ]

admin.site.register(Product, ProductAdmin)

देखें CONTENTTYPES प्रलेखन अधिक विशिष्ट जानकारी के लिए।

ओवरराइडिंग व्यवस्थापक टेम्पलेट

कई टेम्पलेट्स को ओवरराइड करना अपेक्षाकृत आसान है जो व्यवस्थापक मॉड्यूल का उपयोग किसी व्यवस्थापक साइट के विभिन्न पृष्ठों को बनाने के लिए करता है। तुम भी एक विशिष्ट अनुप्रयोग, या एक विशिष्ट मॉडल के लिए इनमें से कुछ टेम्पलेट्स ओवरराइड कर सकते हैं।

अपने प्रोजेक्ट्स व्यवस्थापक टेम्पलेट निर्देशिकाएं सेट करें

व्यवस्थापक टेम्पलेट फ़ाइलें contrib/admin/templates/admin निर्देशिका में स्थित हैं ।

उनमें से एक या अधिक को ओवरराइड करने के लिए, पहले admin अपने प्रोजेक्ट की templates डायरेक्टरी में एक डायरेक्टरी बनाएं । यह सेटिंग में बैकएंड के DIRS विकल्प में आपके द्वारा निर्दिष्ट किसी भी निर्देशिका का हो सकता है । यदि आपने विकल्प को अनुकूलित किया है, तो सुनिश्चित करें कि आपके कस्टम टेम्प्लेट टेम्पलेट लोडिंग सिस्टम द्वारा उन लोगों के साथ शामिल होने से पहले दिखाई देंगे । DjangoTemplates TEMPLATES 'loaders' 'django.template.loaders.filesystem.Loader' 'django.template.loaders.app_directories.Loader' django.contrib.admin

इस admin निर्देशिका के भीतर , अपने ऐप के नाम पर उप-निर्देशिका बनाएं। इन एप्लिकेशन के भीतर उपनिर्देशिका आपके मॉडलों के नाम पर उप-निर्देशिकाएं बनाती हैं। ध्यान दें, कि डायरेक्टरी ऐप डायरेक्टरी की तलाश करते समय मॉडल के नाम को कम कर देगा, इसलिए सुनिश्चित करें कि आप सभी लोअरकेस में डायरेक्टरी का नाम दें यदि आप केस-सेंसिटिव फाइल सिस्टम पर अपना ऐप चलाने जा रहे हैं।

किसी विशिष्ट एप्लिकेशन के लिए व्यवस्थापक टेम्पलेट को ओवरराइड करने के लिए, django/contrib/admin/templates/admin निर्देशिका से टेम्पलेट को कॉपी और संपादित करें , और इसे आपके द्वारा बनाई गई निर्देशिकाओं में से एक में सहेजें।

उदाहरण के लिए, यदि हम किसी ऐप में सभी मॉडलों के लिए परिवर्तन सूची दृश्य में एक उपकरण जोड़ना चाहते हैं, तो हम अपनी परियोजना की निर्देशिका में my_app कॉपी करेंगे , और कोई भी आवश्यक बदलाव करेंगे। contrib/admin/templates/admin/change_list.html templates/admin/my_app/

यदि हम 'पेज' नाम के केवल एक विशिष्ट मॉडल के लिए परिवर्तन सूची दृश्य में एक उपकरण जोड़ना चाहते थे, तो हम उसी फ़ाइल को templates/admin/my_app/page अपनी परियोजना की निर्देशिका में कॉपी कर लेंगे ।

ओवरराइडिंग बनाम एक व्यवस्थापक टेम्पलेट की जगह

व्यवस्थापक टेम्प्लेट के मॉड्यूलर डिजाइन के कारण, यह आम तौर पर पूरे टेम्पलेट को बदलने के लिए न तो आवश्यक है और न ही उचित है। केवल उस टेम्पलेट के अनुभाग को ओवरराइड करना लगभग हमेशा बेहतर होता है जिसे आपको बदलने की आवश्यकता होती है।

ऊपर दिए गए उदाहरण को जारी रखने के लिए, हम मॉडल के History लिए उपकरण के बगल में एक नया लिंक जोड़ना चाहते हैं Page । देखने के बाद change_form.html हम यह निर्धारित करते हैं कि हमें केवल object-tools-items ब्लॉक को ओवरराइड करने की आवश्यकता है । इसलिए यहाँ हमारा नया है change_form.html :

{% extends "admin/change_form.html" %}
{% load i18n admin_urls %}
{% block object-tools-items %}
    <li>
        <a href="{% url opts|admin_urlname:'history' original.pk|admin_urlquote %}" class="historylink">{% trans "History" %}</a>
    </li>
    <li>
        <a href="mylink/" class="historylink">My Link</a>
    </li>
    {% if has_absolute_url %}
        <li>
            <a href="{% url 'admin:view_on_site' content_type_id original.pk %}" class="viewsitelink">{% trans "View on site" %}</a>
        </li>
    {% endif %}
{% endblock %}

और बस! यदि हमने इस फ़ाइल को templates/admin/my_app निर्देशिका में रखा है , तो हमारा लिंक my_app के भीतर सभी मॉडलों के परिवर्तन फ़ॉर्म में दिखाई देगा।

टेम्प्लेट जिन्हें प्रति ऐप या मॉडल से ओवरराइड किया जा सकता है

प्रत्येक टेम्पलेट को contrib/admin/templates/admin प्रति ऐप या प्रति मॉडल ओवरराइड नहीं किया जा सकता है। निम्नलिखित कर सकते हैं:

• actions.html
• app_index.html
• change_form.html
• change_form_object_tools.html
• change_list.html
• change_list_object_tools.html
• change_list_results.html
• date_hierarchy.html
• delete_confirmation.html
• object_history.html
• pagination.html
• popup_response.html
• prepopulated_fields_js.html
• search_form.html
• submit_line.html

उन टेम्प्लेट के लिए जिन्हें इस तरह से ओवरराइड नहीं किया जा सकता है, आप अभी भी उन्हें अपने पूरे प्रोजेक्ट के लिए ओवरराइड कर सकते हैं। बस अपनी templates/admin निर्देशिका में नया संस्करण रखें । यह विशेष रूप से कस्टम 404 और 500 पेज बनाने के लिए उपयोगी है।

रूट और लॉगिन टेम्प्लेट

यदि आप इंडेक्स, लॉगिन या लॉगआउट टेम्प्लेट को बदलना चाहते हैं, तो आप अपना स्वयं का AdminSite उदाहरण (नीचे देखें), और बदलने AdminSite.index_template , AdminSite.login_template या AdminSite.logout_template गुणों को बनाने से बेहतर हैं।

AdminSite वस्तुओं

class AdminSite(name='admin') [source]

एक Django प्रशासनिक साइट का एक उदाहरण द्वारा प्रतिनिधित्व किया है django.contrib.admin.sites.AdminSite ; डिफ़ॉल्ट रूप से, इस वर्ग का एक उदाहरण बनाया जाता है django.contrib.admin.site और आप ModelAdmin इसके साथ अपने मॉडल और उदाहरणों को पंजीकृत कर सकते हैं ।

यदि आप डिफ़ॉल्ट व्यवस्थापक साइट को अनुकूलित करना चाहते हैं, तो आप इसे ओवरराइड कर सकते हैं ।

एक इंस्टेंस का निर्माण AdminSite करते समय, आप name कंस्ट्रक्टर के तर्क का उपयोग करके एक अद्वितीय इंस्टेंस नाम प्रदान कर सकते हैं । यह उदाहरण नाम उदाहरण की पहचान करने के लिए उपयोग किया जाता है, खासकर जब व्यवस्थापक URL को उलट कर । यदि कोई उदाहरण नाम प्रदान नहीं किया गया है, तो डिफ़ॉल्ट डिफ़ॉल्ट नाम का admin उपयोग किया जाएगा। कक्षा को अनुकूलित करने के उदाहरण के लिए AdminSite वर्ग को अनुकूलित करना देखें AdminSite ।

AdminSite गुण

ओवरराइडिंग एडमिन टेम्प्लेट में वर्णित टेम्प्लेट्स आधार व्यवस्थापक टेम्प्लेट को ओवरराइड या विस्तारित कर सकते हैं ।

AdminSite.site_header

प्रत्येक व्यवस्थापक पृष्ठ के शीर्ष पर रखने के लिए पाठ, एक <h1> (एक स्ट्रिंग) के रूप में। डिफ़ॉल्ट रूप से, यह "Django प्रशासन" है।

AdminSite.site_title

प्रत्येक व्यवस्थापक पृष्ठ के अंत में डालने का पाठ <title> (एक स्ट्रिंग)। डिफ़ॉल्ट रूप से, यह "Django साइट व्यवस्थापक" है।

AdminSite.site_url

प्रत्येक व्यवस्थापक पृष्ठ के शीर्ष पर "साइट देखें" लिंक का URL। डिफ़ॉल्ट रूप से, site_url है / । None लिंक हटाने के लिए इसे सेट करें ।

एक उपपथ पर चलने वाली साइटों के लिए, each_context() विधि यह जांचती है कि क्या वर्तमान अनुरोध request.META['SCRIPT_NAME'] सेट किया गया है और उस मूल्य का उपयोग करता है यदि site_url इसके अलावा कुछ और के लिए सेट नहीं किया गया है / ।

AdminSite.index_title

एडमिन इंडेक्स पेज (एक स्ट्रिंग) के शीर्ष पर रखने के लिए पाठ। डिफ़ॉल्ट रूप से, यह "साइट प्रशासन" है।

AdminSite.index_template

एक कस्टम टेम्पलेट का पथ, जिसका उपयोग व्यवस्थापक साइट मुख्य सूचकांक दृश्य द्वारा किया जाएगा।

AdminSite.app_index_template

एक कस्टम टेम्पलेट का पथ, जिसका उपयोग व्यवस्थापक साइट ऐप इंडेक्स दृश्य द्वारा किया जाएगा।

AdminSite.empty_value_display

व्यवस्थापक साइट की परिवर्तन सूची में रिक्त मान प्रदर्शित करने के लिए उपयोग करने के लिए स्ट्रिंग। एक पानी का छींटा करने के लिए चूक। मान को प्रति ModelAdmin आधार पर और कस्टम फ़ील्ड पर फ़ील्ड पर विशेषता ModelAdmin सेट करके भी ओवरराइड किया जा सकता है empty_value_display । ModelAdmin.empty_value_display उदाहरण के लिए देखें ।

AdminSite.login_template

एक कस्टम टेम्पलेट का पथ जो व्यवस्थापक साइट लॉगिन दृश्य द्वारा उपयोग किया जाएगा।

AdminSite.login_form

AuthenticationForm उस के उपवर्ग का उपयोग व्यवस्थापक साइट लॉगिन दृश्य द्वारा किया जाएगा।

AdminSite.logout_template

एक कस्टम टेम्पलेट का पथ जो व्यवस्थापक साइट लॉगआउट दृश्य द्वारा उपयोग किया जाएगा।

AdminSite.password_change_template

एक कस्टम टेम्पलेट का पथ जो व्यवस्थापक साइट पासवर्ड परिवर्तन दृश्य द्वारा उपयोग किया जाएगा।

AdminSite.password_change_done_template

एक कस्टम टेम्पलेट का पथ जिसका उपयोग व्यवस्थापक साइट पासवर्ड परिवर्तन देखने के लिए किया जाएगा।

AdminSite तरीकों

AdminSite.each_context(request) [source]

व्यवस्थापक साइट में प्रत्येक पृष्ठ के लिए टेम्पलेट संदर्भ में रखने के लिए चर का एक शब्दकोश देता है।

डिफ़ॉल्ट रूप से निम्नलिखित चर और मान शामिल हैं:

• site_header : AdminSite.site_header
• site_title : AdminSite.site_title
• site_url : AdminSite.site_url
• has_permission : AdminSite.has_permission()

• available_apps : वर्तमान उपयोगकर्ता के लिए उपलब्ध आवेदन रजिस्ट्री से आवेदनों की एक सूची । सूची में प्रत्येक प्रविष्टि निम्नलिखित कुंजियों के साथ एक आवेदन का प्रतिनिधित्व करने वाला एक तानाशाह है:

  • app_label : एप्लिकेशन लेबल
  • app_url : एडमिन में एप्लिकेशन इंडेक्स का URL
  • has_module_perms : एक बूलियन जो यह दर्शाता है कि वर्तमान उपयोगकर्ता के लिए मॉड्यूल के सूचकांक पृष्ठ को प्रदर्शित करना और एक्सेस करना अनुमत है
  • models : आवेदन में उपलब्ध मॉडल की एक सूची

  प्रत्येक मॉडल निम्नलिखित कुंजियों के साथ एक तानाशाही है:

  • object_name : मॉडल का वर्ग नाम
  • name : मॉडल का बहुवचन नाम
  • perms : एक dict ट्रैकिंग add , change , delete , और view अनुमतियाँ
  • admin_url : मॉडल के लिए व्यवस्थापक चैनल URL
  • add_url : एक नया मॉडल उदाहरण जोड़ने के लिए व्यवस्थापक URL

AdminSite.has_permission(request) [source]

True यदि दिए गए उपयोगकर्ता HttpRequest को व्यवस्थापक साइट में कम से कम एक पृष्ठ देखने की अनुमति है , तो लौटाता है दोनों की आवश्यकता है User.is_active और User.is_staff होने के लिए चूक True ।

AdminSite.register(model_or_iterable, admin_class=None, **options) [source]

दिए गए मॉडल वर्ग (या कक्षाओं के चलने योग्य) को पंजीकृत करता है admin_class । admin_class चूक ModelAdmin (डिफ़ॉल्ट व्यवस्थापक विकल्प के लिए)। यदि कीवर्ड तर्क दिए गए हैं - जैसे list_display - उन्हें व्यवस्थापक वर्ग के विकल्प के रूप में लागू किया जाएगा।

ImproperlyConfigured यदि कोई मॉडल अमूर्त है तो उठाता है। और django.contrib.admin.sites.AlreadyRegistered यदि कोई मॉडल पहले से पंजीकृत है।

AdminSite आपके URLconf में हुकिंग इंस्टेंस

Django एडमिन को स्थापित करने का अंतिम चरण आपके AdminSite उदाहरण को आपके URLconf में हुक करना है । AdminSite.urls विधि में दिए गए URL को इंगित करके ऐसा करें । यह उपयोग करने के लिए आवश्यक नहीं है include() ।

इस उदाहरण में, हम URL पर डिफ़ॉल्ट AdminSite उदाहरण पंजीकृत करते हैं django.contrib.admin.site /admin/

# urls.py
from django.contrib import admin
from django.urls import path

urlpatterns = [
    path('admin/', admin.site.urls),
]

AdminSite कक्षा को अनुकूलित करना

यदि आप कस्टम व्यवहार के साथ अपनी स्वयं की व्यवस्थापक साइट सेट करना चाहते हैं, तो आप उप-लिंक AdminSite और ओवरराइड करने या अपनी पसंद का कुछ भी जोड़ने के लिए स्वतंत्र हैं। फिर, बस अपने AdminSite उपवर्ग का एक उदाहरण बनाएं (जिस तरह से आप किसी अन्य पायथन वर्ग को इंस्टेंट करेंगे) और अपने मॉडल और ModelAdmin उपवर्गों को डिफ़ॉल्ट साइट के बजाय पंजीकृत करें । अंत में, myproject/urls.py अपने AdminSite उपवर्ग को संदर्भित करने के लिए अपडेट करें ।

from django.contrib.admin import AdminSite

from .models import MyModel

class MyAdminSite(AdminSite):
    site_header = 'Monty Python administration'

admin_site = MyAdminSite(name='myadmin')
admin_site.register(MyModel)

from django.urls import path

from myapp.admin import admin_site

urlpatterns = [
    path('myadmin/', admin_site.urls),
]

ध्यान दें कि आप admin अपने स्वयं के AdminSite उदाहरण का उपयोग करते समय मॉड्यूल के ऑटोडिस्कवरी नहीं चाहते हैं क्योंकि आप संभवतः admin अपने myproject.admin मॉड्यूल में सभी प्रति-ऐप मॉड्यूल आयात कर रहे होंगे । यह आपको लगाने की जरूरत का मतलब है 'django.contrib.admin.apps.SimpleAdminConfig' बजाय 'django.contrib.admin' अपने में INSTALLED_APPS सेटिंग।

डिफ़ॉल्ट व्यवस्थापक साइट को ओवरराइड करना

आप कस्टम django.contrib.admin.site की default_site विशेषता को AppConfig किसी AdminSite उपवर्ग या किसी कॉल करने योग्य के डॉक्ड आयात पथ पर सेट करके डिफ़ॉल्ट को ओवरराइड कर सकते हैं जो साइट का उदाहरण देता है।

from django.contrib import admin

class MyAdminSite(admin.AdminSite):
    ...

from django.contrib.admin.apps import AdminConfig

class MyAdminConfig(AdminConfig):
    default_site = 'myproject.admin.MyAdminSite'

INSTALLED_APPS = [
    ...
    'myproject.apps.MyAdminConfig',  # replaces 'django.contrib.admin'
    ...
]

एक ही URLconf में कई व्यवस्थापक साइटें

एक ही Django- संचालित वेबसाइट पर व्यवस्थापक साइट के कई उदाहरण बनाना आसान है। बस AdminSite एक से अधिक उदाहरण बनाएं और हर एक को एक अलग URL पर रूट करें।

इस उदाहरण में, URL /basic-admin/ और /advanced-admin/ व्यवस्थापक साइट के अलग-अलग संस्करण - क्रमशः और AdminSite उदाहरणों का उपयोग करते हुए: myproject.admin.basic_site myproject.admin.advanced_site

# urls.py
from django.urls import path
from myproject.admin import advanced_site, basic_site

urlpatterns = [
    path('basic-admin/', basic_site.urls),
    path('advanced-admin/', advanced_site.urls),
]

AdminSite उदाहरण उनके निर्माता, उनके नाम के लिए एक एकल तर्क लेते हैं, जो आपके लिए कुछ भी हो सकता है। यह तर्क URL के नामों का पूर्ववर्ती बन जाता है ताकि उन्हें उलट दिया जा सके । यह केवल तभी आवश्यक है जब आप एक से अधिक का उपयोग कर रहे हों AdminSite ।

व्यवस्थापक साइटों पर विचार जोड़ना

जैसे ModelAdmin , AdminSite एक get_urls() तरीका प्रदान करता है जिसे साइट के लिए अतिरिक्त विचारों को परिभाषित करने के लिए ओवरराइड किया जा सकता है। अपनी व्यवस्थापक साइट में एक नया दृश्य जोड़ने के get_urls() लिए, अपने नए दृश्य के लिए एक पैटर्न शामिल करने के लिए आधार विधि का विस्तार करें ।

पासवर्ड रीसेट सुविधा जोड़ना

आप अपने URLconf में कुछ पंक्तियाँ जोड़कर व्यवस्थापक साइट के लिए एक पासवर्ड रीसेट सुविधा जोड़ सकते हैं। विशेष रूप से, इन चार पैटर्न को जोड़ें:

from django.contrib.auth import views as auth_views

path(
    'admin/password_reset/',
    auth_views.PasswordResetView.as_view(),
    name='admin_password_reset',
),
path(
    'admin/password_reset/done/',
    auth_views.PasswordResetDoneView.as_view(),
    name='password_reset_done',
),
path(
    'reset/<uidb64>/<token>/',
    auth_views.PasswordResetConfirmView.as_view(),
    name='password_reset_confirm',
),
path(
    'reset/done/',
    auth_views.PasswordResetCompleteView.as_view(),
    name='password_reset_complete',
),

(यह मानता है कि आपने व्यवस्थापक को इसमें जोड़ा है admin/ और इसके लिए आवश्यक है कि आप ^admin/ उस पंक्ति से पहले शुरू होने वाले URL को शामिल करें जिसमें व्यवस्थापक ऐप शामिल है)

admin_password_reset नामांकित URL की उपस्थिति पासवर्ड बॉक्स के नीचे डिफ़ॉल्ट व्यवस्थापक लॉग-इन पृष्ठ पर प्रदर्शित होने के लिए "अपना पासवर्ड भूल गए?" लिंक का कारण बनेगी।

LogEntry वस्तुओं

class models.LogEntry

LogEntry वर्ग परिवर्धन, परिवर्तन, और व्यवस्थापक इंटरफ़ेस के माध्यम से किया वस्तुओं के विलोपन ट्रैक करता है।

LogEntry गुण

LogEntry.action_time

कार्रवाई की तारीख और समय।

LogEntry.user

उपयोगकर्ता (एक AUTH_USER_MODEL उदाहरण) जिसने कार्रवाई की।

LogEntry.content_type

ContentType संशोधित वस्तु की।

LogEntry.object_id

संशोधित ऑब्जेक्ट की प्राथमिक कुंजी का शाब्दिक प्रतिनिधित्व।

LogEntry.object_repr

repr() संशोधन के बाद ऑब्जेक्ट ` ।

LogEntry.action_flag

कार्रवाई के प्रकार लॉग इन: ADDITION , CHANGE , DELETION ।

उदाहरण के लिए, व्यवस्थापक के माध्यम से किए गए सभी अतिरिक्त की सूची प्राप्त करने के लिए:

from django.contrib.admin.models import ADDITION, LogEntry

LogEntry.objects.filter(action_flag=ADDITION)

LogEntry.change_message

संशोधन का विस्तृत विवरण। उदाहरण के लिए, संपादन के मामले में, संदेश में संपादित फ़ील्ड की एक सूची शामिल है। Django व्यवस्थापक साइट इस सामग्री को JSON संरचना के रूप में प्रारूपित करती है, ताकि get_change_message() वर्तमान उपयोगकर्ता भाषा में अनुवादित संदेश को पुन: प्राप्त कर सके। कस्टम कोड हालांकि इसे एक सादे स्ट्रिंग के रूप में सेट कर सकता है। आपको सलाह दी जाती है कि get_change_message() इस मूल्य को पुनः प्राप्त करने के बजाय इसे सीधे एक्सेस करने की विधि का उपयोग करें ।

LogEntry तरीकों

LogEntry.get_edited_object()

एक शॉर्टकट जो संदर्भित ऑब्जेक्ट को लौटाता है।

LogEntry.get_change_message()

change_message वर्तमान उपयोगकर्ता भाषा में प्रारूप और अनुवाद । Django 1.10 से पहले बनाए गए संदेश हमेशा उस भाषा में प्रदर्शित किए जाएंगे जिसमें वे लॉग इन थे।

व्यवस्थापक URL को उलट देना

जब कोई AdminSite परिनियोजित किया जाता है, तो उस साइट द्वारा प्रदान किए गए दृश्य Django के URL रिवर्सल सिस्टम का उपयोग करके सुलभ होते हैं ।

AdminSite निम्नलिखित नामित URL प्रतिमानों प्रदान करता है:

पृष्ठ	URL का नाम	पैरामीटर
सूची	index
लॉग इन करें	login
लोग आउट	logout
पासवर्ड परिवर्तन	password_change
पासवर्ड बदल दिया गया	password_change_done
i18n जावास्क्रिप्ट	jsi18n
एप्लिकेशन इंडेक्स पेज	app_list	app_label
ऑब्जेक्ट के पेज पर रीडायरेक्ट करें	view_on_site	content_type_id , object_id

प्रत्येक ModelAdmin उदाहरण नामित URL का एक अतिरिक्त सेट प्रदान करता है:

पृष्ठ	URL का नाम	पैरामीटर
सूचि बदलें	{{ app_label }}_{{ model_name }}_changelist
जोड़ना	{{ app_label }}_{{ model_name }}_add
इतिहास	{{ app_label }}_{{ model_name }}_history	object_id
हटाना	{{ app_label }}_{{ model_name }}_delete	object_id
परिवर्तन	{{ app_label }}_{{ model_name }}_change	object_id

UserAdmin एक नामित URL प्रदान करता है:

पृष्ठ	URL का नाम	पैरामीटर
पासवर्ड परिवर्तन	auth_user_password_change	user_id

ये नामांकित URL एप्लिकेशन नामस्थान के साथ पंजीकृत हैं admin , और साइट के नाम के नाम से संबंधित एक उदाहरण नामस्थान के साथ।

इसलिए - यदि आप Choice डिफ़ॉल्ट व्‍यवस्‍था में किसी विशेष ऑब्जेक्ट (चुनाव एप्लिकेशन से) के लिए परिवर्तन दृश्य का संदर्भ प्राप्त करना चाहते हैं , तो आप संपर्क करेंगे:

>>> from django.urls import reverse
>>> c = Choice.objects.get(...)
>>> change_url = reverse('admin:polls_choice_change', args=(c.id,))

यह व्यवस्थापक एप्लिकेशन का पहला पंजीकृत उदाहरण (उदाहरण का नाम), और poll.Choice उस उदाहरण में बदलते उदाहरणों के लिए दृश्य को हल करेगा ।

यदि आप किसी विशिष्ट व्यवस्थापक उदाहरण में URL ढूंढना चाहते हैं, current_app तो रिवर्स कॉल के संकेत के रूप में उस उदाहरण का नाम प्रदान करें। उदाहरण के लिए, यदि आप विशेष रूप से नामित व्यवस्थापक उदाहरण से व्यवस्थापक दृश्य चाहते हैं, तो आपको custom कॉल करना होगा:

>>> change_url = reverse('admin:polls_choice_change', args=(c.id,), current_app='custom')

अधिक विवरणों के लिए, नामांकित URL को उलटने के लिए दस्तावेज़ीकरण देखें ।

टेम्पलेट्स में व्यवस्थापक के आसान उलटने की अनुमति देने के लिए, Django एक admin_urlname फ़िल्टर प्रदान करता है जो तर्क के रूप में एक कार्रवाई करता है:

{% load admin_urls %}
<a href="{% url opts|admin_urlname:'add' %}">Add user</a>
<a href="{% url opts|admin_urlname:'delete' user.pk %}">Delete this user</a>

ऊपर दिए गए उदाहरणों में कार्रवाई ऊपर ModelAdmin वर्णित उदाहरणों के लिए URL नामों के अंतिम भाग से मेल खाती है। opts चर किसी भी वस्तु जो एक है हो सकता है app_label और model_name जिम्मेदार बताते हैं और आम तौर पर मौजूदा मॉडल के लिए व्यवस्थापक देखा गया आपूर्ति की है।

staff_member_required डेकोरेटर

staff_member_required(redirect_field_name='next', login_url='admin:login') [source]

इस डेकोरेटर का उपयोग उस व्यवस्थापक दृश्य पर किया जाता है जिसे प्राधिकरण की आवश्यकता होती है। इस कार्य से सजाया गया एक दृश्य निम्नलिखित व्यवहार करेगा:

• यदि उपयोगकर्ता लॉग इन है, तो एक स्टाफ सदस्य ( User.is_staff=True ) है, और सक्रिय है ( User.is_active=True ), सामान्य रूप से दृश्य निष्पादित करें।
• अन्यथा, अनुरोध login_url पैरामीटर द्वारा निर्दिष्ट URL पर पुनर्निर्देशित किया जाएगा , जिसमें निर्दिष्ट स्ट्रिंग स्ट्रिंग चर में मूल रूप से अनुरोधित पथ है redirect_field_name । उदाहरण के लिए /admin/login/?next=/admin/polls/question/3/ :।

उदाहरण का उपयोग:

from django.contrib.admin.views.decorators import staff_member_required

@staff_member_required
def my_view(request):
    ...