Comment remplacer et étendre la base de Django admin modèles?

Comment remplacer un modèle d'administrateur (par ex. admin/index.html) alors que dans le même temps, l'extension (voir https://docs.djangoproject.com/en/dev/ref/contrib/admin/#overriding-vs-replacing-an-admin-template)?

Premier - je sais que cette question a été posée et répondue avant (voir Django: le remplacement ET l'extension d'un modèle d'application), mais comme la réponse dit que ce n'est pas directement applicable si vous êtes à l'aide de la app_directories modèle de chargeur (qui est la plupart du temps).

Ma solution actuelle est de faire des copies et de les étendre au lieu de l'extension directement depuis l'admin de modèles. Cela fonctionne très bien mais c'est vraiment déroutant et ajoute un surcroît de travail quand l'admin modèles de changement.

Il pourrait penser à une coutume de prolongation de balise pour les modèles mais je ne veux pas réinventer la roue si il existe déjà une solution.

Sur une note de côté: Est-ce que quelqu'un sait si ce problème sera abordé par Django lui-même?

Copier les modèles d'administrateur, en les étendant et en remplaçant/ajout d'un bloc est le plus efficace, bien que non optimale des flux de travail compte tenu de l'état actuel de Django. Je n'ai pas vu d'autre moyen de faire ce que vous essayez de le faire en trois ans de travail avec elle 🙂
Bien je ne sais pas si c'est une bonne chose ou pas, mais au moins les gens comme vous sont venus à la même conclusion. C'est bon à entendre. 🙂

InformationsquelleAutor Semmel | 2011-07-05

97

Mise à jour:

Lisez la documentation de votre version de Django. par exemple,

https://docs.djangoproject.com/en/1.11/ref/contrib/admin/#admin-overriding-templates
https://docs.djangoproject.com/en/2.0/ref/contrib/admin/#admin-overriding-templates

Réponse originale à cette question à partir de 2011:

J'ai eu le même problème à propos d'un an et demi et j'ai trouvé un joli modèle de chargeur sur djangosnippets.org qui rend ce facile. Il vous permet d'étendre un modèle dans une application spécifique, vous donnant la possibilité de créer votre propre admin/index.html qui s'étend de la admin/index.html modèle de l'administrateur de l'application. Comme ceci:
```
{% extends "admin:admin/index.html" %}

{% block sidebar %}
    {{block.super}}
    <div>
        <h1>Extra links</h1>
        <a href="/admin/extra/">My extra link</a>
    </div>
{% endblock %}
```
Je vous ai donné un exemple complet sur la façon d'utiliser ce modèle de chargeur dans un post de blog sur mon site.
- Pour la référence; l'extrait en question a été converti en un django app, et est disponible dans PyPi (pip/easy_install) que django-apptemplates: pypi.python.org/pypi/django-apptemplates
- Juste pour être sur à 100% explicites: la solution ci-dessus NE fonctionne PLUS pour les versions récentes de Django (au moins 1,4), que l'une des fonctions du script utilise est amorti. Vous pouvez trouver les sources mises à jour sur ici
- Notez qu'avec Django 1.8 ce sera encore du travail, mais le programme d'installation doit être faite d'une manière spéciale (voir app_namespace.Chargeur de configuration à titre d'exemple). django-application-noms-modèle-chargeur est aussi une alternative à django-apptemplates si il peut cesser de fonctionner un jour.
InformationsquelleAutor heyman
67

Comme pour Django 1.8 être la version actuelle, il n'y a pas besoin de lien copiez le admin/templates dossier de votre projet, ou installer des middlewares comme suggéré par les réponses ci-dessus. Voici quoi faire:
1. créer l'arbre suivant la structure(recommandé par le la documentation officielle)
```
your_project
     |-- your_project/
     |-- myapp/
     |-- templates/
          |-- admin/
              |-- myapp/
                  |-- change_form.html  <- do not misspell this
```
Note: L'emplacement de ce fichier n'est pas important. Vous pouvez mettre à l'intérieur de votre application et il faudra encore travailler. Tant que son emplacement peut être découvert par django. Ce qui est plus important, c'est le nom d'un fichier HTML doit être le même que l'original de nom de fichier HTML fourni par django.
1. Ajouter ce modèle de chemin d'accès à votre settings.py:
```
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')], # <- add this line
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]
```
2. Identifier le nom et le bloc que vous souhaitez remplacer. Ceci est fait par la recherche dans django admin/répertoire des modèles. Je suis à l'aide de virtualenv, donc pour moi, le chemin est ici:
```
~/.virtualenvs/edge/lib/python2.7/site-packages/django/contrib/admin/templates/admin
```
Dans cet exemple, je veux modifier la page ajouter un formulaire utilisateur. Le modèle responsiblve de ce point de vue est change_form.html. Ouvrir le change_form.html et de trouver le {% block %} que vous souhaitez étendre.
1. Dans votre change_form.html, écrire des choses comme ceci:
```
{% extends "admin/change_form.html" %}
{% block field_sets %}
     {# your modification here #}
{% endblock %}
```
2. De chargement de votre page et vous devriez voir les changements
- Il n'est pas encore assez pour étendre les principaux "index.html" modèle, sans copier tous les blocs. Une solution consiste à écrire des ../ à "exetends" chemin d'accès et de spécifier le chemin d'origine plus unique {% extends "../../admin/templates/admin/index.html" %}. lien vers la réponse
- Je pense que dans les MODÈLES que nous devrions être à l'aide de 'DIR': [os.chemin d'accès.join(BASE_DIR, "templates")],
- C'est le type de fil qui illustre parfaitement la faille dans la. Un cadre sera mis à jour et la question n'est plus d'actualité, c'est en fait un moyen de dissuasion dans la bonne voie. Grande réponse ici. RTFM enfants.
- Merci pour cette réponse. À l'exception de "L'emplacement de ce fichier n'est pas important.", tout fonctionnait très bien.
InformationsquelleAutor Cheng
47

