Des lecteurs comme vous aident à soutenir MUO. Lorsque vous effectuez un achat en utilisant des liens sur notre site, nous pouvons gagner une commission d'affiliation. En savoir plus.

La meilleure façon de maîtriser Django est de l'utiliser pour développer des applications full-stack. Vous rencontrerez de nombreuses fonctionnalités fascinantes lorsque vous travaillerez avec le framework. L'un d'eux est de savoir comment rendre des formulaires dans des modèles à l'aide de formulaires croustillants.

L'utilisation de django-crispy-forms est l'une des nombreuses façons de rendre des formulaires dans Django. La dépendance vous permet de créer des formulaires dans des modèles sans écrire de code HTML. Vous pouvez facilement créer des mises en page réutilisables sans avoir à écrire de code de formulaire.

Vous pouvez en savoir plus en installant la bibliothèque, puis en la configurant et en l'utilisant pour créer un formulaire d'inscription.

Comment fonctionne django-crispy-forms

Le bibliothèque django-crispy-forms

instagram viewer
est livré avec un code HTML intégré que vous pouvez personnaliser en fonction de vos besoins. Il comprend un filtre nommé |croustillant qui rend les formulaires basés sur div dans le modèle.

Le {% croustillant %} les balises rendront les formulaires selon une configuration spécifique.django-crispy-forms fonctionne bien avec d'autres dépendances de modèles comme Bootstrap et Tailwind CSS.

Voyons comment cela fonctionne dans un modèle.

Installer les formulaires croustillants

Commence par créer un projet Django et appli. Installez ensuite la dernière version de django-crispy-forms en utilisant Pipenv avec la commande suivante :

pipenv installer django-crispy-forms

Une installation réussie ressemblera à l'image ci-dessous :

Configurez django-crispy-forms dans les paramètres

Après l'installation, vous devez enregistrer les formulaires croustillants en tant que dépendance dans les paramètres du projet. En l'enregistrant, la bibliothèque de formulaires croustillants sera disponible pour toutes les applications du projet.

Dans le projet paramètres.py fichier, ajoutez la chaîne 'crispy_forms':

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'monapp',
'formes_croustillantes',
]

Créer un formulaire

Vous devez synchroniser votre formulaire d'inscription avec le formulaire de création d'utilisateur Django intégré pour faciliter l'authentification.

L'intégré Authentification utilisateur Django système gère les exigences courantes telles que la validation des mots de passe et l'émission des autorisations.

Le système gère également la validation des formulaires pour vous. Ainsi, vous pouvez créer des formulaires sans avoir à gérer vous-même la validation. Si vous avez effectué une validation de formulaire dans d'autres frameworks, vous saurez à quel point cela peut être fastidieux. Pas avec Django.

Le module d'authentification dispose d'un Utilisateur modèle ou objet. Le Utilisateur L'objet est le composant principal du système d'authentification des utilisateurs. Il gère les autorisations, authentifie les profils des utilisateurs enregistrés, le contrôle d'accès et bien plus encore.

Le UserCreationFormUserCreationForm utilise la fonction intégrée Utilisateur s'opposer à enregistrer de nouveaux utilisateurs. Il hérite de la classe ModelForm.

Tout d'abord, importez des formulaires à partir du module de formulaire Django. Ensuite, importez le UserCreationFormUserCreationForm depuis django.contrib.auth.forms. Importez également le fichier intégré Utilisateur modèle de django.contrib.auth.models. Ensuite, importez les entrées de champ de django ModelForm.

depuis Django importer formes
depuisDjango.contrib.auth.formesimporterUserCreationFormUserCreationForm
depuisDjango.contrib.auth.des modèlesimporterUtilisateur
depuis django.forms importer ModelForm, TextInput, EmailInput, ImageField, Textarea

Ensuite, créez un objet d'enregistrement nommé RegisterUserForm. Il faut le UserCreationFormUserCreationForm comme argument. Ajouter le Utilisateur champs d'objet tels que l'authentification par e-mail, le nom d'utilisateur et deux mots de passe.

classeRegisterUserForm(UserCreationForm):
 e-mail = formulaires. EmailField (max_length=254, help_text='Requis. Entrez une adresse e-mail valide.')
