Crear un blog con Django. Parte 3: Panel de administración

Una de las cosas más interesantes de Django es que tiene una interfaz de administración. Esta lee los metadatos de los modelos creados en nuestro proyecto y nos proporciona una interfaz rápida para la administración del contenido de nuestro sitio.

Antes de acceder al panel de administración debemos realizar unos cambios en los archivos admin.py de nuestro módulos. Empezaremos por el de users:

Users

Lo primero que haremos será crear un super usuario para poder acceder al panel, este se crea con el siguiente comando:

python manage.py createsuperuser

Este comando nos pedirá una serie de datos para crear un usuario, una vez hecho esto y corriendo el servidor si accedemos a la siguiente url http://127.0.0.1:8000/admin/ nos aparecerá la ventana de login y podremos acceder a la interfaz de administración.

Una vez hecho login nos aparecerá un menú donde podemos añadir grupos y usuarios, solo se muestran estos dos ya que son las configuraciones por defecto que trae Django. Ahora nos toca a nosotros customizar esta herramienta.

Abrimos nuestro archivo simple_blog/users/admin.py y añadimos el siguiente código:

"""User admin classes."""

# Django
from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
from django.contrib import admin

# Models
from django.contrib.auth.models import User
from users.models import Profile


@admin.register(Profile)
class ProfileAdmin(admin.ModelAdmin):
    """Profile admin."""

    list_display = ('pk', 'user', 'photo')
    list_display_links = ('pk', 'user',)
    list_editable = ('photo',)

    search_fields = (
        'user__email',
        'user__username',
        'user__first_name',
        'user__last_name',
    )

    list_filter = (
        'user__is_active',
        'user__is_staff',
        'date_modified',
    )

    fieldsets = (
        ('Profile', {
            'fields': (('user', 'photo', 'website'),),
        }),
        ('Extra info', {
            'fields': (('date_modified'),),
        })
    )

    readonly_fields = ('date_modified',)

Aquí lo que hacemos es importar la libería admin y nuestros modelos de User y Profile. Con admin.register(Profile) registramos nuestro modelo lo que hará que nos aparezca en el panel.

Después creamos nuestra clase ProfileAdmin, por convección se añade al final del nombre la palabra Admin y aquí es donde vamos a meter configuraciones customizadas.

list_display: Nos mostrará la lista de usuarios creados cuando estemos en el apartado de profile, la información que se mostrará es la que añadamos en la lista, en este caso la primary key, el usuario y la foto.

list_display_links: Añadirá un link para la edición en los campos que especifiquemos, en este caso en la primary key y en el usuario.

list_editable: Esta funcionalidad nos permitirá editar la foto de un usuario desde el panel de listados.

search_fields: Permite la busqueda por los campos que añadas.

list_filter: Añade un panel de filtros con los campos que hemos añadido.

field_sets: Permite customizar como se visualizarán los datos en el panel, en nuestro caso, profile y metadata serían las cabeceras de los campos y dentro de fields si los datos están dentro de una tupla aparecerán horizontalmente (nuestro caso), sino verticalmente.

readonly_fields: Los datos que añadas aquí se mostrarán solo como lectura.

Por último lo que vamos a hacer es tener la posibilidad de crear un usuario y profile desde el mismo panel para ahorrarnos tener que estar navegando entre paneles. Esto se consigue con la clase StackedInline. Añadimos el siguiente código al final de nuestro archivo admin.py:

class ProfileInline(admin.StackedInline):
    """Profile in-line admin for users."""

    model = Profile
    can_delete = False
    verbose_name_plural = 'profiles'


class UserAdmin(BaseUserAdmin):
    """Add profile admin to base user admin."""

    inlines = (ProfileInline,)
    list_display = (
        'username',
        'email',
        'first_name',
        'last_name',
        'is_active',
        'is_staff'
    )


admin.site.unregister(User)
admin.site.register(User, UserAdmin)

Lo que hacemos aquí es crear la clase ProfileInline y en está guardamos el modelo que queremos añadir al modelo padre.

Después lo que tenemos que hacer es quitar la clase User que es la que está por defecto y registrar nuestra nueva clase, entonces declaramos nuestra nueva clase, añadimos la clase de tipo StackedInline y en el list_display metemos los datos que queremos que se muestren al listar los usuarios.

Por último utilizamos el metodo unregister para quitar nuestra clase User y registramos la nueva clase pasando el modelo base y la nueva clase. 

Post

Ahora crearemos el panel de admin para los posts, para ello abrimos simple_blog/posts/admin.py y añadimos el siguiente código:

from django.contrib import admin

# Register your models here.
from posts.models import Post

@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    """Post admin."""

    list_display = ('id', 'user', 'title', 'image_header')
    search_fields = ('title', 'user__username', 'user__email')
    list_filter = ('created', 'modified')
        
        
    def get_form(self, request, obj=None, **kwargs):
        self.exclude = ('url', )
        form = super(PostAdmin, self).get_form(request, obj, **kwargs)
        form.base_fields['user'].initial = request.user
        form.base_fields['profile'].initial = request.user.profile
        return form

Para este caso hemos añadido el método get_form que lo que hace es que nos permite realizar cambios en el formulario antes de mostrarlo. 

Los cambios que hemos realizado son ocultar la url con el método self.exclude y que por defecto el creador del post sea el usuario con el que estás logueado.

Categories

Este es bastante sencillo, simplemente añadimos el siguiente código y ya lo tendríamos:

from django.contrib import admin

# Register your models here.
from categories.models import Category

@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
    """Category admin."""

    list_display = ('id', 'name')

Comments

Por último crearemos el panel para los comentarios, en este caso solo lo usaremos para listar los comentarios de forma que podamos buscar comentarios que no cumplan nuestra política y así poder eliminarlos. Añadimos el siguente código:

from django.contrib import admin

# Register your models here.
from comments.models import Comment

@admin.register(Comment)
class CommentAdmin(admin.ModelAdmin):
    """Comment admin."""

    list_display = ('id', 'user', 'post', 'comment')

Conclusiones

Con esto tendríamos terminada la parte de admin, que gracias a Django nos permite crear y modificar un panel para administrar nuestro site fácilmente. Para más información podéis consultar la documentación del panel de administración, en la siguiente parte veremos como implementar el diseño.

Espero que este post te ayude y como siempre, te recomiendo seguirme en Twitter para estar al tanto de los nuevo contenido. Ahora también puedes seguirme en Instagram donde estoy subiendo tips, tutoriales en vídeo e información sobre herramientas para developers.

Por último os dejo mi guía para aprender a trabajar con APIs donde explico todo el funcionamiento de una API, el protocolo HTTP y veremos como construir una API con arquitectura REST.

Nos leemos 👋.