Djangoadminsite(三)InlineModelAdmin
InlineModelAdmin
class InlineModelAdmin
class TabularInline
class StackedInline
For example, there are two Models:
from django.db import models
class Author(models.Model):
name = models.CharField(max_length=100)
class Book(models.Model):
author = models.ForeignKey(Author)
title = models.CharField(max_length=100)
If you want to edit book on the Author page:
from django.contrib import admin
class BookInline(admin.TabularInline):
model = Book
class AuthorAdmin(admin.ModelAdmin):
inlines = [
, BookInline,
]
Django provides two subclasses of InlineModelAdmin:
TabularInline
StackedInline
The difference is the template used.
InlineModelAdmin options
The options common to InlineModelAdmin and ModelAdmin are:
form
fieldsets
fields
formfield_overrides
exclude
filter_horizontal
filter_vertical
ordering
PRepopulated_fields
get_queryset()
radio_fields
readonly_fields
raw_id_fields
formfield_for_choice_field()
formfield_for_foreignkey ()
formfield_for_manytomany()
has_add_permission()
has_change_permission()
has_delete_permission()
Additional options are:
InlineModelAdmin.model
The model used inline, required.
InlineModelAdmin.fk_name
The name of the model, used when there are multiple foreign keys.
InlineModelAdmin.formset
Default BaseInlineFormSet.
InlineModelAdmin.form
Default ModelForm. Passed to inlineformset_factory() when creating the formset.
InlineModelAdmin.extra
Extra number of inline.
InlineModelAdmin.get_extra() also returns the extra number of inline.
InlineModelAdmin.max_num
The maximum number that can be displayed.
InlineModelAdmin.get_max_num() also returns this number.
InlineModelAdmin.min_num
The minimum number that can be displayed.
InlineModelAdmin.get_min_num() also returns this number.
InlineModelAdmin.raw_id_fields
Same as ModelAdmin.
class BookInline(admin.TabularInline):
model = Book
raw_id_fields = ("pages",)
InlineModelAdmin.template
The template used.
InlineModelAdmin.verbose_name
overrides verbose_name in meta class.
InlineModelAdmin.verbose_name_plural
Same as above
InlineModelAdmin.can_delete
Defaults to True.
InlineModelAdmin.get_formset(request, obj=None, **kwargs)
Refer to ModelAdmin.get_formsets_with_inlines.
InlineModelAdmin.get_extra(request, obj=None, **kwargs)
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)
class BinaryTreeAdmin(admin.TabularInline):
model = BinaryTree
def get_max_num(self, request, obj=None, **kwargs):
max_num = 10
if obj .parent :
return max_num - 5
using using using . out out through off through off ’s ’ through ’ s ’ through through ‐ ‐ ‐ ‐‐ ‐ back , return max_num to 5
‐ ‐ ‐ ‐ return max_num
InlineModelAdmin.get_min_num(request, obj=None, **kwargs)
from django.db import models
class Friendship(models.Model):
to_person = models.ForeignKey(Person, related_name= "friends")
from_person = models.ForeignKey(Person, related_name="from_friends")
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,
]
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')
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',)
Note:
First, the MembershipInline class points to Group.members.through. The through attribute points to the management of the many- to-many relationship database.
Second, the GroupAdmin must exclude the members field.
Working with many-to-many intermediary models
Explicitly indicate the intermediate model example:
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)
group = models.ForeignKey(Group)
date_joined = models.DateField()
invite_reason = models.CharField(max_length =64)
First step:
class MembershipInline(admin.TabularInline):
model = Membership
extra = 1
Second step:
class PersonAdmin(admin.ModelAdmin):
inlines = (MembershipInline ,)
class GroupAdmin(admin.ModelAdmin):
inlines = (MembershipInline,)
Step 3:
admin.site.register(Person, PersonAdmin)
admin.site.register(Group, GroupAdmin)
Using generic relations as an inline
An example of inline with generically related objects:
from django.db import models
from django.contrib.contenttypes.fields import GenericForeignKey
class Image(models.Model):
image = models.ImageField(upload_to="images")
content_type = models.ForeignKey(ContentType)
object_id = models.PositiveIntegerField()
content_object = GenericForeignKey("content_type", "object_id")
class Product(models.Model):
name = models.CharField(max_length=100)
If you want to edit the Image instance on the Product add/change page, you can use GenericTabularInline or GenericStackedInline:
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)
The above is the content of Djangoadminsite (3) InlineModelAdmin. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!

Hot AI Tools

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Undress AI Tool
Undress images for free

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics











Python is suitable for data science, web development and automation tasks, while C is suitable for system programming, game development and embedded systems. Python is known for its simplicity and powerful ecosystem, while C is known for its high performance and underlying control capabilities.

Python excels in gaming and GUI development. 1) Game development uses Pygame, providing drawing, audio and other functions, which are suitable for creating 2D games. 2) GUI development can choose Tkinter or PyQt. Tkinter is simple and easy to use, PyQt has rich functions and is suitable for professional development.

You can learn basic programming concepts and skills of Python within 2 hours. 1. Learn variables and data types, 2. Master control flow (conditional statements and loops), 3. Understand the definition and use of functions, 4. Quickly get started with Python programming through simple examples and code snippets.

Python is easier to learn and use, while C is more powerful but complex. 1. Python syntax is concise and suitable for beginners. Dynamic typing and automatic memory management make it easy to use, but may cause runtime errors. 2.C provides low-level control and advanced features, suitable for high-performance applications, but has a high learning threshold and requires manual memory and type safety management.

To maximize the efficiency of learning Python in a limited time, you can use Python's datetime, time, and schedule modules. 1. The datetime module is used to record and plan learning time. 2. The time module helps to set study and rest time. 3. The schedule module automatically arranges weekly learning tasks.

Python is better than C in development efficiency, but C is higher in execution performance. 1. Python's concise syntax and rich libraries improve development efficiency. 2.C's compilation-type characteristics and hardware control improve execution performance. When making a choice, you need to weigh the development speed and execution efficiency based on project needs.

Python excels in automation, scripting, and task management. 1) Automation: File backup is realized through standard libraries such as os and shutil. 2) Script writing: Use the psutil library to monitor system resources. 3) Task management: Use the schedule library to schedule tasks. Python's ease of use and rich library support makes it the preferred tool in these areas.

Is it enough to learn Python for two hours a day? It depends on your goals and learning methods. 1) Develop a clear learning plan, 2) Select appropriate learning resources and methods, 3) Practice and review and consolidate hands-on practice and review and consolidate, and you can gradually master the basic knowledge and advanced functions of Python during this period.
