[DOCKER] Tutoriel Django (Créer une application de blog) ⑤ --Fonction de création d'article

La dernière fois, j'ai appris à implémenter un test unitaire dans Tutoriel Django (Créer une application de blog) ④ --Unit Test.

À l'origine, j'aimerais l'implémenter dans un style de développement piloté par les tests qui écrit d'abord le test attendu car c'est un gros problème. Dans ce tutoriel, nous allons apprendre ce que Django peut faire, nous allons donc l'implémenter d'abord, puis écrire le test unitaire.

Désormais, nous allons ajouter les fonctions suivantes cette fois en plusieurs parties.

1. Créez un article
2. Détails de l'article (Lire)
3. Modifier l'article (mise à jour)
4. Supprimer l'article

Nous prendrons l'acronyme de ces fonctions et les appellerons ici "CRUD". (Strictement parlant, cela peut être différent car vous pouvez déjà lire avec blog_list)

Maintenant, ajoutons la fonction ** création d'article **, qui peut être considérée comme la base cette fois. Jusqu'à présent, les articles étaient ajoutés avec les privilèges de superutilisateur à l'aide du site de gestion, mais il serait plus pratique de créer des articles dans l'application.

préparation du formulaire

Lors de l'ajout de données depuis l'application, nous utilisons un mécanisme appelé formulaire. Le formulaire pourra accepter les données d'entrée de l'utilisateur, transmettre les données au modèle via la vue et les enregistrer dans la base de données.

Tout d'abord, créez un fichier appelé forms.py sous l'application de blog.

.
├── blog
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── forms.py #ajouter à
│   ├── migrations
│   │   ├── 0001_initial.py
│   │   └── __init__.py
│   ├── models.py
│   ├── tests
│   │   ├── __init__.py
│   │   ├── test_forms.py
│   │   ├── test_models.py
│   │   ├── test_urls.py
│   │   └── test_views.py
│   ├── urls.py
│   └── views.py
├── db.sqlite3
├── manage.py
├── mysite
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── templates
    └── blog
        ├── index.html
        └── post_list.html

Le contenu du forms.py créé ressemblera à ceci.

forms.py

from django import forms
from .models import Post

class PostCreateForm(forms.ModelForm): #Le ModelForm de Django a une validation puissante

    class Meta:
        model = Post #Se connecte au modèle Post et crée un formulaire en fonction du contenu du modèle Post
        fields = ('title', 'text') #Spécifiez la colonne à saisir

Je pense que vous pouvez comprendre dans une certaine mesure parce que l'explication est également incluse. Si vous spécifiez le modèle dans lequel vous souhaitez saisir des données, form préparera le formulaire de saisie correspondant.

De plus, bien que la colonne de saisie des données soit spécifiée comme un champ dans la dernière ligne, Vous pouvez également spécifier que toutes les colonnes doivent être saisies manuellement en définissant ** fields = '__ all __' **.

Réparer urls.py

La classe à ajouter récemment à la vue est nommée ** PostCreateView à l'avance. Dans urls.py, ajoutons le routage comme suit.

urls.py

from django.urls import path
from . import views

app_name = 'blog'

urlpatterns = [
    path('', views.IndexView.as_view(), name='index'),
    path('post_list', views.PostListView.as_view(), name='post_list'),
    path('post_create', views.PostCreateView.as_view(), name='post_create'), #ajouter à
]

success_url spécifie la page vers laquelle rediriger si la modification de la base de données réussit. Spécifiez-le sous la forme "nom de l'application: nom de l'URL inversée", et par conséquent, vous serez redirigé vers la "liste_post" spécifiée dans urls.py.

• Reverse_lazy renvoie la "chaîne de caractères URL" correspondant à la vue. Cette fois, il retournera / blog / post_list

Modifier views.py

Vous avez décidé d'ajouter le nom de classe PostCreateView plus tôt. J'ai également créé une classe pour le formulaire de saisie sous forme.

Ensuite, créez une classe dans views.py et à nouveau en utilisant la vue de classe générique.

