Personnaliser l'administrateur Django avec Python – Real Python

By | août 3, 2020

Expert Python

le Django framework est livré avec un puissant outil d'administration appelé admin. Vous pouvez l'utiliser immédiatement pour ajouter, supprimer ou modifier rapidement tout modèle de base de données à partir d'une interface Web. Mais avec un peu de code supplémentaire, vous pouvez personnaliser l'administrateur Django pour faire passer vos capacités d'administration au niveau supérieur.

Dans ce didacticiel, vous apprendrez à:

  • Ajouter colonnes d'attributs dans la liste des objets du modèle
  • Lien entre les objets du modèle
  • Ajouter filtres à la liste des objets du modèle
  • Créer des listes d'objets de modèle consultable
  • Modifier l'objet modifier les formulaires
  • Remplacer Django modèles d'administration

Conditions préalables

Pour tirer le meilleur parti de ce didacticiel, vous devez vous familiariser avec Django, en particulier les objets de modèle. Comme Django ne fait pas partie de la bibliothèque Python standard, il est préférable que vous ayez également une certaine connaissance de pépin et pyenv (ou un outil d'environnement virtuel équivalent). Pour en savoir plus sur ces sujets, consultez les ressources suivantes:

Vous pourriez également être intéressé par l'un des nombreux didacticiels Django disponibles.

Les extraits de code de ce didacticiel ont été testés avec Django 3.0.7. Tous les concepts sont antérieurs à Django 2.0, ils devraient donc fonctionner dans la version que vous utilisez, mais des différences mineures peuvent exister.

Configuration de l'administrateur Django

le Administrateur Django fournit une interface Web pour créer et gérer des objets de modèle de base de données. Pour le voir en action, vous aurez d'abord besoin d'un projet Django et de quelques modèles d'objets. Installez Django dans un environnement virtuel propre:

$ python -m pip installer django
$ École startproject django-admin
$ CD École
$ ./manage.py core startapp
$ ./manage.py migrer
$ ./manage.py createuperuser
Nom d'utilisateur: admin
Adresse e-mail: admin@example.com
Mot de passe:
Mot de passe (à nouveau):

Vous créez d'abord un nouveau projet Django nommé École avec une application appelée coeur. Ensuite, vous migrez les tables d'authentification et créez un administrateur. L'accès aux écrans d'administration de Django est limité aux utilisateurs avec Personnel ou superutilisateur drapeaux, vous utilisez donc le créeuperutilisateur commande de gestion pour créer un superutilisateur.

Vous devez également modifier École / settings.py pour inclure la nouvelle application nommée coeur:

# École / settings.py
# ...

INSTALLED_APPS = [[[[
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
    "coeur",    # Ajouter cette ligne
]

le coeur Le répertoire de l'application commencera avec les fichiers suivants à l'intérieur:

coeur/
│
├── migrations /
│ └── __init__.py
│
├── __init__.py
├── admin.py
├── apps.py
├── models.py
├── tests.py
└── views.py

Vous êtes intéressé par deux de ces fichiers:

  1. models.py définit vos modèles de base de données.
  2. admin.py enregistre vos modèles auprès de l'administrateur Django.

Pour illustrer le résultat lorsque vous personnalisez l'administrateur Django, vous aurez besoin de quelques modèles. Éditer core / models.py:

de django.core.validators importer MinValueValidator, MaxValueValidator
de django.db importer des modèles

classe La personne(des modèles.Modèle):
    nom de famille = des modèles.Champ de texte()
    Prénom = des modèles.Champ de texte()
    cours = des modèles.ManyToManyField("Cours", Vide=Vrai)

    classe Meta:
        verbose_name_plural = "Gens"

classe Cours(des modèles.Modèle):
    Nom = des modèles.Champ de texte()
    an = des modèles.IntegerField()

    classe Meta:
        unique_together = ("Nom", "an", )

classe Classe(des modèles.Modèle):
    la personne = des modèles.Clé étrangère(La personne, on_delete=des modèles.CASCADE)
    classe = des modèles.PositiveSmallIntegerField(
        validateurs=[[[[MinValueValidator(0), MaxValueValidator(100)])
    cours = des modèles.Clé étrangère(Cours, on_delete=des modèles.CASCADE)

Ces modèles représentent des étudiants qui suivent des cours dans une école. UNE Cours a un Nom et un an dans lequel il a été offert. UNE La personne a un prénom et un nom et peut prendre zéro ou plus cours. UNE Classe contient un score en pourcentage qu'un La personne reçu sur un Cours.

Voici un diagramme de modèle montrant les relations entre les objets:

Exemples de relations de modèle d'objet

Les noms de table sous-jacents dans la base de données sont légèrement différents de celui-ci, mais ils sont liés aux modèles présentés ci-dessus.

Chaque modèle que vous souhaitez que Django représente dans l'interface d'administration doit être enregistré. Vous faites cela dans le admin.py fichier. Modèles de core / models.py sont enregistrés dans le correspondant core / admin.py fichier:

de django.contrib importer admin

de core.models importer La personne, Cours, Classe

@admin.S'inscrire(La personne)
classe PersonAdmin(admin.ModelAdmin):
    passer

@admin.S'inscrire(Cours)
classe CourseAdmin(admin.ModelAdmin):
    passer

@admin.S'inscrire(Classe)
classe GradeAdmin(admin.ModelAdmin):
    passer

Vous êtes presque prêt à partir. Une fois que vous avez migré vos modèles de base de données, vous pouvez exécuter le serveur de développement Django et voir les résultats:

$ ./manage.py makemigrations
$ ./manage.py migrer
Opérations à effectuer:
        Appliquer toutes les migrations: admin, auth, contenttypes, core, sessions
Migrations en cours:
        Application des types de contenu.0001_initial ... OK
        Application de l'auth.0001_initial ... OK
        Application de admin.0001_initial ... OK
        ...
        Application de core.0001_initial ... OK
        Application de core.0002_auto_20200609_2120 ... OK
        Application des sessions.0001_initial ... OK
$ ./manage.py runserver
Surveiller les modifications de fichiers avec StatReloader
Vérification du système ...

La vérification du système n'a identifié aucun problème (0 désactivé).
Django version 3.0.7, en utilisant les paramètres 'School.settings'
Démarrage du serveur de développement à http://127.0.0.1:8000/
Quittez le serveur avec CONTROL-C.

Maintenant visitez http://127.0.0.1:8000/admin pour voir votre interface d'administration. Vous serez invité à vous connecter. Utilisez les informations d'identification que vous avez créées avec le créeuperutilisateur commande de gestion.

L'écran d'accueil de l'administrateur répertorie tous les modèles de base de données enregistrés:

Liste "index des applications" de Django Admin

Vous pouvez maintenant utiliser l'interface pour créer des objets dans votre base de données. Cliquez sur le nom d'un modèle pour afficher un écran répertoriant tous les objets de la base de données pour ce modèle. Ici se trouve le La personne liste:

Écran de liste de changement de personne vide

La liste commence vide, comme votre base de données. En cliquant AJOUTER UNE PERSONNE vous permet de créer une personne dans la base de données. Une fois que vous avez enregistré, vous serez renvoyé à la liste des La personne objets:

Liste des personnes avec une nouvelle personne

La bonne nouvelle est que vous avez un objet. La mauvaise nouvelle est Objet Personne (1) vous dit le id de l'objet et rien d'autre. Par défaut, l'administrateur Django affiche chaque objet en appelant str () dessus. Vous pouvez rendre cet écran un peu plus utile en ajoutant un .__ str __ () méthode à la La personne classe dans core / models.py:

classe La personne(des modèles.Modèle):
    nom de famille = des modèles.Champ de texte()
    Prénom = des modèles.Champ de texte()
    cours = des modèles.ManyToManyField("Cours", Vide=Vrai)

    def __str__(soi):
        revenir F"soi.nom de famille, soi.Prénom"

Ajouter Personne .__ str __ () modifie l'affichage pour inclure le prénom et le nom du La personne dans l'interface. Vous pouvez actualiser l'écran pour voir le changement:

Améliorer l'affichage avec __str __ ()

C’est un peu mieux! Vous pouvez maintenant voir des informations sur le La personne objet. Il est judicieux d’ajouter des méthodes similaires aux deux Cours et le Classe objets:

classe Cours(des modèles.Modèle):
    # ...

    def __str__(soi):
        revenir F"soi.Nom, soi.an"

classe Classe(des modèles.Modèle):
    # ...

    def __str__(soi):
        revenir F"soi.classe, soi.la personne, soi.cours"

Vous souhaiterez avoir des données dans votre base de données pour voir le plein effet de vos personnalisations. Vous pouvez vous amuser et créer vos propres données maintenant, ou vous pouvez sauter le travail et utiliser un fixation. Développez la case ci-dessous pour savoir comment charger des données à l'aide d'un appareil.

Django vous permet de charger des données depuis et vers la base de données dans des fichiers appelés agencements. Copiez ce qui suit dans un fichier nommé core / fixtures / school.json:

[[[[
    
        "modèle": "core.person",
        "pk": 1,
        "des champs": 
            "nom de famille": «Harris»,
            "Prénom": «Alex»,
            "cours": [[[[
                1,
                3
            ]
        
    ,
    
        "modèle": "core.person",
        "pk": 3,
        "des champs": 
            "nom de famille": «Rosenberg»,
            "Prénom": "Saule",
            "cours": [[[[
                1,
                2,
                3
            ]
        
    ,
    
        "modèle": "core.person",
        "pk": 16,
        "des champs": 
            "nom de famille": "Summers",
            "Prénom": «Buffy»,
            "cours": [[[[
                1,
                2,
                3
            ]
        
    ,
    
        "modèle": "core.course",
        "pk": 1,
        "des champs": 
            "Nom": «CompSci G11»,
            "an": 1998
        
    ,
    
        "modèle": "core.course",
        "pk": 2,
        "des champs": 
            "Nom": «Psych 101»,
            "an": 1999
        
    ,
    
        "modèle": "core.course",
        "pk": 3,
        "des champs": 
            "Nom": "Bibliothéconomie G10",
            "an": 1997
        
    ,
    
        "modèle": "core.grade",
        "pk": 1,
        "des champs": 
            "la personne": 16,
            "classe": 68,
            "cours": 1
        
    ,
    
        "modèle": "core.grade",
        "pk": 2,
        "des champs": 
            "la personne": 16,
            "classe": 87,
            "cours": 2
        
    ,
    
        "modèle": "core.grade",
        "pk": 3,
        "des champs": 
            "la personne": 16,
            "classe": 76,
            "cours": 3
        
    ,
    
        "modèle": "core.grade",
        "pk": 4,
        "des champs": 
            "la personne": 1,
            "classe": 58,
            "cours": 1
        
    ,
    
        "modèle": "core.grade",
        "pk": 5,
        "des champs": 
            "la personne": 1,
            "classe": 58,
            "cours": 3
        
    ,
    
        "modèle": "core.grade",
        "pk": 6,
        "des champs": 
            "la personne": 3,
            "classe": 98,
            "cours": 3
        
    ,
    
        "modèle": "core.grade",
        "pk": 7,
        "des champs": 
            "la personne": 3,
            "classe": 97,
            "cours": 2
        
    
]

Une fois que vous avez créé le fichier, vous pouvez utiliser la commande de gestion Django loaddata pour le charger dans votre base de données:

$ ./manage.py école loaddata
A installé 13 objet (s) à partir de 1 luminaire (s)

Votre base de données a maintenant un échantillon La personne, Cours, et Classe objets.

Maintenant que vous disposez de certaines données, vous êtes prêt à commencer à personnaliser l'interface d'administration de Django.

Personnalisation de l'administrateur Django

Les gens intelligents qui ont créé le framework Django ont non seulement construit l'administrateur, mais ils l'ont fait de manière à ce que vous puissiez le personnaliser pour vos projets. Lorsque vous avez enregistré le PersonAdmin objet plus tôt, il a hérité de admin.ModelAdmin. La plupart des personnalisations que vous pouvez faire avec l'administrateur Django se font en modifiant ModelAdmin, et vous pouvez certainement le modifier!

ModelAdmin a plus de trente attributs et près de cinquante méthodes. Vous pouvez utiliser chacun de ces éléments pour affiner la présentation de l’administrateur et contrôler les interfaces de vos objets. Chacune de ces options est décrite en détail dans la documentation.

Pour couronner le tout, l’administrateur est construit à l’aide de l’interface de création de modèles de Django. Le mécanisme de modèle de Django vous permet de remplacer les modèles existants, et comme l'administrateur n'est qu'un autre ensemble de modèles, cela signifie que vous pouvez modifier complètement son HTML.

Bien que cela dépasse le cadre de ce didacticiel, vous pouvez même créer plusieurs sites d'administration. Cela peut sembler exagéré, mais cela vous permet d'avoir de la fantaisie et de définir différents sites pour des utilisateurs avec des autorisations différentes.

L'administrateur Django est divisé en trois zones principales:

  1. Index des applications
  2. Modifier les listes
  3. Modifier les formulaires

le index des applications répertorie vos modèles enregistrés. UNE modifier la liste est automatiquement créé pour chaque modèle enregistré et répertorie les objets de ce modèle. Lorsque vous ajoutez ou modifiez l'un de ces objets, vous le faites avec un changer de formulaire.

Dans l'exemple précédent, l'index d'application montrait le La personne, Cours, et Classe objets. En cliquant Gens affiche les listes de modifications pour La personne objets. Sur le La personne modifier la page de la liste, en cliquant sur le Buffy Summers objet vous amène au formulaire de modification pour modifier les détails de Buffy.

Modification d'une liste de modifications à l'aide de list_display

Exécution .__ str __ () est un moyen rapide de changer la représentation d'un La personne objet d'une chaîne sans signification à des données compréhensibles. Étant donné que cette représentation apparaîtra également dans les listes déroulantes et les sélections multiples, vous voulez certainement la rendre aussi facile à comprendre que possible.

Vous pouvez personnaliser les pages de la liste de modifications de bien plus de manières que de simplement modifier la représentation sous forme de chaîne d’un objet. le list_display attribut d'un admin.ModelAdmin object spécifie les colonnes affichées dans la liste des modifications. Cette valeur est un tuple d'attributs de l'objet modélisé. Par exemple, dans core / admin.py, modifier PersonAdmin comme suit:

@admin.S'inscrire(La personne)
classe PersonAdmin(admin.ModelAdmin):
    list_display = ("nom de famille", "Prénom")

Le code ci-dessus modifie votre La personne modifier la liste pour afficher nom de famille et Prénom attributs pour chacun La personne objet. Chaque attribut est affiché dans une colonne de la page:

Ajouter des colonnes de prénom et de nom pour modifier la liste

Les deux colonnes sont cliquables, vous permettant de trier la page en fonction des données de la colonne. L'administrateur respecte également le commande attribut d'un Meta section:

classe La personne(des modèles.Modèle):
    # ...

    classe Meta:
        commande = ("nom de famille", "Prénom")

    # ...

Ajout du commande attribut par défaut toutes les requêtes sur La personne à commander par nom de famille puis Prénom. Django respectera cet ordre par défaut à la fois dans l'administrateur et lors de la récupération des objets.

le list_display tuple peut référencer n'importe quel attribut de l'objet répertorié. Il peut également référencer une méthode dans le admin.ModelAdmin lui-même. Modifier PersonAdmin encore:

@admin.S'inscrire(La personne)
classe PersonAdmin(admin.ModelAdmin):
    list_display = ("nom de famille", "Prénom", "show_average")

    def show_average(soi, obj):
        de django.db.models importer Moy
        résultat = Classe.objets.filtre(la personne=obj).agrégat(Moy("classe"))
        revenir résultat[[[["grade__avg"]

Dans le code ci-dessus, vous ajoutez une colonne à l'administrateur qui affiche la moyenne des notes de chaque élève. show_average () est appelé une fois pour chaque objet affiché dans la liste.

le obj paramètre est l'objet de la ligne affichée. Dans ce cas, vous l'utilisez pour interroger le correspondant Classe objets pour l'élève, avec une moyenne de réponse sur Grade.grade. Vous pouvez voir les résultats ici:

Ajouter la moyenne calculée à la liste des personnes

Gardez à l'esprit que la note moyenne doit vraiment être calculée dans le La personne objet modèle. Vous voudrez probablement les données ailleurs, pas seulement dans l'administration Django. Si vous aviez une telle méthode, vous pourriez l'ajouter au list_display attribut. L'exemple ici montre ce que vous pouvez faire dans un ModelAdmin objet, mais ce n’est probablement pas le meilleur choix pour votre code.

Par défaut, seules les colonnes qui sont des attributs d'objet peuvent être triées. show_average () n'est pas. En effet, le tri est effectué par un
sous-jacent QuerySet, pas sur les résultats affichés. Il existe des moyens de trier ces colonnes dans certains cas, mais cela dépasse le cadre de ce didacticiel.

Le titre de la colonne est basé sur le nom de la méthode. Vous pouvez modifier le titre en ajoutant un attribut à la méthode:

def show_average(soi, obj):
    résultat = Classe.objets.filtre(la personne=obj).agrégat(Moy("classe"))
    revenir résultat[[[["grade__avg"]

show_average.brève description = "La note moyenne"

Par défaut, Django vous protège du HTML dans les chaînes au cas où la chaîne proviendrait d'une entrée utilisateur. Pour que l'affichage inclue du HTML, vous devez utiliser format_html ():

def show_average(soi, obj):
    de django.utils.html importer format_html

    résultat = Classe.objets.filtre(la personne=obj).agrégat(Moy("classe"))
    revenir format_html("", résultat[[[["grade__avg"])

show_average.brève description = "Moyenne"

show_average () a maintenant un titre personnalisé, "Moyenne", et est formaté en italique:

Liste des modifications de personne avec colonne italique grasse

Malheureusement, Django n'a pas encore ajouté la prise en charge des chaînes de caractères pour format_html (), donc vous êtes coincé avec str.format () syntaxe.

Ajout de filtres à l'écran de liste

En plus de filtrer les données de la liste de modifications via l'URL d'appel, vous pouvez également filtrer avec un widget intégré. Ajouter le list_filter attribut au CourseAdmin objet dans core / admin.py:

@admin.S'inscrire(Cours)
classe CourseAdmin(admin.ModelAdmin):
    list_display = ("Nom", "an", "view_students_link")
    list_filter = ("an", )
# ...

le list_filter affichera une nouvelle section sur la page avec une liste de liens. Dans ce cas, les liens filtrent la page par année. La liste de filtres est automatiquement remplie avec le an valeurs utilisées par le Cours objets dans la base de données:

Filtrer les objets de cours par année

Cliquer sur une année sur le côté droit changera la liste pour inclure uniquement Cours objets avec ça an valeur. Vous pouvez également filtrer en fonction des attributs des objets associés à l'aide du __ syntaxe de recherche de champ. Par exemple, vous pouvez filtrer GradeAdmin objets par cours__year, montrant le Classe objets pour une seule année de cours.

Si vous souhaitez mieux contrôler votre filtrage, vous pouvez même créer objets de filtre qui spécifient les attributs de recherche et les QuerySet.

Ajout de la recherche à l'écran de liste

Les filtres ne sont pas le seul moyen de réduire la quantité de données à l’écran. L'administrateur de Django prend également en charge la recherche dans champs_recherche option, qui ajoute un Barre de recherche à l'écran. Vous le définissez avec un tuple contenant les noms des champs à utiliser pour construire une requête de recherche dans la base de données.

Tout ce que l'utilisateur tape dans la zone de recherche est utilisé dans un OU clause des champs filtrant le QuerySet. Par défaut, chaque paramètre de recherche est entouré de % signes, c'est-à-dire si vous recherchez r, puis n'importe quel mot avec un r l'intérieur apparaîtra dans les résultats. Vous pouvez être plus précis en spécifiant un __ modificateur dans le champ de recherche.

Modifier le PersonAdmin dans core / admin.py comme suit:

@admin.S'inscrire(La personne)
classe PersonAdmin(admin.ModelAdmin):
    champs_recherche = ("last_name__startswith", )

Dans le code ci-dessus, la recherche est basée sur le nom de famille. le __commence avec Le modificateur limite la recherche aux noms commençant par le paramètre de recherche. Recherche sur R fournit les résultats suivants:

Ajouter la recherche à la liste des personnes

Chaque fois qu'une recherche est effectuée sur une page de liste de modifications, l'administrateur Django appelle votre admin.ModelAdmin objets get_search_results () méthode. Il renvoie un QuerySet avec les résultats de la recherche. Vous pouvez affiner les recherches en surchargeant la méthode et en modifiant le QuerySet. Plus de détails peuvent être trouvés dans la documentation.

Modification de la manière dont les modèles sont modifiés

Vous pouvez personnaliser plus que la page de la liste des modifications. Les écrans utilisés pour ajouter ou modifier un objet sont basés sur un ModelForm. Django génère automatiquement le formulaire en fonction du modèle en cours d'édition.

Vous pouvez contrôler quels champs sont inclus, ainsi que leur ordre, en modifiant le des champs option. Modifiez votre PersonAdmin objet, ajout d'un des champs attribut:

@admin.S'inscrire(La personne)
classe PersonAdmin(admin.ModelAdmin):
    des champs = ("Prénom", "nom de famille", "cours")
# ...

Les pages Ajouter et Modifier pour La personne maintenant mettez le Prénom attribut avant le nom de famille attribut même si le modèle lui-même spécifie l'inverse:

Utilisez l'attribut "admin.AdminModels.fields" pour modifier les champs affichés

ModelAdmin.get_form () est responsable de la création du ModelForm pour votre objet. Vous pouvez remplacer cette méthode pour modifier le formulaire. Ajoutez la méthode suivante à PersonAdmin:

def get_form(soi, demande, obj=Aucun, **kwargs):
    forme = super().get_form(demande, obj, **kwargs)
    forme.base_fields[[[["Prénom"].étiquette = "Prénom (humains uniquement!):"
    revenir forme

Désormais, lorsque la page Ajouter ou Modifier s'affiche, le libellé du Prénom le champ sera personnalisé.

Changer l'étiquette pourrait ne pas être suffisant pour empêcher les vampires de s'inscrire en tant qu'étudiants. Si vous n'aimez pas le ModelForm que l'administrateur Django a créé pour vous, vous pouvez alors utiliser le forme attribut pour enregistrer un formulaire personnalisé. Apportez les ajouts et modifications suivants à core / admin.py:

de Django importer formes

classe PersonAdminForm(formes.ModelForm):
    classe Meta:
        modèle = La personne
        des champs = "__tout__"

    def clean_first_name(soi):
        si soi.clean_data[[[["Prénom"] == "Pointe":
            élever formes.Erreur de validation("Pas de vampires")

        revenir soi.clean_data[[[["Prénom"]

@admin.S'inscrire(La personne)
classe PersonAdmin(admin.ModelAdmin):
    forme = PersonAdminForm
# ...

Le code ci-dessus impose une validation supplémentaire sur le La personne Ajouter et modifier des pages. ModelForm les objets ont un mécanisme de validation riche. Dans ce cas, le Prénom le champ est vérifié par rapport au nom "Pointe". UNE Erreur de validation empêche les étudiants portant ce nom de s'inscrire:

Validation supplémentaire en modifiant le ModelForm

En changeant ou en remplaçant le ModelForm objet, vous pouvez contrôler entièrement l'apparence et la validation des pages que vous utilisez pour ajouter ou modifier des pages d'objets.

Remplacer les modèles d'administration Django

Les développeurs Django ont implémenté l'administrateur en utilisant le mécanisme de template Django. Cela a rendu leur travail un peu plus facile, mais cela vous profite également en vous permettant de passer outre les modèles. Vous pouvez entièrement personnaliser l'administrateur en modifiant les modèles utilisés pour rendre les pages.

Vous pouvez voir tous les modèles utilisés dans l'administrateur en regardant à l'intérieur du package Django dans votre environnement virtuel:

... / site-packages / django / contrib / admin / templates /
│
├── admin /
│ │
│ ├── auth /
│ │ └── utilisateur /
│ │ ├── add_form.html
│ │ └── change_password.html
│ │
│ ├── edit_inline /
│ │ ├── stacked.html
│ │ └── tabular.html
│ │
│ ├── comprend /
│ │ ├── fieldset.html
│ │ └── object_delete_summary.html
│ │
│ ├── widgets /
│ │ ├── clearable_file_input.html
│ │ ├── Foreign_key_raw_id.html
│ │ ├── many_to_many_raw_id.html
│ │ ├── radio.html
│ │ ├── related_widget_wrapper.html
│ │ ├── split_datetime.html
│ │ └── url.html
│ │
│ ├── 404.html
│ ├── 500.html
│ ├── actions.html
│ ├── app_index.html
│ ├── base.html
│ ├── base_site.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
│ ├── delete_selected_confirmation.html
│ ├── filter.html
│ ├── index.html
│ ├── invalid_setup.html
│ ├── login.html
│ ├── object_history.html
│ ├── pagination.html
│ ├── popup_response.html
│ ├── prepopulated_fields_js.html
│ ├── search_form.html
│ └── submit_line.html
│
└── inscription /
    ├── connecté_out.html
    ├── password_change_done.html
    ├── password_change_form.html
    ├── password_reset_complete.html
    ├── password_reset_confirm.html
    ├── password_reset_done.html
    ├── password_reset_email.html
    └── password_reset_form.html

Le moteur de template Django a un ordre défini pour le chargement des templates. Lorsqu'il charge un modèle, il utilise le premier modèle qui correspond au nom. Vous pouvez remplacer les modèles d'administration en utilisant la même structure de répertoires et les mêmes noms de fichier.

Les modèles d'administration sont disponibles dans deux répertoires:

  1. admin est pour les pages d'objets de modèle.
  2. enregistrement est pour les changements de mot de passe et la connexion et la déconnexion.

Pour personnaliser la page de déconnexion, vous devez remplacer le bon fichier. Le chemin relatif menant au fichier doit être le même que celui en cours de remplacement. Le fichier qui vous intéresse est registration / log_out.html. Commencez par créer le répertoire dans le École projet:

$ mkdir -p modèles / enregistrement

Parlez maintenant à Django de votre nouveau répertoire de modèles dans votre École / settings.py fichier. Cherchez le MODÈLES directive et ajoutez le dossier au DIR liste:

# École / settings.py
# ...

MODÈLES = [[[[
    
        "BACKEND": "django.template.backends.django.DjangoTemplates",

        # Ajoutez le répertoire des modèles à l'option DIR:
        "DIRS": [[[[os.chemin.joindre(BASE_DIR, "modèles"), ],
        "APP_DIRS": Vrai,
        "OPTIONS": 
            "processeurs_contexte": [[[[
                "django.template.context_processors.debug",
                "django.template.context_processors.request",
                "django.contrib.auth.context_processors.auth",
                "django.contrib.messages.context_processors.messages",
            ],
        ,
    ,
]

Le moteur de modèle recherche les répertoires dans DIR option avant les répertoires d'application, donc tout ce qui porte le même nom qu'un modèle d'administration sera chargé à la place. Pour voir cela en action, copiez le log_out.html fichier dans votre modèles / inscription répertoire, puis modifiez-le:

% étend "admin / base_site.html" %
% charge i18n %

% bloquer chapelure %<div classe="chapelure"> <une href="% URL 'admin: index' %">% trans 'Accueil' %</une> </div>% bloc d'extrémité %

% bloquer contenu %

<p>Vous quittez maintenant Sunnydale</p>

<p> <une href="% URL 'admin: index' %">% trans 'Connectez-vous à nouveau' %</une> </p>

% bloc d'extrémité %

Vous avez maintenant personnalisé la page de déconnexion. Si vous cliquez sur SE DÉCONNECTER, puis vous verrez le message personnalisé:

Personnaliser les modèles d'administration Django

Les modèles d'administration Django sont profondément imbriqués et pas très intuitifs, mais vous avez un contrôle total sur leur présentation si vous en avez besoin. Certains packages, notamment Grappelli et Django Admin Bootstrap, ont entièrement remplacé les modèles d'administration Django pour changer leur apparence.

Django Admin Bootstrap n'est pas encore compatible avec Django 3, et Grappelli n'a ajouté que récemment la prise en charge, il peut donc toujours avoir des problèmes. Cela étant dit, si vous voulez voir le pouvoir de remplacer les modèles d'administrateur, consultez ces projets!

Conclusion

L'administrateur Django est un puissant outil intégré qui vous permet de créer, mettre à jour et supprimer des objets dans votre base de données à l'aide d'une interface Web. Vous pouvez personnaliser l'admin Django pour faire presque tout ce que vous voulez.

Dans ce didacticiel, vous avez appris à:

  • Enregistrez votre modèles d'objets avec l'administrateur Django
  • Ajoutez des attributs en tant que colonnes dans le modifier la liste
  • Créer des valeurs de colonne avec contenu calculé
  • Références croisées pages d'administration via des liens
  • Filtrer la page de la liste des modifications sur chaînes de requête
  • Faites votre liste de modifications consultable
  • Personnaliser l'automatique ModelForm objet
  • Changer le HTML dans Modèles d'administration Django

Ce tutoriel ne touche que la surface. La quantité de configuration que vous pouvez faire pour personnaliser l'administrateur Django est stupéfiante. Vous pouvez plonger plus en profondeur dans la documentation pour explorer des sujets tels que les formulaires en ligne, plusieurs admin sites, édition en masse, saisie semi-automatique et bien plus encore. Bon codage!