[PYTHON] Comment créer une API Rest dans Django

introduction

Maintenant que vous avez appris à créer une API REST dans Django, pour mieux comprendre Plus étoffé et produit. __ Je vais omettre l'explication de la construction de l'environnement cette fois. __ __ J'utilise l'environnement intégré dans l'article suivant, veuillez donc vous y référer. __ Créez un environnement virtuel avec Anaconda et liez-le à PyCharm. Veuillez également noter que tous les noms arbitraires sont basés sur ceux utilisés dans l'article ci-dessus.

Préparation avancée et environnement

・ En-tête Chrome Mod ・ Facteur ・ Navigateur Anaconda ・ PyCharm CE ・ MacOS

table des matières

1. Créer un modèle
2. Création d'un sérialiseur
3. Créer une vue
4. Contrôle de fonctionnement
5. Bonus: définissez l'API pour qu'elle soit disponible depuis le front

1. Créer un modèle

Un modèle vous permet de concevoir, créer et exploiter une base de données (appelée ORM) en Python. Le nom de la table est défini à l'aide des champs fournis par les modèles de classe et de colonne. Vous pouvez obtenir chaque valeur en spécifiant auto_now_add = True pour l'heure de création des données et auto_now = True pour l'heure de mise à jour.

models.py

from django.db import models

# Create your models here.
#Conception de base de données
class Todo(models.Model):
    title = models.CharField(max_length=50)
    content = models.CharField(max_length=400)
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

Effectuez des migrations et migrez le modèle créé. Bien sûr, je vais l'expliquer correctement. -Makemigrations: Créez migration files pour la gestion de la version de la base de données. -Migrate: modifiez la configuration de la base de données ou annulez la modification.

$ python manage.py makemigrations
$ python manage.py migrate

Ceci termine la création et la migration du modèle.

2. Création d'un sérialiseur

Un sérialiseur est un périphérique qui transforme les données en formes appropriées telles que la validation et le hachage de mot de passe pour entrer et sortir dans le modèle. Il agit comme un pont entre le formulaire d'entrée et le modèle qui gère la base de données. Créez un nouveau serializers.py directement sous api. Les jetons de ce chapitre sont des jetons d'authentification, Vous pouvez imaginer le jeton d'authentification comme une information (chaîne de caractères) permettant de reconnaître de manière unique l'utilisateur.

serializers.py

from rest_framework import serializers
from .models import Todo
#Importez le modèle User fourni par défaut dans django
from django.contrib.auth.models import User
#Importer des jetons pour les utilisateurs
from rest_framework.authtoken.models import Token

class UserSerializer(serializers.ModelSerializer):
    #Classe pour les paramètres de base
    class Meta:
        model = User
        fields = ('id', 'username', 'password')
        #le mot de passe n'est pas accessible par GET et doit être saisi
        extra_kwargs = {'password': {'write_only':True, 'required': True}}

    #Remplacez la méthode de création utilisée pour créer l'utilisateur.
    def create(self,validated_data):
        #Hash le mot de passe
        user = User.objects.create_user(**validated_data)
        #Générer un jeton
        Token.objects.create(user=user)
        return user

class TodoSerializer(serializers.ModelSerializer):

    #Changement de la notation du champ Datetime de django
    created_at = serializers.DateTimeField(format="%Y-%m-%d %H:%M", read_only=True)
    updated_at = serializers.DateTimeField(format="%Y-%m-%d %H:%M", read_only=True)

    class Meta:
        model = Todo
        fields = ['id','title','content','created_at','updated_at']

Vous avez maintenant créé un sérialiseur.

3. Créer une vue

Les vues contrôlent les droits d'accès aux données et l'authentification. Il est responsable de s'assurer que CRUD ne peut être manipulé que par des utilisateurs correctement authentifiés. Créez un fichier d'autorisation avant de créer des vues. Cela permet d'éviter PUT et DELETE dans le modèle User. Créez vos propres autorisations directement sous api et spécifiez d'accepter uniquement GET et POST.