si vous avez besoin de remplacer le admin/index.html, vous pouvez définir la index_template paramètre de la AdminSite.

par exemple
```
# urls.py
...
from django.contrib import admin

admin.site.index_template = 'admin/my_custom_index.html'
admin.autodiscover()
```
et le lieu de votre modèle dans <appname>/templates/admin/my_custom_index.html
- Génial! Cela vous permet de faire {% extends "admin/index.html" %} de my_custom_index.html et pour que la référence à la django admin modèle sans le copier. Je vous remercie.
- devrait marquer ce que la bonne réponse, puisque c'est l'approche la plus simple qui utilise intégré dans django caractéristiques et ne nécessite pas l'aide personnalisée chargeurs de modèle.
InformationsquelleAutor gingerlime
16

Avec django 1.5 (au moins), vous pouvez définir le modèle que vous souhaitez utiliser pour un particulier modeladmin

voir https://docs.djangoproject.com/en/1.5/ref/contrib/admin/#custom-template-options

Vous pouvez faire quelque chose comme
```
class Myadmin(admin.ModelAdmin):
    change_form_template = 'change_form.htm'
```
Avec change_form.html d'être un simple modèle html étendre admin/change_form.html (ou pas si vous voulez le faire à partir de zéro)

InformationsquelleAutor maazza
7

Chengs réponse est bonne, howewer selon les documents admin pas chaque modèle d'administrateur peut être écrasée de cette façon:
https://docs.djangoproject.com/en/1.9/ref/contrib/admin/#overriding-admin-templates
Des modèles qui peuvent être remplacées par application ou d'un modèle

