Django
Templating
Recherche…
Les variables
Les variables que vous avez fournies dans votre contexte de vue peuvent être accédées en utilisant la notation à double accolade:
Dans vos views.py :
class UserView(TemplateView):
""" Supply the request user object to the template """
template_name = "user.html"
def get_context_data(self, **kwargs):
context = super(UserView, self).get_context_data(**kwargs)
context.update(user=self.request.user)
return context
Dans user.html :
<h1>{{ user.username }}</h1>
<div class="email">{{ user.email }}</div>
La notation par points aura accès à:
- propriétés de l'objet, par exemple
user.usernamesera{{ user.username }} - les recherches dans les dictionnaires, par exemple
request.GET["search"]sera{{ request.GET.search }} - les méthodes sans arguments, par exemple
users.count()seront{{ user.count }}
Les variables de modèle ne peuvent pas accéder aux méthodes qui prennent des arguments.
Les variables peuvent également être testées et mises en boucle:
{% if user.is_authenticated %}
{% for item in menu %}
<li><a href="{{ item.url }}">{{ item.name }}</a></li>
{% endfor %}
{% else %}
<li><a href="{% url 'login' %}">Login</a>
{% endif %}
On accède aux URL en utilisant le format {% url 'name' %} , où les noms correspondent aux noms de vos urls.py
{% url 'login' %} - Rendra probablement sous /accounts/login/
{% url 'user_profile' user.id %} - Les arguments pour les URL sont fournis dans l'ordre
{% url next %} - Les URL peuvent être des variables
Templating in Class Views Vues
Vous pouvez transmettre des données à un modèle dans une variable personnalisée.
Dans vos views.py :
from django.views.generic import TemplateView
from MyProject.myapp.models import Item
class ItemView(TemplateView):
template_name = "item.html"
def items(self):
""" Get all Items """
return Item.objects.all()
def certain_items(self):
""" Get certain Items """
return Item.objects.filter(model_field="certain")
def categories(self):
""" Get categories related to this Item """
return Item.objects.get(slug=self.kwargs['slug']).categories.all()
Une simple liste dans votre item.html :
{% for item in view.items %}
<ul>
<li>{{ item }}</li>
</ul>
{% endfor %}
Vous pouvez également récupérer des propriétés supplémentaires des données.
En supposant que votre Item modèle a un champ de name :
{% for item in view.certain_items %}
<ul>
<li>{{ item.name }}</li>
</ul>
{% endfor %}
Création de modèles dans les vues basées sur les fonctions
Vous pouvez utiliser un modèle dans une vue basée sur les fonctions comme suit:
from django.shortcuts import render
def view(request):
return render(request, "template.html")
Si vous souhaitez utiliser des variables de modèle, vous pouvez le faire comme suit:
from django.shortcuts import render
def view(request):
context = {"var1": True, "var2": "foo"}
return render(request, "template.html", context=context)
Ensuite, dans template.html , vous pouvez vous référer à vos variables comme suit:
<html>
{% if var1 %}
<h1>{{ var2 }}</h1>
{% endif %}
</html>
Filtres de modèle
Le système de gabarit de Django comporte des balises et des filtres intégrés, qui sont des fonctions à l’intérieur d’un modèle pour rendre le contenu de manière spécifique. Plusieurs filtres peuvent être spécifiés avec des tubes et les filtres peuvent avoir des arguments, comme dans la syntaxe des variables.
{{ "MAINROAD 3222"|lower }} # mainroad 3222
{{ 10|add:15}} # 25
{{ "super"|add:"glue" }} # superglue
{{ "A7"|add:"00" }} # A700
{{ myDate | date:"D d M Y"}} # Wed 20 Jul 2016
Une liste des filtres intégrés disponibles est disponible à l' adresse https://docs.djangoproject.com/en/dev/ref/templates/builtins/#ref-templates-builtins-filters .
Création de filtres personnalisés
Pour ajouter vos propres filtres de modèle, créez un dossier nommé templatetags dans le dossier de votre application. Ajoutez ensuite un __init__.py et le fichier contenant les filtres:
#/myapp/templatetags/filters.py
from django import template
register = template.Library()
@register.filter(name='tostring')
def to_string(value):
return str(value)
Pour utiliser le filtre, vous devez le charger dans votre modèle:
#templates/mytemplate.html
{% load filters %}
{% if customer_id|tostring = customer %} Welcome back {% endif%}
Des trucs
Même si les filtres semblent simples au début, cela permet de faire des choses astucieuses:
{% for x in ""|ljust:"20" %}Hello World!{% endfor %} # Hello World!Hello World!Hel...
{{ user.name.split|join:"_" }} ## replaces whitespace with '_'
Voir aussi les balises de modèle pour plus d'informations.
Empêcher les méthodes sensibles d'être appelées dans des modèles
Lorsqu'un objet est exposé au contexte du modèle, ses méthodes sans arguments sont disponibles. Ceci est utile lorsque ces fonctions sont des "getters". Mais cela peut être dangereux si ces méthodes modifient certaines données ou ont des effets secondaires. Même si vous faites probablement confiance à l'auteur du modèle, il peut ne pas être conscient des effets secondaires d'une fonction ou penser à appeler le mauvais attribut par erreur.
Vu le modèle suivant:
class Foobar(models.Model):
points_credit = models.IntegerField()
def credit_points(self, nb_points=1):
"""Credit points and return the new points credit value."""
self.points_credit = F('points_credit') + nb_points
self.save(update_fields=['points_credit'])
return self.points_credit
Si vous écrivez ceci, par erreur, dans un modèle:
You have {{ foobar.credit_points }} points!
Cela augmentera le nombre de points à chaque appel du modèle. Et vous ne le remarquerez peut-être même pas.
Pour éviter cela, vous devez définir l'attribut alters_data sur True pour les méthodes qui ont des effets secondaires. Cela rendra impossible de les appeler à partir d'un modèle.
def credit_points(self, nb_points=1):
"""Credit points and return the new points credit value."""
self.points_credit = F('points_credit') + nb_points
self.save(update_fields=['points_credit'])
return self.points_credit
credit_points.alters_data = True
Utilisation de {% extend%}, {% include%} et {% blocks%}
résumé
{% extend%} : cela déclare le modèle donné comme argument en tant que parent du modèle en cours. Utilisation:
{% extends 'parent_template.html' %}.{% block%} {% endblock%} : Ceci est utilisé pour définir des sections dans vos modèles, de sorte que si un autre modèle étend celui-ci, il pourra remplacer le code HTML qui a été écrit à l'intérieur. Les blocs sont identifiés par leur nom. Utilisation:
{% block content %} <html_code> {% endblock %}.{% include%} : cela insérera un modèle dans le modèle actuel. Sachez que le modèle inclus recevra le contexte de la requête et vous pourrez également lui attribuer des variables personnalisées. Utilisation de base:
{% include 'template_name.html' %}, utilisation avec des variables:{% include 'template_name.html' with variable='value' variable2=8 %}
Guider
Supposons que vous construisiez votre code côté frontal avec des dispositions communes pour tout le code et que vous ne souhaitiez pas répéter le code pour chaque modèle. Django vous offre des balises construites pour cela.
Supposons que nous ayons un site Web de blog ayant 3 modèles qui partagent la même mise en page:
project_directory
..
templates
front-page.html
blogs.html
blog-detail.html
1) Définir le fichier base.html ,
<html>
<head>
</head>
<body>
{% block content %}
{% endblock %}
</body>
</html>
2) blog.html dans blog.html comme,
{% extends 'base.html' %}
{% block content %}
# write your blog related code here
{% endblock %}
# None of the code written here will be added to the template
Ici, nous avons étendu la disposition de base afin que sa mise en page HTML soit maintenant disponible dans le blog.html blog.html. Le concept de { % block %} est un héritage de modèle qui vous permet de créer un modèle de base contenant tous les éléments site et définit les blocs que les modèles enfants peuvent remplacer.
3) Supposons maintenant que tous vos 3 modèles aient le même code HTML, ce qui définit certains articles populaires. Au lieu d'être écrits, les 3 fois créent un nouveau modèle posts.html .
blog.html
{% extends 'base.html' %}
{% block content %}
# write your blog related code here
{% include 'posts.html' %} # includes posts.html in blog.html file without passing any data
<!-- or -->
{% include 'posts.html' with posts=postdata %} # includes posts.html in blog.html file with passing posts data which is context of view function returns.
{% endblock %}