Personnaliser l'administrateur Django avec Python – Real Python

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:

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:

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:

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:

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:

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.

[[[[
    
        "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
        
    
]

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

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:

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:

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:

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.

Fournir des liens vers d'autres pages d'objets

Il est assez courant que les objets référencent d’autres objets en utilisant clés étrangères. Vous pouvez pointer list_display à une méthode qui renvoie un lien HTML. À l'intérieur core / admin.py, modifier le CourseAdmin classe comme suit:

de django.urls importer inverser
de django.utils.http importer urlencode

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

    def view_students_link(soi, obj):
        compter = obj.person_set.compter()
        URL = (
            inverser("admin: core_person_changelist")
            + "?"
            + urlencode(F"courses__id =obj.id")
        )
        revenir format_html('<a href = "">    Étudiants', URL, compter)

    view_students_link.brève description = "Étudiants"

Ce code provoque le Cours modifier la liste pour avoir trois colonnes:

1. Le nom du cours
2. L'année au cours de laquelle le cours a été offert
3. Un lien affichant le nombre d'étudiants dans le cours

Vous pouvez voir le changement résultant dans la capture d'écran suivante:

Lorsque vous cliquez 2 étudiants, il vous emmène au La personne modifier la page de la liste avec un filtre appliqué. La page filtrée n'affiche que les élèves de Psych 101, Buffy et Willow. Xander n’est pas arrivé à l’université.

L'exemple de code utilise inverser() pour rechercher une URL dans l'admin Django. Vous pouvez rechercher n'importe quelle page d'administration en utilisant la convention de dénomination suivante:

"admin:%(applications_%(des modèles_%(page)"

Cette structure de nom se décompose comme suit:

• administrateur: est l'espace de noms.
• app est le nom de l'application.
• modèle est l'objet modèle.
• page est le type de page d'administration Django.

Pour le view_students_link () exemple ci-dessus, vous utilisez admin: core_person_changelist pour obtenir une référence à la page de la liste des modifications du La personne objet dans le coeur app.

Voici les noms d'URL disponibles:

Vous pouvez filtrer la page de liste de modifications en ajoutant une chaîne de requête à l'URL. Cette chaîne de requête modifie le QuerySet utilisé pour remplir la page. Dans l'exemple ci-dessus, la chaîne de requête "? courses__id = obj.id" filtre le La personne lister uniquement les objets qui ont une valeur correspondante dans Cours de personne.

Ces filtres prennent en charge QuerySet recherches de champ utilisant des traits de soulignement doubles (__). Vous pouvez accéder aux attributs des objets associés et utiliser des modificateurs de filtre comme __exact et __commence avec.

Vous pouvez trouver tous les détails sur ce que vous pouvez accomplir avec le list_display attribut dans la documentation d'administration de Django.

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:

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:

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:

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:

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é:

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!