Pas à chaque modèle dans contrib/admin/templates/admin peuvent être remplacées
par application ou par modèle. Les suivantes:
```
app_index.html
change_form.html
change_list.html
delete_confirmation.html
object_history.html
```
Pour ceux des modèles qui ne peut pas être remplacée de cette façon, vous pouvez
encore les écraser pour l'ensemble de votre projet. Juste place la nouvelle
version dans votre templates/admin répertoire. Ceci est particulièrement utile
pour créer des 404 et 500 pages
J'ai dû remplacer le login.html de l'administration et, par conséquent, devait mettre le écrasées modèle dans cette structure de dossier:
```
your_project
 |-- your_project/
 |-- myapp/
 |-- templates/
      |-- admin/
          |-- login.html  <- do not misspell this
```
(sans le myapp sous-dossier dans l'admin)
Je n'ai pas assez repution pour commenter Cheng du post c'est pourquoi j'ai dû écrire cela comme une nouvelle réponse.
- Merci pour les commentaires hyneker j'espère que ma réponse est plus claire et plus directement à l'essentiel maintenant.
- Oui, il est utile de savoir que les modèles peuvent être personnalisés au niveau du projet, même si certains d'entre eux peuvent être modifiés en option au niveau de l'application.
InformationsquelleAutor matyas
5

La meilleure façon de le faire est de mettre le Django admin modèles à l'intérieur de votre projet. Si vos modèles serait en templates/admin tandis que le stock de Django admin modèles serait de dire template/django_admin. Ensuite, vous pouvez faire quelque chose comme ce qui suit:

templates/admin/change_form.html
```
{% extends 'django_admin/change_form.html' %}

Your stuff here
```
Si vous êtes inquiet au sujet de garder le stock des modèles jusqu'à date, vous pouvez les inclure avec svn externes ou similaire.
- Utilisation de svn alias est une excellente idée. Le problème ce présente, c'est que tous mes traducteurs à traduire tous ces modèles (parce que makemessages permettra de recueillir les chaînes de traduction de tous les modèles d'administration) qui ajoute beaucoup de travail supplémentaire si vous travaillez avec plusieurs langues. Peut-être il ya un moyen d'exclure les modèles de makemessages?
- Utiliser le --ignore argument avec makemessages. Voir: docs.djangoproject.com/en/dev/ref/django-admin/#makemessages
- Je pense que la réponse correspond à mon besoin de mieux. Mais j'aime votre solution et pense que c'est une bonne alternative si vous ne voulez pas vous amuser avec vos chargeurs de modèle.
InformationsquelleAutor Chris Pratt
2

Je ne pouvais pas trouver une seule réponse ou une section officielle de Django docs qui avait tous les informations dont j'avais besoin pour remplacer/prolonger l'admin par défaut des modèles, donc j'écris cette réponse comme un guide complet, en espérant qu'il serait utile pour les autres dans le futur.

En supposant que la norme de Django structure de projet:
```
mysite-container/         # project container directory
    manage.py
    mysite/               # project package
        __init__.py
        admin.py
        apps.py
        settings.py
        urls.py
        wsgi.py
    app1/
    app2/
    ...
    static/
    templates/
```
Voici ce que vous devez faire:
1. Dans mysite/admin.py, créez une sous-classe de AdminSite:
```
from django.contrib.admin import AdminSite


class CustomAdminSite(AdminSite):
    # set values for `site_header`, `site_title`, `index_title` etc.
    site_header = 'Custom Admin Site'
    ...

    # extend /override admin views, such as `index()`
    def index(self, request, extra_context=None):
        extra_context = extra_context or {}

        # do whatever you want to do and save the values in `extra_context`
        extra_context['world'] = 'Earth'

        return super(CustomAdminSite, self).index(request, extra_context)


custom_admin_site = CustomAdminSite()
```
  Assurez-vous d'importer custom_admin_site dans le admin.py de vos applications et d'enregistrer vos modèles pour les afficher sur votre personnalisé admin du site (si vous voulez).
