One of the most powerful parts of Django is the automatic admin interface. It reads metadata from your models to provide a quick, model-centric interface where trusted users can manage content on your site.
The admin’s recommended use is limited to an organization’s internal management tool. It’s not intended for building your entire front end around. In this article, we will cover everything you need to know to become a Django Admin pro. We will start from scratch and gradually move to advanced topics.
By the end of this article, you will be able to manage your Django project efficiently using Django Admin.
This will be a long article, feel free to jump to the section you are interested in:
- Activating Django Admin
- Creating Superuser
- Accessing Django Admin Site
- An Overview of Django Admin Interface
- Creating and registering models
- ModelAdmin class
- ModelAdmin Actions
Activating Django Admin
The admin is enabled in the default project template used by startproject. If you’re not using the default project template, here are the requirements:
- Add
django.contrib.admin
and its dependencies -django.contrib.auth
,django.contrib.contenttypes
,django.contrib.messages
, anddjango.contrib.sessions
- to your INSTALLED_APPS setting. - Add
admin.site.urls
to your URLconf. Modify theurls.py
file in your project folder to include the following line:
urlpatterns = [
path('admin/', admin.site.urls),
]
Creating Superuser account
To access the Django admin, you need to create a superuser. Run the following command in your terminal:
python manage.py createsuperuser
You will be prompted to enter a username, email address, and password for the superuser.
Accessing Django Admin Site
Run the Django development server:
python manage.py runserver
By default, Django development server will run on port 8000. Open your browser and navigate to http://localhost:8000/admin/. You will see the Django admin login page.
Enter the superuser credentials you created earlier to log in.
An Overview of Django Admin Interface
Without any other registered models, Django will display the “Groups” and “Users” models. These are part of Django’s authentication framework. You can use these models to manage users and groups in your Django project. Please note how they are categorized under the “Authentication and Authorization” section.
Creating and registering models
In this article let's work with the Books model
located in the books
app. The Books model
has the following fields:
-
title
- The title of the book. -
author
- The author of the book. -
price
- The price of the book. -
published
- A boolean field to indicate if the book has been published.
Assuming you have already created the books
app, let's create the Books model
in the models.py
file of the books
app:
class Book(models.Model):
title = models.CharField(max_length=100)
author = models.CharField(max_length=100)
price = models.DecimalField(max_digits=10, decimal_places=2)
published = models.BooleanField(default=False)
def __str__(self):
return self.title # Display the title of the book in the Django admin site
class Meta:
# the attributes below are very useful for the Django admin interface, they are not required but are good practice
verbose_name = 'Book' # Singular name for the model
verbose_name_plural = 'Books' # Plural name for the model
In your admin.py
file of the books
app, register the Books model
:
from .models import Book
admin.site.register(Book)
Save the file and make migrations:
python manage.py makemigrations
python manage.py migrate
Restart the Django development server:
python manage.py runserver
Head over to the Django admin site and you will see the Books
model listed under the Books
section. You can now add, edit, and delete books using the Django admin interface.
Make sure to create some books using the Django admin interface.
How cool is that?
A little further - ModelAdmin class
It is possible to register a model with just the admin.site.register(ModelName)
method.
Perhaps you need more control over how the model is displayed in the admin interface. This is where the ModelAdmin
class comes in.
The ModelAdmin
class is the representation of a model in the admin interface. It allows you to customize how the model is displayed, how it can be interacted with, and how it can be filtered.
You can customize the ModelAdmin
class by creating a class that inherits from admin.ModelAdmin
and then registering it with the model.
In our case, we want to display the Books
model with a list of books sorted by the price in ascending order. We also want to display the title
and author
fields in the list view.
Let's create a BookAdmin
class in the admin.py
file of the books
app:
class BookAdmin(admin.ModelAdmin):
list_display = ('title', 'author') # Display title and author fields in the list view
ordering = ('price',) # Sort by price in ascending order
Register the BookAdmin
class with the Books
model:
admin.site.register(Book, BookAdmin)
In the end the admin.py
file of the books
app should look like this:
from django.contrib import admin
from .models import Book
class BookAdmin(admin.ModelAdmin):
list_display = ('title', 'author') # Display title and author fields in the list view
ordering = ('price',) # Sort by price in ascending order
admin.site.register(Book, BookAdmin)
Head over to the Django admin site and you will see the Books
model listed under the Books
section. The books will be displayed with the title
and author
fields in the list view, sorted by price in ascending order.
Let me teach you an even concise way to register the ModelAdmin
using the @admin.register
decorator.
@admin.register(Book)
class BookAdmin(admin.ModelAdmin):
list_display = ('title', 'author') # Display title and author fields in the list view
ordering = ('price',) # Sort by price in ascending order
The above code is equivalent to the previous code where we registered the BookAdmin
class with the Books
model but in a more concise way.
ModelAdmin Actions
If you have noticed, selecting multiple books provides a dropdown with the action "Delete selected books". This is an example of a ModelAdmin
action.
That sounds limited, right? What if you want to create your own custom actions?
Custom ModelAdmin Actions
The easiest way to explain actions is by example, so let’s dive in.
A common use case for admin actions is the bulk updating of a model’s fields.
To create an action, you need to define a method in the ModelAdmin
class and decorate it with the @admin.action
decorator.
Let's create a custom action to mark selected books as published.
class BookAdmin(admin.ModelAdmin):
list_display = (
"title",
"author",
) # Display title and author fields in the list view
ordering = ("price",) # Sort by price in ascending order
actions = ["mark_as_published"] # Add the custom action
@admin.action(description="Mark selected books as published")
def mark_as_published(self, request, queryset):
queryset.update(published=True)
admin.site.register(Book, BookAdmin)
Admin model actions take three arguments: self
, request
, and queryset
. The queryset
argument is a list of all the selected objects. In our case, it will be a list of selected books.
That is just a tip of the iceberg. There is so much more you can do with Django Admin. I hope this article has given you a good foundation to start exploring Django Admin. Feel free to explore the official Django documentation to learn more about Django Admin.
Happy coding! 🚀
Top comments (0)