ownpermissions

from rest_framework import permissions

class OwnPermission(permissions.BasePermission):

    def has_object_permission(self, request, view, obj):
        #SAFE_OBTENIR AVEC METHOD,Seul POST autorisé
        if request.method in permissions.SAFE_METHODS:
            return True
        return False

Créez ensuite la vue.

views.py

from django.shortcuts import render

#Bibliothèque requise pour l'authentification par jeton
from rest_framework.authentication import TokenAuthentication
from rest_framework.permissions import IsAuthenticated

#Bibliothèques requises pour créer des vues
from rest_framework import generics
from rest_framework import viewsets

#Importer le modèle et le sérialiseur créés
from django.contrib.auth.models import User
from .models import Todo
from .serializers import UserSerializer,TodoSerializer

#Importer l'autorisation créée
from .ownpermissions import OwnPermission

class UserViewSet(viewsets.ModelViewSet):

    #Obtenir tous les objets utilisateur
    queryset = User.objects.all()

    #Spécifiez le sérialiseur à utiliser
    serializer_class = UserSerializer

    #Précisez pour que tout le monde puisse le voir
    permission_classes = (OwnPermission,)

class ManageUserView(generics.RetrieveUpdateAPIView):
    serializer_class = UserSerializer

    #Spécifiez que seuls les utilisateurs authentifiés peuvent accéder
    authentication_classes = (TokenAuthentication,)

    #Spécifiez pour autoriser uniquement les utilisateurs connectés
    permission_classes = (IsAuthenticated,)

    #Une fonction qui renvoie des informations sur l'utilisateur connecté
    def get_object(self):
        return self.request.user

class TodoViewSet(viewsets.ModelViewSet):
    queryset = Todo.objects.all()
    serializer_class = TodoSerializer
    authentication_classes = (TokenAuthentication,)
    permission_classes = (IsAuthenticated,)

La vue est maintenant terminée.

Créons également des URL. les URL sont responsables de la liaison des vues et des chemins. Apportez les modifications suivantes au projet et à l'application. (Créer une nouvelle application)

drfapi/urls

from django.contrib import admin
from django.urls import path
from django.conf.urls import include
from rest_framework.authtoken.views import obtain_auth_token

urlpatterns = [
    path('admin/', admin.site.urls),
    #Allez voir les URL d'API
    path('api/',include('api.urls')),
    #Le POST d'un nom d'utilisateur et d'un mot de passe renvoie un jeton.
    path('auth/',obtain_auth_token ),
]

Les modèles hérités des génériques utilisent as_view () pour associer la vue au chemin.

api/urls

from django.urls import path
from django.conf.urls import include
from rest_framework import routers
from api.views import UserViewSet, ManageUserView, TodoViewSet

router = routers.DefaultRouter()
router.register('users',UserViewSet)
router.register('todolist',TodoViewSet)

urlpatterns = [
    path('myself/',ManageUserView.as_view( ), name='myself'),
    #Le POST d'un nom d'utilisateur et d'un mot de passe renvoie un jeton.
    path('',include(router.urls)),
]

6. Contrôle de fonctionnement

Vérifiez d'abord le tableau de bord d'administration pour voir si le modèle fonctionne correctement. Écrivez une fonction qui renvoie le nom du titre à models.py et un code qui rend Todo reconnu par l'administrateur dans admin.py.

models.py

def __str__(self):
   return self.title

admin.py

from django.contrib import admin
from .models import Todo
#Enregistrer Todo en tant qu'administrateur
admin.site.register(Todo)

Vous avez besoin d'un super utilisateur (utilisateur autorisé) pour vous connecter au tableau de bord d'administration. Le super utilisateur (utilisateur autorisé) est créé à partir du terminal.

Lorsque vous entrez la commande suivante, une réponse sera renvoyée, alors entrez le nom, l'email, le mot de passe. Vous pouvez laisser l'e-mail vide. S'il s'agit d'un simple mot de passe, vous serez averti, mais s'il n'y a pas de problème, entrez y.