2. Dans mysite/apps.py, créez une sous-classe de AdminConfig et définir default_site à admin.CustomAdminSite de l'étape précédente:
```
from django.contrib.admin.apps import AdminConfig


class CustomAdminConfig(AdminConfig):
    default_site = 'admin.CustomAdminSite'
```
3. Dans mysite/settings.py, remplacer django.admin.site dans INSTALLED_APPS avec apps.CustomAdminConfig (personnalisé de votre admin app config à partir de l'étape précédente).
4. Dans mysite/urls.py, remplacer admin.site.urls de l'administrateur de l'URL de custom_admin_site.urls
```
from .admin import custom_admin_site


urlpatterns = [
    ...
    path('admin/', custom_admin_site.urls),
    # for Django 1.x versions: url(r'^admin/', include(custom_admin_site.urls)),
    ...
]
```
5. Créer le modèle que vous souhaitez modifier dans votre templates répertoire, le maintien de la valeur par défaut de Django admin modèles de structure de répertoire spécifié dans le docs. Par exemple, si vous avez été la modification de admin/index.html, créez le fichier templates/admin/index.html.
  
  Tous les modèles existants peuvent être modifiés de cette façon, et leurs noms et les structures peuvent être trouvés dans Django du code source.
6. Maintenant, vous pouvez soit remplacer le modèle par écrit à partir de zéro ou de l'agrandir, puis remplacer/extension des blocs spécifiques.
  
  Par exemple, si vous vouliez garder tout aussi-est, mais qui voulaient remplacer les content bloc (qui sur la page d'index répertorie les applications et leurs modèles que vous avez enregistrée), ajoutez les lignes suivantes à templates/admin/index.html:
```
{% extends 'admin/index.html' %}

{% block content %}
  <h1>
    Hello, {{ world }}!
  </h1>
{% endblock %}
```
  De préserver le contenu original d'un bloc, ajouter {{ block.super }} où vous le souhaitez le contenu d'origine à afficher:
```
{% extends 'admin/index.html' %}

{% block content %}
  <h1>
    Hello, {{ world }}!
  </h1>
  {{ block.super }}
{% endblock %}
```
  Vous pouvez également ajouter des styles et des scripts en modifiant la extrastyle et extrahead blocs.
InformationsquelleAutor Faheel Ahmad
1

Je suis d'accord avec Chris Pratt. Mais je pense qu'il est préférable de créer le lien symbolique à l'origine de Django dossier où les modèles d'administration lieu:
```
ln -s /usr/local/lib/python2.7/dist-packages/django/contrib/admin/templates/admin/ templates/django_admin
```
et comme vous pouvez le voir, il dépend de la version de python et le dossier où le Django installé. Donc, à l'avenir, ou sur un serveur de production, vous devez modifier le chemin d'accès.

InformationsquelleAutor James May
0

Ce site avait une solution simple qui a travaillé avec mon Django 1.7 configuration.

PREMIÈRE: Faire un lien symbolique nommé admin_src dans votre projet de modèle/répertoire de votre installation de Django modèles. Pour moi sur Dreamhost à l'aide d'un virtualenv, ma "source" Django admin modèles sont:
```
~/virtualenvs/mydomain/lib/python2.7/site-packages/django/contrib/admin/templates/admin
```
DEUXIÈME: Créer un admin - répertoire dans le répertoire templates/

Donc, mon projet de modèle/répertoire ressemblait maintenant à ceci:
```
/templates/
   admin
   admin_src -> [to django source]
   base.html
   index.html
   sitemap.xml
   etc...
```
TROISIÈME: Dans votre nouveau modèle/admin/répertoire créer un base.html un fichier avec le contenu:
```
{% extends "admin_src/base.html" %}

{% block extrahead %}
<link rel='shortcut icon' href='{{ STATIC_URL }}img/favicon-admin.ico' />
{% endblock %}
```
QUATRIÈME: Ajouter votre admin favicon-admin.ico dans votre racine statique dossier img.

Fait. Facile.

InformationsquelleAutor mitchf
0

Vous pouvez utiliser django-overextends, qui prévoit la circulaire de l'héritage de template de Django.

Il s'agit de la Mezzanine de la CMS, d'où Stephen extrait en autonome Django extension.

Plus d'infos que vous trouverez dans "Substitution vs l'Extension des Modèles" (http:/mezzanine.jupo.org/docs/content-architecture.html#overriding-vs-extending-templates) à l'intérieur de la Mezzanine docs.

Pour les plus profondes entrailles de regarder Stephens Blog "Circulaire de l'Héritage de Template de Django" (http:/blog.jupo.org/2012/05/17/circular-template-inheritance-for-django).

Et dans Google Groupes de discussion (https:/groups.google.com/forum/#!topic/mezzanine-utilisateurs/sUydcf_IZkQ), qui a commencé le développement de cette fonctionnalité.

Remarque:

Je n'ai pas la réputation d'ajouter plus de 2 liens. Mais je pense que les liens fournir d'intéressantes informations d'arrière-plan. Donc j'ai juste à gauche une barre oblique après "le protocole http(s):". Peut-être quelqu'un avec une meilleure réputation peut réparer les liens et supprimer cette note.

InformationsquelleAutor Henri Hulski
0

pour l'application de l'indice ajoutez cette ligne à quelque part commune de py fichier comme url.py
```
admin.site.index_template = 'admin/custom_index.html'
```
pour l'application du module index : ajoutez cette ligne à admin.py
```
admin.AdminSite.app_index_template = "servers/servers-home.html"
```
pour changer de liste : ajoutez cette ligne à l'admin catégorie:
```
change_list_template = "servers/servers_changelist.html"
```
pour l'application du module de modèle de formulaire : ajoutez cette ligne à votre administrateur de classe
```
change_form_template = "servers/server_changeform.html"
```
etc. et trouver d'autres dans le même admin du module classes

InformationsquelleAutor Saurabh Chandra Patel

Vous devez vous connecter pour publier un commentaire.