L’auteur choisi Open Sourcing maladie mentale Ltd de recevoir un don dans le cadre du programme écrire pour les dons .
Introduction
Les gens utilisent divers types de dispositifs pour se connecter à internet et surfer sur le Web. Pour cette raison, les applications doivent être accessibles depuis divers endroits. Pour les sites Web traditionnels, ayant une interface utilisateur réactive est généralement suffisant, mais des applications plus complexes nécessitent souvent l’emploi d’autres techniques et architectures. Ceux-ci incluent avoir reste dorsal et frontal des demandes distinctes qui peuvent être implémentées comme des applications web côté client, Progressive Web applications (PWA) ou des applications mobiles natives.
Certains outils que vous pouvez utiliser lorsque vous créez des applications plus complexes incluent :
Réagir, un framework JavaScript qui permet aux développeurs de créer des web et des interfaces natives pour leurs programmes de l’API REST.
Django, un libre et open source Python web framework qui suit le modèle architectural de logiciel de modèle vue contrôleur (MVC) .
Cadre de Django reste, un outil puissant et flexible pour construction API REST dans Django.
Dans ce didacticiel, vous allez générer une application web moderne avec une API REST backend et interface pour réagir, Django et le Framework Django reste séparés. En utilisant réagissent avec Django, vous serez en mesure de bénéficier des derniers avancements en JavaScript et développement front-end. Au lieu de construire une application Django qui utilise un moteur de template intégré, vous utiliserez réagissent comme une bibliothèque d’interface utilisateur, profitant de son virtual Document Object Model (DOM), approche déclarative et composants qui rendent rapidement les modifications de données.
L’application web, que vous générerez stocke les enregistrements sur les clients dans une base de données, et vous pouvez l’utiliser comme point de départ pour une application de CRM. Lorsque vous avez terminé, vous serez en mesure de créer, lire, mettre à jour et supprimer des enregistrements en utilisant une interface réagissent avec Bootstrap 4 style.
Conditions préalables
Pour compléter ce tutoriel, vous aurez besoin :
Une machine de développement avec Ubuntu 18.04.
Python 3, pipet venv installé sur votre ordinateur en suivant les étapes 1 et 2 de Comment installer Python 3 et Set Up a programmation environnement Local sur Ubuntu 18.04.
Node.js 6 + et npm 5.2 ou version ultérieure installé sur votre machine. Vous pouvez installer deux d’entre eux en suivant les instructions Comment à installer Node.js sur Ubuntu 18.04 sur l’installation d’un PPA.
Étape 1 — Création d’un environnement virtuel Python et l’installation des dépendances
Dans cette étape, nous allons créer un environnement virtuel et installez les dépendances requises pour notre application, y compris de Django, le framework Django reste et django-cors-headers.
Notre application utilisera deux serveurs de développement différents pour Django et de réagir. Ils seront exécuté sur des ports différents et fonctionnera comme deux domaines distincts. Pour cette raison, nous devons permettre à Croix-origine ressource partage (SCRO) envoyer des requêtes HTTP de réagir à Django sans être bloqué par le navigateur.
Accédez à votre répertoire personnel et créer un environnement virtuel en utilisant le module venv Python 3 :
cd ~
python3 -m venv ./env
Activer l’environnement virtuel créé à l’aide de la source:
source env/bin/activate
Ensuite, installez les dépendances du projet avec le pip. Il s’agira notamment :
Django: le framework web pour le projet.
Cadre de Django reste: une application tierce qui construit les API REST avec Django.
django-cors-headers: un paquet qui permet de la SCRO.
Installer le framework Django :
pip install django djangorestframework django-cors-headers
Avec les dépendances de projet installés, vous pouvez créer le projet Django et le frontend de réagir.
Étape 2 : Création d’un projet Django
Dans cette étape, nous générerons projet Django en utilisant les commandes suivantes et les utilitaires :
django-admin startproject project-name: django-admin est un utilitaire de ligne de commande utilisé pour accomplir des tâches avec Django. La commande startproject crée un nouveau projet Django.
python manage.py startapp myapp: manage.py est un script utilitaire, ajouté automatiquement à chaque projet de Django, qui effectue un certain nombre de tâches administratives : création de nouvelles applications, migration de la base de données, et le projet Django localement au service. Sa commande de startapp crée une application Django Django du projet. Dans Django, terme application décrit un Python qui fournit un ensemble de fonctionnalités dans un projet.
Pour commencer, créez le projet Django django-admin startproject. Nous appellerons notre projet djangoreactproject:
django-admin startproject djangoreactproject
Avant de poursuivre, nous allons étudier la structure de répertoires de notre projet de Django à l’aide de la commande tree .
Astuce : tree est une commande très utile pour l’affichage des fichiers et répertoires des structures de la ligne de commande. Vous pouvez l’installer avec la commande suivante :
sudo apt-get install tree
Utilisez-le, cd dans le répertoire que vous voulez et tapez tree ou fournissez le chemin d’accès au point de départ avec tree /home/sammy/sammys-project.
Naviguez jusqu’au dossier djangoreactproject dans la racine de votre projet et exécutez la commande tree :
cd ~/djangoreactproject
tree
Vous verrez la sortie suivante :
Output
├── djangoreactproject
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
└── manage.py
Le dossier ~/djangoreactproject est la racine du projet. Dans ce dossier, il y a plusieurs fichiers qui conviendra à votre travail :
manage.py: le script utilitaire qui effectue un certain nombre de tâches administratives.
settings.py: le fichier de configuration principal pour le projet Django où vous pouvez modifier les paramètres du projet. Ces paramètres incluent des variables telles INSTALLED_APPS, une liste de chaînes désignant les applications activées pour votre projet. La documentation de Django a plus d’informations sur les paramètres disponibles.
urls.py: ce fichier contient une liste des modèles d’URL et les vues associées. Chaque modèle correspond une connexion entre une URL et la fonction qui doit être appelée pour cette URL. Pour plus d’informations sur les URL et les vues, veuillez vous référer à notre tutoriel sur Comment créer Django vues.
Notre première étape dans le travail avec le projet sera de configurer les paquets que nous avons installé à l’étape précédente, y compris le framework Django reste et le paquet de Django CORS, en les ajoutant à settings.py. Ouvrez le fichier avec nano ou votre éditeur favori :
nano ~/djangoreactproject/djangoreactproject/settings.py
Accédez au paramètre INSTALLED_APPS et ajoutez les applications rest_framework et corsheaders vers le bas de la liste :
~/djangoreactproject/djangoreactproject/Settings.py
…
INSTALLED_APPS = [
‘django.contrib.admin’,
‘django.contrib.auth’,
‘django.contrib.contenttypes’,
‘django.contrib.sessions’,
‘django.contrib.messages’,
‘django.contrib.staticfiles’,
‘rest_framework’,
‘corsheaders’
]
Ensuite, ajoutez le middleware de corsheaders.middleware.CorsMiddleware de l’emballage de la SCRO précédemment installé sur le réglage de MIDDLEWARE . Ce paramètre est une liste des middlewares, une classe de Python qui contient le code obtenu à chaque fois que votre application web gère une demande ou une réponse :
~/djangoreactproject/djangoreactproject/Settings.py
…
MIDDLEWARE = [
…
‘django.contrib.messages.middleware.MessageMiddleware’,
‘django.middleware.clickjacking.XFrameOptionsMiddleware’,
‘corsheaders.middleware.CorsMiddleware’
]
Ensuite, vous pouvez activer la SCRO. Le paramètre CORS_ORIGIN_ALLOW_ALL spécifie si oui ou non vous souhaitez autoriser la SCRO pour tous les domaines, et CORS_ORIGIN_WHITELIST est un tuple Python qui contient a permis des URLs. Dans notre cas, parce que le serveur de développement réagissent sera cadencé à http://localhost:3000, nous allons ajouter nouveau CORS_ORIGIN_ALLOW_ALL = False et les paramètres de CORS_ORIGIN_WHITELIST(‘localhost:3000’,) à notre settings.py settings.pyfichier. Ajouter ces paramètres n’importe où dans le fichier :
~/djangoreactproject/djangoreactproject/Settings.py
…
CORS_ORIGIN_ALLOW_ALL = False
CORS_ORIGIN_WHITELIST = (
‘localhost:3000’,
)
…
Vous pouvez trouver plus d’options de configuration dans les docs de django-cors-headers .
Enregistrez le fichier et quittez l’éditeur lorsque vous avez terminé.
Toujours dans le répertoire ~/djangoreactproject , présenter une nouvelle demande de Django appelée customers:
python manage.py startapp customers
Celui-ci contiendra les modèles et les vues pour la gestion des clients. Les modèles définissent les champs et les comportements de notre application data, alors que les vues permettent à notre application à bien gérer les requêtes web et renvoyer les réponses nécessaires.
Ensuite, ajoutez cette application à la liste des applications installées dans le fichier settings.py du projet pour Django il reconnaîtra dans le cadre du projet. Ouvert settings.py encore une fois :
nano ~/djangoreactproject/djangoreactproject/settings.py
Ajouter la demande de customers :
~/djangoreactproject/djangoreactproject/Settings.py
…
INSTALLED_APPS = [
…
‘rest_framework’,
‘corsheaders’,
‘customers’
]
…
Ensuite, migrer la base de données et démarrer le serveur de développement local. Les migrations sont de Django de propager les modifications que vous apportez à vos modèles dans votre schéma de base de données. Ces changements peuvent inclure des choses comme l’ajout d’un champ ou la suppression d’un modèle, par exemple. Pour plus d’informations sur les modèles et les migrations, voir Comment à créer des modèles Django.
La migration de la base de données :
python manage.py migrate
Démarrez le serveur de développement local :
python manage.py runserver
Vous obtenez une sortie semblable au suivant :
Output
Performing system checks…
System check identified no issues (0 silenced).
October 22, 2018 – 15:14:50
Django version 2.1.2, using settings ‘djangoreactproject.settings’
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.
Vous utiliserez votre application web de http://127.0.0.1:8000. Si vous accédez à cette adresse dans votre navigateur web, vous devriez voir la page suivante :
Django demo page
À ce stade, quitter l’application en cours d’exécution et ouvrez un nouveau terminal pour continuer à développer le projet.
Étape 3 — Création le Frontend React
Dans cette section, nous allons créer l’application frontale de notre projet à l’aide de réagir.
Réagir a un utilitaire officiel qui permet de générer rapidement des projets de réagir sans avoir à configurer Webpack directement. WebPack est un bundler module utilisé pour regrouper des ressources web tels que le code JavaScript, CSS et images. En général, avant de pouvoir utiliser Webpack vous devrez définir différentes options de configuration, mais grâce à l’utilitaire create-react-app , il ne faut pas traiter directement avec Webpack, jusqu’à ce que vous décidez que vous avez besoin de plus de contrôle. Pour exécuter create-react-app , vous pouvez utiliser npx, un outil qui exécute les fichiers binaires de la npm paquet.
Dans votre deuxième terminal, vérifiez que vous êtes dans le répertoire de votre projet :
cd ~/djangoreactproject
Créez un projet React appelé frontend aide create-react-app et npx:
npx create-react-app frontend
Ensuite naviguer à l’intérieur de votre application de réagir et de démarrer le serveur de développement :
cd ~/djangoreactproject/frontend
npm start
Votre application s’exécutera de http://localhost:3000/:
React demo page
Laissez le serveur de développement réagissent en cours d’exécution et ouvrir une autre fenêtre de terminal pour aller de l’avant.
Pour visualiser la structure de répertoire de l’ensemble du projet à ce stade, naviguez jusqu’au dossier racine, puis réexécutez tree :
cd ~/djangoreactproject
tree
Vous verrez une structure comme suit :
Output
├── customers
│ ├── admin.py
│ ├── apps.py
│ ├── __init__.py
│ ├── migrations
│ │ └── __init__.py
│ ├── models.py
│ ├── tests.py
│ └── views.py
├── djangoreactproject
│ ├── __init__.py
│ ├── __pycache__
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
├── frontend
│ ├── package.json
│ ├── public
│ │ ├── favicon.ico
│ │ ├── index.html
│ │ └── manifest.json
│ ├── README.md
│ ├── src
│ │ ├── App.css
│ │ ├── App.js
│ │ ├── App.test.js
│ │ ├── index.css
│ │ ├── index.js
│ │ ├── logo.svg
│ │ └── registerServiceWorker.js
│ └── yarn.lock
└── manage.py
Notre application utilisera Bootstrap 4 au style de l’interface de réagir, donc nous l’inclurons dans le fichier frontend/src/App.css , qui gère nos paramètres CSS. Ouvrir le fichier :
nano ~/djangoreactproject/frontend/src/App.css
Au début du fichier, ajouter suivant l’importation . Vous pouvez supprimer le contenu du fichier existant, mais qui n’est pas obligatoire :
~/djangoreactproject/frontend/SRC/App.CSS
@import ‘https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css’;
Ici, @import est une instruction CSS est utilisée pour importer des règles de style d’autres feuilles de style.
Maintenant que nous avons créé les deux les applications back-end et front-end, nous allons créer le modèle de client et des données de démonstration.
Étape 4 — À créer le modèle de client et les données initiales
Après avoir créé l’application Django et le frontend React, notre prochaine étape sera de créer le modèle de client, ce qui représente la table de base de données qui contiendra des informations sur le client. Vous n’avez pas besoin tout SQL puisque Django Object Relational Mapper (ORM) gère les opérations de base de données en mappant des classes Python et variables pour les colonnes et les tables SQL. De cette façon, l’ORM de Django abstracts des interactions avec la base de données via une interface Python SQL.
Activer à nouveau votre environnement virtuel :
cd ~
source env/bin/activate
Déplacer vers le répertoire de customers et ouvrez models.py, un fichier Python qui contient les modèles de votre application :
cd ~/djangoreactproject/customers/
nano models.py
Le fichier contiendra le contenu suivant :
~/djangoreactproject/Customers/Models.py
from django.db import models
# Create your models here.
API du modèle client est déjà importé dans le fichier grâce à l’instruction import from django.db import models . Vous allez maintenant ajouter la classe Customer , qui s’étend des modèles models.Model. Chaque modèle de Django est une classe de Python qui s’étend de django.db.models.Model .
Le modèle de Customer aura ces champs de base de données :
first_name : le prénom du client.
last_name — le nom du client.
email : l’adresse e-mail du client.
phone : le numéro de téléphone du client.
address : l’adresse du client.
description : la description du client.
createdAt — la date où le client est ajouté.
Nous allons également ajouter la fonction __str__() , qui définit la façon dont le modèle s’affichera. Dans notre cas, ce sera avec les prénom du client. Pour en savoir plus sur la construction de classes et de définition d’objets, consultez Comment construire des Classes et définir des objets en Python 3.
Ajoutez le code suivant au fichier :
~/djangoreactproject/Customers/Models.py
from django.db import models
class Customer(models.Model):
first_name = models.CharField(“First name”, max_length=255)
last_name = models.CharField(“Last name”, max_length=255)
email = models.EmailField()
phone = models.CharField(max_length=20)
address = models.TextField(blank=True, null=True)
description = models.TextField(blank=True, null=True)
createdAt = models.DateTimeField(“Created At”, auto_now_add=True)
def __str__(self):
return self.first_name
Ensuite, migrer la base de données pour créer les tables de base de données. La commande makemigrations crée les fichiers de migration où les modifications apportées au modèle seront ajoutées, et migrate applique les modifications dans les fichiers de migration de la base de données.
Naviguez vers le dossier racine du projet :
cd ~/djangoreactproject
Exécutez la commande suivante pour créer les fichiers de migration :
python manage.py makemigrations
Vous obtiendrez un résultat qui ressemble à ceci :
Output
customers/migrations/0001_initial.py
– Create model Customer
Appliquer ces modifications à la base de données :
python manage.py migrate
Vous verrez la sortie indiquant une migration réussie :
Output
Operations to perform:
Apply all migrations: admin, auth, contenttypes, customers, sessions
Running migrations:
Applying customers.0001_initial… OK
Ensuite, vous utiliserez un fichier de migration de données pour créer les données du client initial. Un fichier de migration de données est une migration qui ajoute ou modifie des données dans la base de données. Créer un fichier de migration de données vide pour la demande de customers :
python manage.py makemigrations –empty –name customers customers
Vous verrez la confirmation suivante avec le nom de votre fichier de migration :
Output
Migrations for ‘customers’:
customers/migrations/0002_customers.py
Notez que le nom de votre fichier de migration est 0002_customers.py.
Ensuite, naviguez dans le dossier de migration de la demande de customers :
cd ~/djangoreactproject/customers/migrations
Ouvrez le fichier de migration créé :
nano 0002_customers.py
Il s’agit de la teneur initiale du fichier :
~/djangoreactproject/Customers/migrations/0002_customers.py
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
(‘customers’, ‘0001_initial’),
]
operations = [
]
Les importations de déclaration d’importation l’API de migrations , une API de Django pour créer des migrations, de django.db, un package intégré qui contient des classes pour travailler avec des bases de données.
La Migration de classe est une classe de Python qui décrit les opérations qui sont exécutées lors de la migration des bases de données. Cette classe étend les migrations migrations.Migration et dispose de deux listes :
dependencies: contient les migrations dépendantes.
operations: contient les opérations qui seront exécutées lorsque nous appliquons la migration.
Ensuite, ajoutez une méthode pour créer des données de clients de démo. Ajoutez la méthode suivante avant la définition de la classe de Migration :
~/djangoreactproject/Customers/migrations/0002_customers.py
…
def create_data(apps, schema_editor):
Customer = apps.get_model(‘customers’, ‘Customer’)
Customer(first_name=”Customer 001″, last_name=”Customer 001″, email=”[email protected]”, phone=”00000000″, address=”Customer 000 Address”, description= “Customer 001 description”).save()
…
Dans cette méthode, nous saisissant de la classe de Customer de notre application customers et créons un client démo à insérer dans la base de données.
Pour obtenir la classe Customer , qui permettra la création de nouveaux clients, nous utilisons la méthode get_model() de l’objet apps . L’objet apps représente le registre des applications installées et leurs modèles de base de données.
L’objet apps sera passé par la méthode RunPython() lorsque nous l’utilisons pour exécuter create_data(). Ajouter les migrations de migrations.RunPython() méthode pour la liste vide operations :
~/djangoreactproject/Customers/migrations/0002_customers.py
…
operations = [
migrations.RunPython(create_data),
]
RunPython() fait partie de l’API de migration qui vous permet d’exécuter un code Python personnalisé dans une migration. Notre liste operations précise que cette méthode est exécutée lorsque nous appliquons la migration.
Il s’agit de l’ensemble du dossier :
~/djangoreactproject/Customers/migrations/0002_customers.py
from django.db import migrations
def create_data(apps, schema_editor):
Customer = apps.get_model(‘customers’, ‘Customer’)
Customer(first_name=”Customer 001″, last_name=”Customer 001″, email=”[email protected]”, phone=”00000000″, address=”Customer 000 Address”, description= “Customer 001 description”).save()
class Migration(migrations.Migration):
dependencies = [
(‘customers’, ‘0001_initial’),
]
operations = [
migrations.RunPython(create_data),
]
Pour plus d’informations sur la migration des données, consultez la documentation sur les migrations de données de Django
Pour migrer votre base de données, tout d’abord naviguer vers le dossier racine de votre projet :
cd ~/djangoreactproject
Migrer votre base de données pour créer les données de démonstration :
python manage.py migrate
Vous obtenez une sortie qui confirme la migration :
Output
Operations to perform:
Apply all migrations: admin, auth, contenttypes, customers, sessions
Running migrations:
Applying customers.0002_customers… OK
Pour plus de détails sur ce processus, renvoyer au Comment pour créer des modèles Django.
Avec les modèle et démo données client créées, nous pouvons passer à la construction de l’API REST.
Étape 5 : Création de l’API REST
Dans cette étape, nous allons créer l’API REST en utilisant le Framework Django reste. Nous allons créer plusieurs différentes vues de l’API. Une vue de l’API est une fonction qui gère une demande d’API ou l’appel, alors qu’un point de terminaison API est une URL unique qui représente un touchpoint avec le reste du système. Par exemple, lorsque l’utilisateur envoie une requête GET à un point de terminaison API, Django appelle la fonction correspondante ou la vue des API pour gérer la demande et renvoie aucun résultat possible.
Nous ferons également l’utilisation de sérialiseurs. Un sérialiseur dans le Framework Django reste permet de modèles complexes et QuerySets à être convertis en format JSON pour la consommation de l’API. La classe de sérialiseur peut également fonctionner dans l’autre sens, prévoir des mécanismes pour l’analyse et la désérialisation des données en modèles de Django et QuerySets.
Nos points de terminaison API comprendra :
api/customers: ce paramètre est utilisé pour créer des clients et retourne ensembles paginés de clients.
api/customers/
Nous allons également créer des URL dans le fichier urls.py du projet pour les points de terminaison correspondants (c’est à dire api/customers et api/customers/
Nous allons commencer par créer la classe de sérialiseur pour notre modèle de Customer .
Ajout de la classe de sérialiseur
Créez une classe de sérialiseur pour notre modèle de Customer est nécessaire pour transformer des instances customer et QuerySets vers et à partir de JSON. Pour créer la classe de sérialiseur, tout d’abord faire un fichier serializers.py à l’intérieur de la demande de customers :
cd ~/djangoreactproject/customers/
nano serializers.py
Ajoutez le code suivant pour importer le modèle de sérialiseurs API et Customer :
~/djangoreactproject/Customers/Serializers.py
from rest_framework import serializers
from .models import Customer
Ensuite, créez une classe de sérialiseur qui étend les sérialiseurs serializers.ModelSerializer et spécifie les champs qui seront sérialisés :
~/djangoreactproject/Customers/Serializers.py
…
class CustomerSerializer(serializers.ModelSerializer):
class Meta:
model = Customer
fields = (‘pk’,’first_name’, ‘last_name’, ’email’, ‘phone’,’address’,’description’)
La classe Meta spécifie les champs à sérialiser et modèle : pk,first_name, last_name, email, phone, address,description.
Il s’agit de l’intégralité du contenu du fichier :
~/djangoreactproject/Customers/Serializers.py
from rest_framework import serializers
from .models import Customer
class CustomerSerializer(serializers.ModelSerializer):
class Meta:
model = Customer
fields = (‘pk’,’first_name’, ‘last_name’, ’email’, ‘phone’,’address’,’description’)
Maintenant que nous avons créé notre classe de sérialiseur, nous pouvons ajouter des vues de l’API.
Ajout de l’API vues
Dans cette section, nous allons créer le point de vue API pour notre application qui sera appelée par Django lorsque l’utilisateur visite le point de terminaison correspondant à la fonction de visualisation.
Ouvrir ~/djangoreactproject/customers/views.py:
nano ~/djangoreactproject/customers/views.py
Supprimer ce qui est là et ajouter les importations suivantes :
~/djangoreactproject/Customers/views.py
from rest_framework.response import Response
from rest_framework.decorators import api_view
from rest_framework import status
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from .models import Customer
from .serializers import *
Nous importons le sérialiseur que nous avons créé, avec le modèle de Customer et le Django et API du Framework Django reste.
Ensuite, ajoutez la vue pour le traitement des requêtes POST et GET HTTP :
~/djangoreactproject/Customers/views.py
…
@api_view([‘GET’, ‘POST’])
def customers_list(request):
“””
List customers, or create a new customer.
“””
if request.method == ‘GET’:
data = []
nextPage = 1
previousPage = 1
customers = Customer.objects.all()
page = request.GET.get(‘page’, 1)
paginator = Paginator(customers, 10)
try:
data = paginator.page(page)
except PageNotAnInteger:
data = paginator.page(1)
except EmptyPage:
data = paginator.page(paginator.num_pages)
serializer = CustomerSerializer(data,context={‘request’: request} ,many=True)
if data.has_next():
nextPage = data.next_page_number()
if data.has_previous():
previousPage = data.previous_page_number()
return Response({‘data’: serializer.data , ‘count’: paginator.count, ‘numpages’ : paginator.num_pages, ‘nextlink’: ‘/api/customers/?page=’ + str(nextPage), ‘prevlink’: ‘/api/customers/?page=’ + str(previousPage)})
elif request.method == ‘POST’:
serializer = CustomerSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
Tout d’abord, nous utilisons le décorateur @api_view([‘GET’, ‘POST’]) pour créer une vue de l’API qui peut accepter les requêtes GET et POST. Un décorateur est une fonction qui prend une autre fonction et elle étend dynamiquement.
Dans le corps de la méthode, nous utilisons la variable request.method pour vérifier la méthode HTTP actuelle et exécuter la logique correspondante selon le type de demande :
Si c’est une demande GET, la méthode pagine les données à l’aide de Django Paginatoret retourne la première page de données après la sérialisation, le nombre de clients disponibles, le nombre de pages disponibles et les liens vers les pages précédentes et suivante. Paginator est une classe intégrée de Django qui pagine une liste de données dans les pages et fournit des méthodes pour accéder aux éléments de chaque page.
Si c’est une demande POST, la méthode sérialise les données des clients reçus et appelle ensuite la méthode save() de l’objet du sérialiseur. Puis, elle retourne un objet de réponse, une instance de HttpResponse, avec un code de 201 État. Chaque affichage que vous créez est responsable de retournant un objet HttpResponse . La méthode save() enregistre les données sérialisées dans la base de données.
Pour plus d’infos sur HttpResponse et vues, consultez cette discussion de la création de fonctions de vue.
Maintenant, ajoutez la vue de l’API qui sera chargée de traiter les demandes GET, PUT et DELETE pour obtenir, mise à jour et suppression de clients par pk (clé primaire) :
~/djangoreactproject/Customers/views.py
…
@api_view([‘GET’, ‘PUT’, ‘DELETE’])
def customers_detail(request, pk):
“””
Retrieve, update or delete a customer by id/pk.
“””
try:
customer = Customer.objects.get(pk=pk)
except Customer.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == ‘GET’:
serializer = CustomerSerializer(customer,context={‘request’: request})
return Response(serializer.data)
elif request.method == ‘PUT’:
serializer = CustomerSerializer(customer, data=request.data,context={‘request’: request})
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == ‘DELETE’:
customer.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
La méthode est décorée avec @api_view([‘GET’, ‘PUT’, ‘DELETE’]) pour indiquer que c’est une vue de l’API qui peut accepter GET, mettre et supprimer les requêtes.
La vérification dans le domaine de la request.method vérifie la méthode de la demande et selon sa valeur appelle la logique de la droite :
Si c’est une demande GET, données clients sont sérialisées et envoyées à l’aide d’un objet de réponse.
Si c’est une demande PUT, la méthode crée un sérialiseur pour les nouvelles données de client. Ensuite, il appelle la méthode save() de l’objet de sérialiseur créé. Enfin, il envoie un objet de réponse avec le client mises à jour.
Si c’est une demande de suppression, la méthode appelle la méthode delete() de l’objet customer de la supprimer puis retourne un objet de réponse sans aucune donnée.
Le fichier ressemble à ceci :
~/djangoreactproject/Customers/views.py
from rest_framework.response import Response
from rest_framework.decorators import api_view
from rest_framework import status
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from .models import Customer
from .serializers import *
@api_view([‘GET’, ‘POST’])
def customers_list(request):
“””
List customers, or create a new customer.
“””
if request.method == ‘GET’:
data = []
nextPage = 1
previousPage = 1
customers = Customer.objects.all()
page = request.GET.get(‘page’, 1)
paginator = Paginator(customers, 5)
try:
data = paginator.page(page)
except PageNotAnInteger:
data = paginator.page(1)
except EmptyPage:
data = paginator.page(paginator.num_pages)
serializer = CustomerSerializer(data,context={‘request’: request} ,many=True)
if data.has_next():
nextPage = data.next_page_number()
if data.has_previous():
previousPage = data.previous_page_number()
return Response({‘data’: serializer.data , ‘count’: paginator.count, ‘numpages’ : paginator.num_pages, ‘nextlink’: ‘/api/customers/?page=’ + str(nextPage), ‘prevlink’: ‘/api/customers/?page=’ + str(previousPage)})
elif request.method == ‘POST’:
serializer = CustomerSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
@api_view([‘GET’, ‘PUT’, ‘DELETE’])
def customers_detail(request, pk):
“””
Retrieve, update or delete a customer by id/pk.
“””
try:
customer = Customer.objects.get(pk=pk)
except Customer.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method == ‘GET’:
serializer = CustomerSerializer(customer,context={‘request’: request})
return Response(serializer.data)
elif request.method == ‘PUT’:
serializer = CustomerSerializer(customer, data=request.data,context={‘request’: request})
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
elif request.method == ‘DELETE’:
customer.delete()
return Response(status=status.HTTP_204_NO_CONTENT)
Nous pouvons maintenant passer à la création de nos points de terminaison.
Ajout de points de terminaison API
Nous allons maintenant créer les points de terminaison API : api/customers/, pour l’interrogation et la création de clients, et api/customers/
Ouvrir ~/djangoreactproject/djangoreactproject/urls.py:
nano ~/djangoreactproject/djangoreactproject/urls.py
Laisser ce qui est là, mais ajouter l’importation à l’opinion de customers en haut du fichier :
~/djangoreactproject/djangoreactproject/URLs.py
from django.contrib import admin
from django.urls import path
from customers import views
from django.conf.urls import url
Ensuite, ajoutez le api/customers/ et api/customers/
~/djangoreactproject/djangoreactproject/URLs.py
…
urlpatterns = [
path(‘admin/’, admin.site.urls),
url(r’^api/customers/$’, views.customers_list),
url(r’^api/customers/(?P
]
Avec nos points de terminaison REST créés, nous allons voir comment nous pouvons consommer.
Étape 6 – Consommant l’API REST avec Axios
Dans cette étape, nous installerons Axios, nous allons utiliser pour passer des appels API client HTTP. Nous allons également créer une classe pour consommer les points de terminaison API que nous avons créé.
Tout d’abord, désactiver votre environnement virtuel :
deactivate
Ensuite, accédez à votre dossier frontend :
cd ~/djangoreactproject/frontend
Installer axios npm en faisant :
npm install axios –save
La –save option ajoute la dépendance axios au fichier package.json de votre application.
Ensuite, créez un fichier JavaScript appelé CustomersService.js, qui contiendra le code pour appeler les autres API. Nous allons faire cela dans le dossier src , où vivra le code d’application pour notre projet :
cd src
nano CustomersService.js
Ajoutez le code suivant, qui contient des méthodes pour vous connecter à l’API REST de Django :
~/djangoreactproject/frontend/SRC/CustomersService.js
import axios from ‘axios’;
const API_URL = ‘http://localhost:8000’;
export default class CustomersService{
constructor(){}
getCustomers() {
const url = ${API_URL}/api/customers/
;
return axios.get(url).then(response => response.data);
}
getCustomersByURL(link){
const url = ${API_URL}${link}
;
return axios.get(url).then(response => response.data);
}
getCustomer(pk) {
const url = ${API_URL}/api/customers/${pk}
;
return axios.get(url).then(response => response.data);
}
deleteCustomer(customer){
const url = ${API_URL}/api/customers/${customer.pk}
;
return axios.delete(url);
}
createCustomer(customer){
const url = ${API_URL}/api/customers/
;
return axios.post(url,customer);
}
updateCustomer(customer){
const url = ${API_URL}/api/customers/${customer.pk}
;
return axios.put(url,customer);
}
}
La classe CustomersService appelle les méthodes Axios suivants :
getCustomers(): première page obtient des clients.
getCustomersByURL(): obtient des clients par URL. Il est ainsi possible d’obtenir les pages qui suivent des clients en passant des liens tels que /api/customers/?page=2.
getCustomer(): obtient un client de la clé primaire.
createCustomer(): crée un client.
updateCustomer(): met à jour un client.
deleteCustomer(): supprime un client.
Nous pouvons maintenant afficher les données de notre API dans notre interface interface utilisateur réagissent en créant un composant CustomersList .
Étape 7-Affichage des données de l’API dans l’Application de réagir
Dans cette étape, nous allons créer le React CustomersList composant. Un composant de React représente une partie de l’interface utilisateur ; il vous permet également de séparer l’interface utilisateur en morceaux indépendants et réutilisable.
Commencez par créer CustomersList.js dans frontend/src:
nano ~/djangoreactproject/frontend/src/CustomersList.js
Commencez par importer React et Component pour créer un composant de réagir :
~/djangoreactproject/frontend/SRC/CustomersList.js
import React, { Component } from ‘react’;
Ensuite, importez et instancier le module CustomersService que vous avez créé à l’étape précédente, qui fournit des méthodes que l’interface avec l’API REST backend :
~/djangoreactproject/frontend/SRC/CustomersList.js
…
import CustomersService from ‘./CustomersService’;
const customersService = new CustomersService();
Ensuite, créez un composant CustomersList qui s’étend de Component pour appeler l’API REST. Un composant de React devrait étendre ou la sous-classe de la classe Component . Pour plus d’infos sur héritage et classes E6, veuillez consulter notre tutoriel sur Les Classes de compréhension dans JavaScript.
Ajoutez le code suivant pour créer un composant de réagir qui s’étend de react.Component:
~/djangoreactproject/frontend/SRC/CustomersList.js
…
class CustomersList extends Component {
constructor(props) {
super(props);
this.state = {
customers: [],
nextPageURL: ”
};
this.nextPage = this.nextPage.bind(this);
this.handleDelete = this.handleDelete.bind(this);
}
}
export default CustomersList;
À l’intérieur du constructeur, nous sommes l’initialisation de l’objet state . Cela vaut les variables d’état de notre composant à l’aide d’un vide de customers tableau. Ce tableau contiendra des clients et un nextPageURL qui contiendra l’URL de la page suivante pour récupérer de l’API principale. Nous sommes également contraignant les méthodes nextPage() et handleDelete() à this sorte qu’ils seront accessibles depuis le code HTML.
Ensuite, ajoutez la méthode de componentDidMount() et un appel à getCustomers() au sein de la classe de CustomersList , avant l’accolade fermante.
La méthode componentDidMount() est une méthode de cycle de vie du composant qui est appelée lorsque le composant est créé et inséré dans le DOM. getCustomers() appelle l’objet Service clients pour obtenir la première page de données et le lien de la page suivante depuis le backend de Django :
~/djangoreactproject/frontend/SRC/CustomersList.js
…
componentDidMount() {
var self = this;
customersService.getCustomers().then(function (result) {
self.setState({ customers: result.data, nextPageURL: result.nextlink})
});
}
Maintenant, ajoutez la méthode handleDelete() , qui gère la suppression d’un client, sous componentDidMount():
~/djangoreactproject/frontend/SRC/CustomersList.js
…
handleDelete(e,pk){
var self = this;
customersService.deleteCustomer({pk : pk}).then(()=>{
var newArr = self.state.customers.filter(function(obj) {
return obj.pk !== pk;
});
self.setState({customers: newArr})
});
}
La méthode handleDelete() appelle la méthode deleteCustomer() pour supprimer un client à l’aide de son pk (clé primaire). Si l’opération est réussie, le tableau de customers est filtré pour le client supprimé.
Ajoutez ensuite une méthode nextPage() pour obtenir les données pour la page suivante et de mettre à jour le lien vers la page suivante :
~/djangoreactproject/frontend/SRC/CustomersList.js
…
nextPage(){
var self = this;
customersService.getCustomersByURL(this.state.nextPageURL).then((result) => {
self.setState({ customers: result.data, nextPageURL: result.nextlink})
});
}
La méthode nextPage() appelle une méthode getCustomersByURL() qui prend l’URL de la page suivante de l’objet state, this.state.nextPageURLet met à jour le tableau des customers avec les données retournées.
Enfin, ajoutez le composant méthode render() , qui restitue une table de clients de l’état du composant :
~/djangoreactproject/frontend/SRC/CustomersList.js
…
render() {
return (
# | First Name | Last Name | Phone | Address | Description | Actions | |
---|---|---|---|---|---|---|---|
{c.pk} | {c.first_name} | {c.last_name} | {c.phone} | {c.email} | {c.address} | {c.description} |
Update |
);
}
Il s’agit de l’intégralité du contenu du fichier :
~/djangoreactproject/frontend/SRC/CustomersList.js
import React, { Component } from ‘react’;
import CustomersService from ‘./CustomersService’;
const customersService = new CustomersService();
class CustomersList extends Component {
constructor(props) {
super(props);
this.state = {
customers: [],
nextPageURL: ”
};
this.nextPage = this.nextPage.bind(this);
this.handleDelete = this.handleDelete.bind(this);
}
componentDidMount() {
var self = this;
customersService.getCustomers().then(function (result) {
console.log(result);
self.setState({ customers: result.data, nextPageURL: result.nextlink})
});
}
handleDelete(e,pk){
var self = this;
customersService.deleteCustomer({pk : pk}).then(()=>{
var newArr = self.state.customers.filter(function(obj) {
return obj.pk !== pk;
});
self.setState({customers: newArr})
});
}
nextPage(){
var self = this;
console.log(this.state.nextPageURL);
customersService.getCustomersByURL(this.state.nextPageURL).then((result) => {
self.setState({ customers: result.data, nextPageURL: result.nextlink})
});
}
render() {
return (
# | First Name | Last Name | Phone | Address | Description | Actions | |
---|---|---|---|---|---|---|---|
{c.pk} | {c.first_name} | {c.last_name} | {c.phone} | {c.email} | {c.address} | {c.description} |
Update |
);
}
}
export default CustomersList;
Maintenant que nous avons créé le composant CustomersList pour l’affichage de la liste des clients, nous pouvons ajouter le composant cette poignées client création et mises à jour.
Étape 8 — Ajoutant le client créer et mettre à jour réagissent composant
Dans cette étape, nous allons créer le composant CustomerCreateUpdate , qui se chargera de créer et mettre à jour des clients. Elle le fera en fournissant un formulaire qui permet aux utilisateurs d’entrer des données sur un nouveau client ou mettre à jour une entrée existante.
Dans frontend/src, créez un fichier CustomerCreateUpdate.js :
nano ~/djangoreactproject/frontend/src/CustomerCreateUpdate.js
Ajoutez le code suivant pour créer un composant de React, importation de React et Component:
~/djangoreactproject/frontend/SRC/CustomerCreateUpdate.js
import React, { Component } from ‘react’;
Nous pouvons aussi importer et instanciez la classe CustomersService que nous avons créé à l’étape précédente, qui fournit des méthodes que l’interface avec l’API REST backend :
~/djangoreactproject/frontend/SRC/CustomerCreateUpdate.js
…
import CustomersService from ‘./CustomersService’;
const customersService = new CustomersService();
Ensuite, créez un composant CustomerCreateUpdate qui s’étend de Component pour créer et mettre à jour les clients :
~/djangoreactproject/frontend/SRC/CustomerCreateUpdate.js
…
class CustomerCreateUpdate extends Component {
constructor(props) {
super(props);
}
}
export default CustomerCreateUpdate;
Dans la définition de classe, ajoutez la méthode render() du composant, qui restitue un formulaire HTML qui tire ses informations sur le client :
~/djangoreactproject/frontend/SRC/CustomerCreateUpdate.js
…
render() {
return (
);
}
Pour chaque élément d’entrée du formulaire, la méthode ajoute une propriété ref pour accéder et définir la valeur de l’élément form.
Ensuite, au-dessus de la méthode render() , définissez une méthode de handleSubmit(event) , afin que vous ayez la fonctionnalité correcte lorsqu’un utilisateur clique sur le bouton Envoyer :
~/djangoreactproject/frontend/SRC/CustomerCreateUpdate.js
…
handleSubmit(event) {
const { match: { params } } = this.props;
if(params && params.pk){
this.handleUpdate(params.pk);
}
else
{
this.handleCreate();
}
event.preventDefault();
}
…
La méthode handleSubmit(event) gère l’envoi du formulaire et, selon l’itinéraire, appelle la méthode handleUpdate(pk) pour mettre à jour le client avec le passé pk, ou la méthode handleCreate() pour créer un nouveau client. Nous allons définir ces méthodes peu de temps.
Retour sur le constructeur de composants, lier la méthode nouvellement ajouté handleSubmit() à this donc vous pouvez y accéder dans votre formulaire :
~/djangoreactproject/frontend/SRC/CustomerCreateUpdate.js
…
class CustomerCreateUpdate extends Component {
constructor(props) {
super(props);
this.handleSubmit = this.handleSubmit.bind(this);
}
…
Définissez ensuite la méthode handleCreate() pour créer un client d’après les données de formulaire. Au-dessus de la méthode handleSubmit(event) , ajoutez le code suivant :
~/djangoreactproject/frontend/SRC/CustomerCreateUpdate.js
…
handleCreate(){
customersService.createCustomer(
{
“first_name”: this.refs.firstName.value,
“last_name”: this.refs.lastName.value,
“email”: this.refs.email.value,
“phone”: this.refs.phone.value,
“address”: this.refs.address.value,
“description”: this.refs.description.value
}).then((result)=>{
alert(“Customer created!”);
}).catch(()=>{
alert(‘There was an error! Please re-check your form.’);
});
}
…
On servira de la méthode handleCreate() pour créer un client à partir des données saisies. Il appelle la méthode correspondante de CustomersService.createCustomer() qui lance l’appel réel de l’API pour le backend pour créer un client.
Ensuite, sous la méthode de handleCreate() , définir la méthode handleUpdate(pk) pour implémenter les mises à jour :
~/djangoreactproject/frontend/SRC/CustomerCreateUpdate.js
…
handleUpdate(pk){
customersService.updateCustomer(
{
“pk”: pk,
“first_name”: this.refs.firstName.value,
“last_name”: this.refs.lastName.value,
“email”: this.refs.email.value,
“phone”: this.refs.phone.value,
“address”: this.refs.address.value,
“description”: this.refs.description.value
}
).then((result)=>{
alert(“Customer updated!”);
}).catch(()=>{
alert(‘There was an error! Please re-check your form.’);
});
}
La méthode updateCustomer() met à jour un client par pk en utilisant les nouvelles informations du formulaire d’informations client. Il appelle la méthode customersService.updateCustomer() .
Ajoutez ensuite une méthode componentDidMount() . Si le les visites de l’utilisateur un customer/:pk route, nous voulons remplir le formulaire avec les informations relatives au client à l’aide de la clé primaire de l’URL. Pour ce faire, nous pouvons ajouter la méthode getCustomer(pk) après que le composant obtient monté dans le cas du cycle de vie des componentDidMount(). Ajoutez le code suivant sous le constructeur de composants à ajouter cette méthode :
~/djangoreactproject/frontend/SRC/CustomerCreateUpdate.js
…
componentDidMount(){
const { match: { params } } = this.props;
if(params && params.pk)
{
customersService.getCustomer(params.pk).then((c)=>{
this.refs.firstName.value = c.first_name;
this.refs.lastName.value = c.last_name;
this.refs.email.value = c.email;
this.refs.phone.value = c.phone;
this.refs.address.value = c.address;
this.refs.description.value = c.description;
})
}
}
Il s’agit de l’intégralité du contenu du fichier :
~/djangoreactproject/frontend/SRC/CustomerCreateUpdate.js
import React, { Component } from ‘react’;
import CustomersService from ‘./CustomersService’;
const customersService = new CustomersService();
class CustomerCreateUpdate extends Component {
constructor(props) {
super(props);
this.handleSubmit = this.handleSubmit.bind(this);
}
componentDidMount(){
const { match: { params } } = this.props;
if(params && params.pk)
{
customersService.getCustomer(params.pk).then((c)=>{
this.refs.firstName.value = c.first_name;
this.refs.lastName.value = c.last_name;
this.refs.email.value = c.email;
this.refs.phone.value = c.phone;
this.refs.address.value = c.address;
this.refs.description.value = c.description;
})
}
}
handleCreate(){
customersService.createCustomer(
{
“first_name”: this.refs.firstName.value,
“last_name”: this.refs.lastName.value,
“email”: this.refs.email.value,
“phone”: this.refs.phone.value,
“address”: this.refs.address.value,
“description”: this.refs.description.value
}
).then((result)=>{
alert(“Customer created!”);
}).catch(()=>{
alert(‘There was an error! Please re-check your form.’);
});
}
handleUpdate(pk){
customersService.updateCustomer(
{
“pk”: pk,
“first_name”: this.refs.firstName.value,
“last_name”: this.refs.lastName.value,
“email”: this.refs.email.value,
“phone”: this.refs.phone.value,
“address”: this.refs.address.value,
“description”: this.refs.description.value
}
).then((result)=>{
console.log(result);
alert(“Customer updated!”);
}).catch(()=>{
alert(‘There was an error! Please re-check your form.’);
});
}
handleSubmit(event) {
const { match: { params } } = this.props;
if(params && params.pk){
this.handleUpdate(params.pk);
}
else
{
this.handleCreate();
}
event.preventDefault();
}
render() {
return (
);
}
}
export default CustomerCreateUpdate;
Avec le composant CustomerCreateUpdate créé, nous pouvons mettre à jour la principale composante de App pour ajouter des liens vers les différents éléments que nous avons créé.
Étape 9-Mise à jour le composant de l’application principale
Dans cette section, nous mettrons à jour le composant de App de notre application pour créer des liens vers les composants que nous avons créé lors des étapes précédentes.
Dans le dossier frontend , exécutez la commande suivante pour installer le Routeur réagir, qui vous permet d’ajouter le routage et la navigation entre les différentes composantes de réagir :
cd ~/djangoreactproject/frontend
npm install –save react-router-dom
Ensuite, ouvrez ~/djangoreactproject/frontend/src/App.js:
nano ~/djangoreactproject/frontend/src/App.js
Supprimer tout ce qui est là et ajoutez le code suivant pour importer les classes nécessaires pour l’ajout de routage. Il s’agit de BrowserRouter, qui crée un composant de routeur et la Route, ce qui crée un composant de l’itinéraire :
~/djangoreactproject/frontend/SRC/App.js
import React, { Component } from ‘react’;
import { BrowserRouter } from ‘react-router-dom’
import { Route, Link } from ‘react-router-dom’
import CustomersList from ‘./CustomersList’
import CustomerCreateUpdate from ‘./CustomerCreateUpdate’
import ‘./App.css’;
BrowserRouter synchronise l’interface utilisateur avec l’URL à l’aide de l’ HTML5 history API.
Ensuite, créer une disposition de base qui fournit le composant de base d’être enveloppé par le composant de BrowserRouter :
~/djangoreactproject/frontend/SRC/App.js
…
const BaseLayout = () => (
)
Nous utilisons le composant Route pour définir les routes de notre application ; le composant routeur devrait se charger une fois qu’une correspondance est trouvée. Chaque route a besoin d’un path pour spécifier le chemin d’accès soit mis en correspondance et un component de spécifier le composant de chargement. La propriété exact raconte le routeur pour faire correspondre le chemin exact.
Enfin, créez le composant de App , la racine ou le composant de niveau supérieur de notre application de réagir :
~/djangoreactproject/frontend/SRC/App.js
…
class App extends Component {
render() {
return (
);
}
}
export default App;
Nous avons enveloppé le composant BaseLayout avec le composant BrowserRouter étant donné que notre application est destinée à être exécuté dans le navigateur.
Le fichier ressemble à ceci :
~/djangoreactproject/frontend/SRC/App.js
import React, { Component } from ‘react’;
import { BrowserRouter } from ‘react-router-dom’
import { Route, Link } from ‘react-router-dom’
import CustomersList from ‘./CustomersList’
import CustomerCreateUpdate from ‘./CustomerCreateUpdate’
import ‘./App.css’;
const BaseLayout = () => (
)
class App extends Component {
render() {
return (
);
}
}
export default App;
Après avoir ajouté le routage à notre application, nous sommes maintenant prêts à tester l’application. Accédez à http://localhost:3000. Vous devriez voir la première page de l’application :
Application Home Page
Avec cette application en place, vous avez maintenant la base pour une application de CRM.
Conclusion
Dans ce didacticiel, vous avez créé une application de démonstration à l’aide de Django et réagir. Vous avez utilisé le framework Django reste à construire l’API REST, Axios à consommer de l’API et 4 Bootstrap pour style votre CSS. Vous pouvez trouver le code source de ce projet dans ce dépôt GitHub.
Cette configuration tutoriel utilisé séparé des applications front-end et back-end. Pour une approche différente à l’intégration de réagir avec Django, consultez ce tutoriel et ce tutoriel.
Pour plus d’informations sur la création d’une application avec Django, vous pouvez suivre la série de développement Django. Vous pouvez aussi consulter les docs officielles de Django.