$ python magange.py createsuperuser
Username (laissez vide pour utiliser le nom d'hôte): admin
Email address: 
Password: 
Password (again): 
The password is too similar to the username.
This password is too short. It must contain at least 8 characters.
This password is too common.
Bypass password validation and create user anyway? [y/N]: y
Superuser created successfully.

Utilisons maintenant le tableau de bord d'administration. Exécutez manage.py et ajoutez "/ api / users" à l'URL de l'hôte local pour y accéder. Entrez votre nom d'utilisateur et mot de passe pour vous connecter. Après vous être connecté, entrez le titre et le contenu de [AJOUTER À FAIRE] de Todos. Si vous pouvez l'enregistrer comme indiqué dans l'image ci-dessous, le modèle fonctionne correctement.

Ensuite, utilisez Postman pour vérifier le fonctionnement de CRUD. Lors de l'exécution de manage.py comme précédemment, ajoutez "/ api / users" à l'URL de l'hôte local et accédez-y. Entrez votre nom d'utilisateur et votre mot de passe pour POST et obtenez à nouveau. Si la valeur est mise à jour comme indiqué dans l'image ci-dessous, la communication GET et POST de l'UTILISATEUR est réussie.

Ensuite, accédons à Todolist. Convertissez la partie "utilisateurs" de l'URL en "todolist" et accédez-y. J'ai été averti que je n'ai pas de privilèges CRUD sauf si je suis un utilisateur authentifié. C'est parce que j'ai écrit dans views.py que l'authentification de l'utilisateur est requise.

Accès à l'aide d'un jeton d'authentification. Le jeton d'authentification est obtenu auprès de Postman.

Démarrez Postman. Lorsqu'il démarre, appuyez sur le bouton blanc "+". Entrez l'URL avec "auth" ajouté. Sélectionnez POST pour la requête Http. Créez un champ de nom d'utilisateur et de mot de passe à partir de Body> form-data et entrez la valeur existante. Lorsque vous appuyez sur ENVOYER, le jeton est retourné et vous pouvez le copier. Lancez Chrome ModHeader depuis votre navigateur. Appuyez sur le bouton «+» Sélectionnez Autorisation et entrez Token "Copied Token". (Espace demi-largeur après le jeton) Vous pouvez désormais également accéder à la Todolist.

5. Bonus: définissez l'API pour qu'elle soit disponible depuis le front

Installez CORS. CORS est un système consistant à transmettre des en-têtes HTTP qui détermine si le navigateur empêche le code JavaScript frontal d'accéder à la réponse des requêtes entre les origines. À propos, l'origine est une combinaison de «schéma (protocole)», «hôte (domaine)» et «port» de la propre URL de la ressource.

$ pip install django-cors-headers

Faites connaître à Django CORS.

setting.py

INSTALLED_APPS = [
   #<Abréviation> 
   'corsheaders',
]

MIDDLEWARE = [
   #<Abréviation>
   'corsheaders.middleware.CorsMiddleware',
]

CORS_ORIGIN_WHITELIST = [
    'http://localhost:3000',
]

Vous pouvez maintenant y accéder depuis le front-end. Dans le prochain article, je voudrais résumer comment accéder à l'API depuis la face avant.

Références

・ Présentation de Django (https://docs.djangoproject.com/ja/3.1/intro/overview/) ・ Créons un outil de gestion des appareils avec l'API Django REST (https://www.udemy.com/course/django-rest-api/) ・ [Mémo d'apprentissage] À propos des migrations et migrations (https://qiita.com/frosty/items/8c715a53d7920c9cd1eb) ・ J'ai résumé ce que j'ai appris avec le framework Django REST (https://qiita.com/breakthrough/items/f845592961d8863a72c5) ・ MDN (https://developer.mozilla.org/ja/docs/Glossary/CORS)