views.py

from django.views import generic
from django.urls import reverse_lazy
from .forms import PostCreateForm # forms.Importer une classe créée avec py
from .models import Post

class IndexView(generic.TemplateView):
    template_name = 'blog/index.html'

class PostListView(generic.ListView):
    model = Post

class PostCreateView(generic.CreateView): #ajouter à
    model = Post #Spécifiez le modèle que vous souhaitez créer
    form_class = PostCreateForm #Spécifiez la classe de formulaire créée
    success_url = reverse_lazy('blog:post_list') #Spécifiez la destination de la redirection lorsque l'article est créé avec succès

C'est tout ce que vous avez à faire, grâce à la puissante vue générique basée sur les classes de Django. Tout ce que vous avez à faire est de spécifier le modèle que vous souhaitez créer, la classe de formulaire que vous avez créée et la destination de la redirection lorsque l'article a été créé avec succès.

Préparation du modèle

Je n'ai pas encore créé le html pour créer (publier) des articles, alors créons-le sous templates / blog. Nommez-le post_form.html.

• En suivant la convention de dénomination des vues à usage général basées sur les classes, c'est OK même si vous ne spécifiez pas le nom du modèle.

└── templates
    └── blog
        ├── index.html
        ├── post_form.html #ajouter à
        └── post_list.html

post_create.html

<form action="" method="POST">
  <table class="table">
      <tr>
        <th>Titre</th>
        <td>{{ form.title }}</td>
      </tr>
      <tr>
        <th>Texte</th>
        <td>{{ form.text }}</td>
      </tr>
  </table>
  <button type="submit" class="btn btn-primary">Envoyer</button>
  {% csrf_token %}
</form>

Étant donné que le champ de saisie spécifié dans les champs de forms.py peut être reçu par une variable appelée form, Du côté du modèle, il peut être récupéré sous la forme de form.title et form.text.

Il est également appelé CSRF (Cross-Site Request Forgery) pour empêcher les attaques utilisant des formulaires de saisie. Assurez-vous de l'inclure lors de l'affichage du formulaire de saisie en html.

Si vous démarrez le serveur avec la commande runserver dans cet état, vous verrez un formulaire d'entrée, même si cela semble terrible. (Souvent, je commencerai par apprendre les bases de Django, puis j'ajusterai l'apparence.)

Entrons une valeur et envoyons-la.

Appuyer sur soumettre vous redirigera vers post_list. Et vous pouvez voir que l'article que j'ai posté plus tôt a été ajouté.

Vous avez ajouté avec succès la fonction de publication d'articles.

Correction de test_views.py

Enfin, implémentons un test pour cette fonctionnalité.

Créez la classe de test suivante dans test_views.py.

test_views.py

...
class PostCreateTests(TestCase):
    """Classe de test de vue PostCreate."""

    def test_get(self):
        """Confirmez que le code d'état 200 est renvoyé en accédant avec la méthode GET."""
        response = self.client.get(reverse('blog:post_create'))
        self.assertEqual(response.status_code, 200)

    def test_post_with_data(self):
        """Confirmez que si vous POSTEZ avec les données appropriées, vous serez redirigé avec succès"""
        data = {
            'title': 'test_title',
            'text': 'test_text',
        }
        response = self.client.post(reverse('blog:post_create'), data=data)
        self.assertEqual(response.status_code, 302)
    
    def test_post_null(self):
        """Confirmez que le POST avec des données vides ne renvoie que 200 sans redirection"""
        data = {}
        response = self.client.post(reverse('blog:post_create'), data=data)
        self.assertEqual(response.status_code, 200)

Nous examinons la confirmation GET de base, l'entrée de données appropriée et la confirmation de redirection, et la réponse lorsque des données vides sont entrées.

Enfin, exécutons le test.

Vous êtes passé sain et sauf.

La prochaine fois, je créerai immédiatement l'écran des détails de l'article.

→ La prochaine fois Tutoriel Django (Créer une application de blog) ⑥ - Détails de l'article / Fonction Modifier / Supprimer