classeMéta:
 modèle = Utilisateur
 champs = ('nom d'utilisateur', 'e-mail', 'mot de passe1', 'mot de passe2')

Ces champs sont les principaux attributs d'un utilisateur sur le formulaire d'inscription. Ce sont des entrées obligatoires que les utilisateurs doivent remplir pour que le système les authentifie.

Créer une fonction d'affichage

Ensuite, vous allez créer une fonction d'affichage pour le formulaire d'inscription. Tout d'abord, importez la fonction de rendu ainsi que le RegisterUserForm à partir de formulaires.py. Ensuite, importez le Utilisateur modèle de django.contrib.auth.models.

La fonction de vue nommée registre prend la RegisterUserForm. Il le rendra sur le registre.html modèle.

depuis django.raccourcis importer rendre,
depuis django.http importer HttpResponse, Http404
depuis .formes importer RegisterUserForm
depuisDjango.contrib.auth.des modèlesimporterUtilisateur
définitivementenregistrer(demande):
 form=RegisterUserForm
 contexte={'former':former}
 retour rendu (requête,'registre.html',contexte)

Créer un chemin d'URL

Créer un chemin d'URL pour le registre.html modèle. Cette URL est le chemin de la fonction d'affichage que vous venez de créer. Donnez-lui le nom enregistrer, vous pouvez donc utiliser le nom pour l'appeler sur un modèle.

depuis django.urls importer chemin
depuis. importer vues
modèles d'url=[
 chemin ('enregistrer', vues.register, nom='enregistrer'),
]

Charger sur un modèle

Maintenant que vous avez la vue et le chemin de l'URL, vous pouvez créer le registre.html modèle dans le dossier de l'application. Vous utiliserez django-crispy-forms pour rendre le RegisterUserForm.

Dans le registre.html modèle, étendez le base.html. Le base.html contient le Liens d'amorçage vous utiliserez pour styliser le formulaire d'inscription. Chargez ensuite les django-crispy-forms avec le register.html en utilisant les balises de modèle.

{% s'étend 'base.html' %}
{% charge crispy_forms_tags %}
{% bloque le contenu %}
<classe div="récipient" style="">
<classe div="ligne">
<classe div="col-md-2"></div>
<classe div="col-md-8">
<classe div="carte" style="la couleur noire;">
<classe div="corps de carte">
<classe h5="titre de la carte"><un>Inscrivez-vous pour devenir membre</un><style d'étendue ="Flotter à droite">Êtes vous membre? <un href="#" classe="texte-primaire">Connecte-toi maintenant</un></span></h5>
<classe div="texte de la carte">
<action du formulaire="" méthode="POSTE" non valider>
 {% csrf_token %}
 {{ forme|croustillant}}
<type de bouton ="soumettre" classe="btn btn-primaire btn-sm"> Enregistrer</button>
</form>
</div>
</div>
</div>
</div>
</div>
</div>
</div>
{% endblock %}

Le formulaire comprend le csrf_token, qui protège le processus d'enregistrement contre les pirates. Affichez le formulaire avec le même nom de variable que dans la fonction d'affichage. Ajoutez ensuite le |croustillant filtre vers le Django {{former}} variable. Cela rendra la forme sous forme croustillante.

Exécutez le serveur. Ensuite, vérifiez l'application dans un navigateur à http://127.0.0.1:8000/register. Vous devriez voir le formulaire affiché comme illustré ci-dessous :

Vous avez rendu un formulaire d'inscription à l'aide de formulaires croustillants! Notez que Django a automatiquement ajouté une validation au formulaire. Celles-ci incluent des exigences telles que les autorisations de nom d'utilisateur et de mot de passe.

Pour avoir un système d'inscription complet, ajoutez une logique d'authentification à la fonction d'affichage. Vous pouvez également ajouter une page de connexion pour connecter les utilisateurs enregistrés. Les utilisateurs doivent remplir les conditions d'authentification pour se connecter à l'application.

La bibliothèque django-crispy-forms vous permet de rendre rapidement et facilement des formulaires validés. La validation des données garantit que vous disposez de données précises de vos utilisateurs.

Les données sont utiles lors de la communication avec les utilisateurs et de l'analyse des mesures de performance.

Pourquoi utiliser django-crispy-forms ?

L'utilisation de la bibliothèque de formulaires croustillants pour rendre des formulaires dans Django est un excellent exemple d'application du principe DRY. django-crispy-forms crée des composants réutilisables que vous pouvez afficher dans des modèles.

Ils sont livrés avec du code HTML intégré. Le code vous évitera les tracas liés à la structuration et à la validation des formulaires. Les formulaires Crispy fournissent une balise et un filtre qui restituent les formulaires au format div. Ils offrent également la possibilité de configurer et de contrôler le rendu HTML.

django-crispy-forms fonctionne bien avec le système d'authentification de Django. Vous pouvez créer un système d'authentification pour vérifier vos utilisateurs sans écrire beaucoup de code.