Comment créer une application Web moderne pour gérer les informations client avec Django et réagir sur Ubuntu 18.04

L'auteur a sélectionnéOpen Sourcing Mental Illness Ltd pour recevoir un don dans le cadre du programmeWrite for DOnations.

introduction

Les gens utilisent différents types de périphériques pour se connecter à Internet et naviguer sur le Web. Pour cette raison, les applications doivent être accessibles à partir de divers emplacements. Pour les sites Web traditionnels, une interface utilisateur réactive suffit généralement, mais les applications plus complexes nécessitent souvent l'utilisation d'autres techniques et architectures. Celles-ci incluent notamment des applications frontales et frontales REST distinctes pouvant être implémentées en tant qu'applications Web côté client, applications Web progressives (PWA) ou applications mobiles natives.

Parmi les outils que vous pouvez utiliser pour créer des applications plus complexes, citons:

  • React, un framework JavaScript qui permet aux développeurs de créer des frontends web et natifs pour leurs backends API REST.

  • Django, un framework Web Python gratuit et open-source qui suit le modèle d'architecture logicielle demodel view controller (MVC).

  • Django REST framework, une boîte à outils puissante et flexible pour créer des API REST dans Django.

Dans ce didacticiel, vous allez créer une application Web moderne avec un serveur et une interface d’API REST distincts à l’aide de React, Django et de Django REST Framework. En utilisant React avec Django, vous pourrez bénéficier des dernières avancées en matière de développement JavaScript et front-end. Au lieu de créer une application Django utilisant un moteur de gabarit intégré, vous utiliserez React en tant que bibliothèque d'interface utilisateur, en tirant parti de son modèle DOM (Document Object Model) virtuel, de son approche déclarative et de ses composants permettant d'afficher rapidement les modifications apportées aux données.

L'application Web que vous allez créer stocke des enregistrements de clients dans une base de données et vous pouvez vous en servir comme point de départ pour une application CRM. Lorsque vous avez terminé, vous serez en mesure de créer, lire, mettre à jour et supprimer des enregistrements à l'aide d'une interface React stylisée avecBootstrap 4.

Conditions préalables

Pour compléter ce tutoriel, vous aurez besoin de:

[[step-1 -—- creation-a-python-virtual-environment-and-install-dependencies]] == Étape 1 - Création d'un environnement virtuel Python et installation de dépendances

Dans cette étape, nous allons créer un environnement virtuel et installer les dépendances requises pour notre application, y compris Django, le framework Django REST etdjango-cors-headers.

Notre application utilisera deux serveurs de développement différents pour Django et React. Ils fonctionneront sur des ports différents et fonctionneront comme deux domaines distincts. Pour cette raison, nous devons permettre àcross-origin resource sharing (CORS) d'envoyer des requêtes HTTP de React vers Django sans être bloqué par le navigateur.

Accédez à votre répertoire personnel et créez un environnement virtuel à l'aide du module Python 3 devenv:

cd ~
python3 -m venv ./env

Activez l'environnement virtuel créé à l'aide desource:

source env/bin/activate

Ensuite, installez les dépendances du projet avecpip. Ceux-ci comprendront:

  • Django: le cadre Web du projet.

  • Django REST framework: une application tierce qui construit des API REST avec Django.

  • django-cors-headers: un package qui active CORS.

Installez le framework Django:

pip install django djangorestframework django-cors-headers

Avec les dépendances de projet installées, vous pouvez créer le projet Django et l'interface React.

[[step-2 -—- creating-the-django-project]] == Étape 2 - Création du projet Django

Dans cette étape, nous générerons le projet Django à l’aide des commandes et des utilitaires suivants:

  • django-admin startproject project-name:django-admin est un utilitaire de ligne de commande utilisé pour accomplir des tâches avec Django. La commandestartproject crée un nouveau projet Django.

  • python manage.py startapp myapp:manage.py est un script utilitaire, automatiquement ajouté à chaque projet Django, qui effectue un certain nombre de tâches administratives: créer de nouvelles applications, migrer la base de données et servir le projet Django localement. Sa commandestartapp crée une application Django dans le projet Django. Dans Django, le termeapplication décrit un package Python qui fournit un ensemble de fonctionnalités dans un projet.

Pour commencer, créez le projet Django avecdjango-admin startproject. Nous appellerons notre projetdjangoreactproject:

django-admin startproject djangoreactproject

Avant de continuer, examinons la structure des répertoires de notre projet Django en utilisant la commandetree.

[.Remarque]##

Tip:tree est une commande utile pour visualiser les structures de fichiers et de répertoires à partir de la ligne de commande. Vous pouvez l'installer avec la commande suivante:

sudo apt-get install tree

Pour l'utiliser,cd dans le répertoire de votre choix et tapeztree ou indiquez le chemin vers le point de départ avectree /home/sammy/sammys-project.

Accédez au dossierdjangoreactproject dans la racine de votre projet et exécutez la commandetree:

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, plusieurs fichiers seront importants pour votre travail:

  • manage.py: le script utilitaire qui effectue un certain nombre de tâches administratives.

  • settings.py: Le fichier de configuration principal du projet Django dans lequel vous pouvez modifier les paramètres du projet. Ces paramètres incluent des variables telles queINSTALLED_APPS, unlist de chaînes désignant les applications activées pour votre projet. La documentation Django contient plus d'informations suravailable settings.

  • urls.py: ce fichier contient une liste de modèles d'URL et de vues associées. Chaque modèle mappe une connexion entre une URL et la fonction à appeler pour cette URL. Pour en savoir plus sur les URL et les vues, veuillez consulter notre tutoriel surHow To Create Django Views.

Notre première étape dans l'utilisation du projet sera de configurer les packages que nous avons installés à l'étape précédente, y compris le framework Django REST et le package Django CORS, en les ajoutant àsettings.py. Ouvrez le fichier avecnano ou votre éditeur préféré:

nano ~/djangoreactproject/djangoreactproject/settings.py

Accédez au paramètreINSTALLED_APPS et ajoutez les applicationsrest_framework etcorsheaders au 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 middlewarecorsheaders.middleware.CorsMiddleware du package CORS précédemment installé au paramètreMIDDLEWARE. Ce paramètre est une liste demiddlewares, une classe Python qui contient du code traité chaque fois que votre application Web traite 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 CORS. Le paramètreCORS_ORIGIN_ALLOW_ALL spécifie si vous souhaitez ou non autoriser CORS pour tous les domaines, etCORS_ORIGIN_WHITELIST est un tuple Python qui contient les URL autorisées. Dans notre cas, comme le serveur de développement React fonctionnera àhttp://localhost:3000, nous ajouterons de nouveaux paramètresCORS_ORIGIN_ALLOW_ALL = False etCORS_ORIGIN_WHITELIST('localhost:3000',) à notre fichiersettings.py. Ajoutez 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 lesdjango-cors-headers docs.

Enregistrez le fichier et quittez l'éditeur lorsque vous avez terminé.

Toujours dans le répertoire~/djangoreactproject, créez une nouvelle application Django appeléecustomers:

python manage.py startapp customers

Celui-ci contiendra lesmodels etviews pour la gestion des clients. Les modèles définissent les champs et les comportements des données de notre application, tandis que les vues permettent à notre application de gérer correctement les requêtes Web et de renvoyer les réponses requises.

Ensuite, ajoutez cette application à la liste des applications installées dans le fichiersettings.py de votre projet afin que Django la reconnaisse comme faisant partie du projet. Ouvrez à nouveausettings.py:

nano ~/djangoreactproject/djangoreactproject/settings.py

Ajoutez l'applicationcustomers:

~/djangoreactproject/djangoreactproject/settings.py

...
INSTALLED_APPS = [
    ...
    'rest_framework',
    'corsheaders',
    'customers'
]
...

Ensuite,migrate la base de données et démarrez le serveur de développement local. Migrations sont la manière de Django de propager les modifications que vous apportez à vos modèles dans votre schéma de base de données. Ces modifications peuvent inclure des éléments tels que 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, consultezHow To Create Django Models.

Migrer la base de données:

python manage.py migrate

Démarrez le serveur de développement local:

python manage.py runserver

Vous verrez une sortie semblable à celle-ci:

OutputPerforming 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.

Votre application Web sera exécutée à partir dehttp://127.0.0.1:8000. Si vous naviguez jusqu'à cette adresse dans votre navigateur Web, vous devriez voir la page suivante:

Django demo page

À ce stade, laissez l'application en cours d'exécution et ouvrez un nouveau terminal pour poursuivre le développement du projet.

[[step-3 -—- creation-the-react-frontend]] == Étape 3 - Création du frontend React

Dans cette section, nous allons créer l'application frontale de notre projet à l'aide de React.

React dispose d'un utilitaire officiel qui vous permet de générer rapidement des projets React sans avoir à configurer directementWebpack. Webpack est un ensemble de modules utilisé pour regrouper des ressources Web telles que du code JavaScript, des CSS et des images. En règle générale, avant de pouvoir utiliser Webpack, vous devez définir diverses options de configuration, mais grâce à l’utilitairecreate-react-app, vous n’avez pas à vous occuper directement de Webpack tant que vous n’avez pas décidé que vous avez besoin de plus de contrôle. Pour exécutercreate-react-app, vous pouvez utilisernpx, un outil qui exécute les binaires du packagenpm.

Dans votre deuxième terminal, assurez-vous que vous êtes dans le répertoire de votre projet:

cd ~/djangoreactproject

Créez un projet React appeléfrontend en utilisantcreate-react-app etnpx:

npx create-react-app frontend

Ensuite, naviguez dans votre application React et démarrez le serveur de développement:

cd ~/djangoreactproject/frontend
npm start

Votre application sera exécutée à partir dehttp://localhost:3000/:

React demo page

Laissez le serveur de développement React en cours d'exécution et ouvrez une autre fenêtre de terminal pour continuer.

Pour voir la structure de répertoires de l'ensemble du projet à ce stade, accédez au dossier racine et exécutez à nouveautree:

cd ~/djangoreactproject
tree

Vous verrez une structure comme celle-ci:

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 pour styliser l'interface React, nous l'inclurons donc dans le fichierfrontend/src/App.css, qui gère nos paramètres CSS. Ouvrez le fichier:

nano ~/djangoreactproject/frontend/src/App.css

Ajoutez lesimportuivants au début du fichier. Vous pouvez supprimer le contenu existant du fichier, bien que cela ne soit pas nécessaire:

~/djangoreactproject/frontend/src/App.css

@import  'https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css';

Ici,@import est une instruction CSS utilisée pour importer des règles de style à partir d'autres feuilles de style.

Maintenant que nous avons créé les applications frontale et frontale, créons le modèle client et certaines données de démonstration.

[[step-4 -—- creation-the-customer-model-and-initial-data]] == Étape 4 - Création du modèle client et des données initiales

Après avoir créé l'application Django et l'interface React, l'étape suivante consistera à créer le modèle Client, qui représente la table de base de données contenant les informations sur les clients. Vous n’avez pas besoin de SQL puisque DjangoObject Relational Mapper (ORM) gérera les opérations de base de données en mappant des classes et des variables Python sur des tables et des colonnes SQL. Ainsi, Django ORM résume les interactions SQL avec la base de données via une interface Python.

Activez à nouveau votre environnement virtuel:

cd ~
source env/bin/activate

Déplacez-vous dans le répertoirecustomers et ouvrezmodels.py, un fichier Python contenant 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.

L'API du modèle client est déjà importée dans le fichier grâce à l'instruction d'importationfrom django.db import models. Vous allez maintenant ajouter la classeCustomer, qui étendmodels.Model. Chaque modèle de Django est une classe Python qui étenddjango.db.models.Model.

Le modèleCustomer aura ces champs de base de données:

  • first_name - Le prénom du client.

  • last_name - Le nom de famille 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 à laquelle le client est ajouté.

Nous ajouterons également la fonction__str__(), qui définit comment le modèle sera affiché. Dans notre cas, ce sera avec le prénom du client. Pour plus d'informations sur la construction de classes et la définition d'objets, veuillez consulterHow To Construct Classes and Define Objects in 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, migrez la base de données pour créer les tables de la base de données. La commandemakemigrations crée les fichiers de migration dans lesquels les modifications du modèle seront ajoutées etmigrate applique les modifications des fichiers de migration à la base de données.

Revenez au dossier racine du projet:

cd ~/djangoreactproject

Exécutez ce qui suit pour créer les fichiers de migration:

python manage.py makemigrations

Vous obtiendrez une sortie qui ressemble à ceci:

Outputcustomers/migrations/0001_initial.py
    - Create model Customer

Appliquez ces modifications à la base de données:

python manage.py migrate

Vous verrez une sortie indiquant une migration réussie:

OutputOperations to perform:
  Apply all migrations: admin, auth, contenttypes, customers, sessions
Running migrations:
  Applying customers.0001_initial... OK

Ensuite, vous utiliserez undata migration file pour créer les données client initiales. Undata migration file est une migration qui ajoute ou modifie des données dans la base de données. Créez un fichier de migration de données vide pour l'applicationcustomers:

python manage.py makemigrations --empty --name customers customers

Vous verrez la confirmation suivante avec le nom de votre fichier de migration:

OutputMigrations for 'customers':
  customers/migrations/0002_customers.py

Notez que le nom de votre fichier de migration est0002_customers.py.

Ensuite, naviguez dans le dossier migrations de l'applicationcustomers:

cd ~/djangoreactproject/customers/migrations

Ouvrez le fichier de migration créé:

nano 0002_customers.py

Ceci est le contenu initial du fichier:

~/djangoreactproject/customers/migrations/0002_customers.py

from django.db import migrations

class Migration(migrations.Migration):
    dependencies = [
        ('customers', '0001_initial'),
    ]
    operations = [
    ]

L'instruction import importe l'APImigrations, une API Django pour créer des migrations, à partir dedjango.db, un package intégré qui contient des classes pour travailler avec des bases de données.

La classeMigration est une classe Python qui décrit les opérations exécutées lors de la migration des bases de données. Cette classe étendmigrations.Migration et a deux listes:

  • dependencies: contient les migrations dépendantes.

  • operations: contient les opérations qui seront exécutées lorsque nous appliquerons la migration.

Ensuite, ajoutez unmethod pour créer des données client de démonstration. Ajoutez la méthode suivante avant la définition de la classeMigration:

~/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 récupérons la classeCustomer de notre applicationcustomers et créons un client de démonstration à insérer dans la base de données.

Pour obtenir la classeCustomer, qui permettra la création de nouveaux clients, nous utilisons la méthodeget_model() de l'objetapps. L'objetapps représente lesregistry des applications installées et leurs modèles de base de données.

L'objetapps sera passé de la méthodeRunPython() lorsque nous l'utilisons pour exécutercreate_data(). Ajoutez la méthodemigrations.RunPython() à la liste videoperations:

~/djangoreactproject/customers/migrations/0002_customers.py

...
    operations = [
        migrations.RunPython(create_data),
    ]

RunPython() fait partie de l'API Migrations qui vous permet d'exécuter du code Python personnalisé dans une migration. Notre listeoperations spécifie que cette méthode sera exécutée lorsque nous appliquerons la migration.

Ceci est le fichier complet:

~/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 les migrations de données, consultez la documentation surdata migrations in Django

Pour migrer votre base de données, retournez dans le dossier racine de votre projet:

cd ~/djangoreactproject

Migrez votre base de données pour créer les données de démonstration:

python manage.py migrate

Vous verrez une sortie qui confirme la migration:

OutputOperations 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, reportez-vous àHow To Create Django Models.

Avec le modèle client et les données de démonstration créés, nous pouvons passer à la construction de l'API REST.

[[step-5 -—- creating-the-rest-api]] == Étape 5 - Création de l'API REST

Dans cette étape, nous allons créer l’API REST à l’aide de la structure Django REST. Nous allons créer plusieursAPI views différents. Une vue API est une fonction qui gère une demande ou un appel API, tandis qu'unAPI endpoint est une URL unique qui représente un point de contact avec le système REST. Par exemple, lorsque l'utilisateur envoie une demande GET à un noeud final d'API, Django appelle la fonction ou la vue API correspondante pour gérer la demande et renvoyer les résultats possibles.

Nous utiliserons égalementserializers. Unserializer dans Django REST Framework permet aux instances de modèles complexes et aux QuerySets d'être convertis au format JSON pour la consommation d'API. La classe sérialiseur peut également fonctionner dans l'autre sens, fournissant des mécanismes pour analyser et désérialiser les données dans des modèles Django et des QuerySets.

Nos points de terminaison API comprendront:

  • api/customers: ce point de terminaison est utilisé pour créer des clients et renvoie des ensembles paginés de clients.

  • api/customers/<pk>: ce point de terminaison est utilisé pour obtenir, mettre à jour et supprimer des clients uniques par clé primaire ou ID.

Nous allons également créer des URL dans le fichierurls.py du projet pour les points de terminaison correspondants (c'est-à-direapi/customers etapi/customers/<pk>).

Commençons par créer lesserializer class pour notre modèleCustomer.

Ajout de la classe de sérialiseur

La création d'une classe de sérialiseur pour notre modèleCustomer est nécessaire pour transformer les instances client et les QuerySets vers et depuis JSON. Pour créer la classe de sérialiseur, créez d'abord un fichierserializers.py dans l'applicationcustomers:

cd ~/djangoreactproject/customers/
nano serializers.py

Ajoutez le code suivant pour importer l'API des sérialiseurs et le modèleCustomer:

~/djangoreactproject/customers/serializers.py

from rest_framework import serializers
from .models import Customer

Ensuite, créez une classe de sérialiseur qui étendserializers.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 classeMeta spécifie le modèle et les champs à sérialiser:pk,first_name,last_name,email,phone,address ,description.

Ceci est le contenu complet 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 les vues API.

Ajout des vues API

Dans cette section, nous allons créer les vues d’API de notre application qui seront appelées par Django lorsque l’utilisateur visitera le noeud final correspondant à la fonction de vue.

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éé, ainsi que le modèleCustomer et les API Django et Django REST Framework.

Ensuite, ajoutez la vue pour le traitement des requêtes HTTP POST et GET:

~/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)

Nous utilisons d'abord le décorateur@api_view(['GET', 'POST']) pour créer une vue API qui peut accepter les requêtes GET et POST. Undecorator est une fonction qui prend une autre fonction et l'étend dynamiquement.

Dans le corps de la méthode, nous utilisons la variablerequest.method pour vérifier la méthode HTTP actuelle et exécuter la logique correspondante en fonction du type de requête:

  • S'il s'agit d'une requête GET, la méthode pagine les données à l'aide de DjangoPaginator, et renvoie 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 suivantes . Paginator est une classe Django intégrée qui pagine une liste de données dans des pages et fournit des méthodes pour accéder aux éléments de chaque page.

  • S'il s'agit d'une requête POST, la méthode sérialise les données client reçues, puis appelle la méthodesave() de l'objet sérialiseur. Il renvoie ensuite un objet Response, une instance deHttpResponse, avec un code d'état 201. Chaque vue que vous créez est responsable de la returing d'un objetHttpResponse. La méthodesave() enregistre les données sérialisées dans la base de données.

Pour plus d'informations sur lesHttpResponse et les vues, consultez cette discussion surcreating view functions.

Ajoutez maintenant la vue API qui sera responsable du traitement des demandes GET, PUT et DELETE pour obtenir, mettre à jour et supprimer des clients parpk (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 de@api_view(['GET', 'PUT', 'DELETE']) pour indiquer qu'il s'agit d'une vue API qui peut accepter les requêtes GET, PUT et DELETE.

La vérification dans le champrequest.method vérifie la méthode de requête et, en fonction de sa valeur, appelle la bonne logique:

  • S'il s'agit d'une demande GET, les données client sont sérialisées et envoyées à l'aide d'un objet Response.

  • S'il s'agit d'une demande PUT, la méthode crée un sérialiseur pour les nouvelles données client. Ensuite, il appelle la méthodesave() de l'objet sérialiseur créé. Enfin, il envoie un objet Response avec le client mis à jour.

  • S'il s'agit d'une requête DELETE, la méthode appelle la méthodedelete() de l'objet client pour le supprimer, puis renvoie un objet Response sans données.

Le fichier terminé 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 d'API

Nous allons maintenant créer les points de terminaison de l'API:api/customers/, pour interroger et créer des clients, etapi/customers/<pk>, pour obtenir, mettre à jour ou supprimer des clients uniques par leurspk.

Ouvrir~/djangoreactproject/djangoreactproject/urls.py:

nano ~/djangoreactproject/djangoreactproject/urls.py

Laissez ce qui est là, mais ajoutez l'importation aux vuescustomers 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 les URLapi/customers/ etapi/customers/<pk> auxurlpatterns list qui contiennent les URL de l'application:

~/djangoreactproject/djangoreactproject/urls.py

...

urlpatterns = [
    path('admin/', admin.site.urls),
    url(r'^api/customers/$', views.customers_list),
    url(r'^api/customers/(?P[0-9]+)$', views.customers_detail),
]

Avec nos points de terminaison REST créés, voyons comment nous pouvons les consommer.

[[step-6 -—- consumer-the-rest-api-with-axios]] == Étape 6 - Utilisation de l'API REST avec Axios

Dans cette étape, nous installeronsAxios, le client HTTP que nous utiliserons pour passer des appels API. Nous allons également créer une classe pour utiliser les points de terminaison d'API que nous avons créés.

Tout d'abord, désactivez votre environnement virtuel:

deactivate

Ensuite, accédez à votre dossierfrontend:

cd ~/djangoreactproject/frontend

Installezaxios à partir denpm en utilisant:

npm install axios --save

L’option--save ajoute la dépendanceaxios au fichierpackage.json de votre application.

Ensuite, créez un fichier JavaScript appeléCustomersService.js, qui contiendra le code pour appeler les API REST. Nous allons faire cela dans le dossiersrc, où le code d'application de notre projet sera hébergé:

cd src
nano CustomersService.js

Ajoutez le code suivant, qui contient des méthodes pour vous connecter à l'API Django REST:

~/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 classeCustomersService appellera les méthodes Axios suivantes:

  • getCustomers(): obtient la première page des clients.

  • getCustomersByURL(): récupère les clients par URL. Cela permet d'obtenir les pages suivantes des clients en passant des liens tels que/api/customers/?page=2.

  • getCustomer(): récupère un client par 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 React UI en créant un composantCustomersList.

[[step-7 -—- display-data-from-the-api-in-the-react-application]] == Étape 7 - Affichage des données de l'API dans l'application React

Dans cette étape, nous allons créer lesCustomersList Reactcomponent. Un composant React représente une partie de l'interface utilisateur; il vous permet également de diviser l'interface utilisateur en éléments indépendants réutilisables.

Commencez par créerCustomersList.js enfrontend/src:

nano ~/djangoreactproject/frontend/src/CustomersList.js

Commencez par importerReact etComponent pour créer un composant React:

~/djangoreactproject/frontend/src/CustomersList.js

import  React, { Component } from  'react';

Ensuite, importez et instanciez le moduleCustomersService que vous avez créé à l'étape précédente, qui fournit des méthodes qui s'interfacent avec le backend de l'API REST:

~/djangoreactproject/frontend/src/CustomersList.js

...
import  CustomersService  from  './CustomersService';

const  customersService  =  new  CustomersService();

Ensuite, créez un composantCustomersList qui étendComponent pour appeler l'API REST. Un composant React doitextend or subclass the Component class. Pour plus d'informations sur les classes E6 et l'héritage, veuillez consulter notre tutoriel surUnderstanding Classes in JavaScript.

Ajoutez le code suivant pour créer un composant React qui étendreact.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 desconstructor, nous initialisons l'objetstate. Cela contient les variables d'état de notre composant en utilisant uncustomersarray vide. Ce tableau contiendra les clients et unnextPageURL qui contiendra l'URL de la page suivante à récupérer depuis l'API back-end. Nous sommes aussibinding lesnextPage() et leshandleDelete()methods àthis donc ils seront accessibles depuis le code HTML.

Ensuite, ajoutez la méthodecomponentDidMount() et un appel àgetCustomers() dans la classeCustomersList, avant l'accolade fermante.

La méthodecomponentDidMount() 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 Django:

~/djangoreactproject/frontend/src/CustomersList.js

...
componentDidMount() {
    var  self  =  this;
    customersService.getCustomers().then(function (result) {
        self.setState({ customers:  result.data, nextPageURL:  result.nextlink})
    });
}

Ajoutez maintenant la méthodehandleDelete(), qui gère la suppression d'un client, en dessous decomponentDidMount():

~/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éthodehandleDelete() appelle la méthodedeleteCustomer() pour supprimer un client à l'aide de sespk (clé primaire). Si l'opération réussit, le tableaucustomers est filtré pour le client supprimé.

Ensuite, ajoutez une méthodenextPage() pour obtenir les données de la page suivante et mettez à jour le lien de 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éthodenextPage() appelle une méthodegetCustomersByURL(), qui prend l'URL de la page suivante de l'objet d'état,this.state.nextPageURL, et met à jour le tableaucustomers avec les données renvoyées.

Enfin, ajoutez le composantrender() method, qui restitue une table de clients à partir de l'état du composant:

~/djangoreactproject/frontend/src/CustomersList.js

...
render() {

    return (
    
{this.state.customers.map( c => )}
# First Name Last Name Phone Email Address Description Actions
{c.pk} {c.first_name} {c.last_name} {c.phone} {c.email} {c.address} {c.description} Update
); }

Ceci est le contenu complet 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 (
        
{this.state.customers.map( c => )}
# First Name Last Name Phone Email 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 composantCustomersList pour afficher la liste des clients, nous pouvons ajouter le composant qui gère la création et les mises à jour des clients.

[[step-8 -—- ajoutant-le-client-create-and-update-react-component]] == Étape 8 - Ajout du composant Customer Create and Update React

Dans cette étape, nous allons créer le composantCustomerCreateUpdate, qui gérera la création et la mise à jour des clients. Pour ce faire, il fournit un formulaire que les utilisateurs peuvent utiliser pour saisir des données sur un nouveau client ou mettre à jour une entrée existante.

Dansfrontend/src, créez un fichierCustomerCreateUpdate.js:

nano ~/djangoreactproject/frontend/src/CustomerCreateUpdate.js

Ajoutez le code suivant pour créer un composant React, en importantReact etComponent:

~/djangoreactproject/frontend/src/CustomerCreateUpdate.js

import  React, { Component } from  'react';

Nous pouvons également importer et instancier la classeCustomersService que nous avons créée à l'étape précédente, qui fournit des méthodes qui s'interfacent avec le backend de l'API REST:

~/djangoreactproject/frontend/src/CustomerCreateUpdate.js

...
import  CustomersService  from  './CustomersService';

const  customersService  =  new  CustomersService();

Ensuite, créez un composantCustomerCreateUpdate qui étendComponent 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éthoderender() du composant, qui restitue un formulaire HTML qui prend des informations sur le client:

~/djangoreactproject/frontend/src/CustomerCreateUpdate.js

...
render() {
        return (
          
); }

Pour chaque élément d'entrée de formulaire, la méthode ajoute une propriétéref pour accéder et définir la valeur de l'élément de formulaire.

Ensuite, au-dessus de la méthoderender(), définissez une méthodehandleSubmit(event) afin que vous ayez les fonctionnalités appropriées lorsqu'un utilisateur clique sur le bouton d'envoi:

~/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éthodehandleSubmit(event) gère la soumission du formulaire et, en fonction de l'itinéraire, appelle soit la méthodehandleUpdate(pk) pour mettre à jour le client avec lespk passés, soit la méthodehandleCreate() pour créer un nouveau client. Nous définirons ces méthodes sous peu.

De retour sur le constructeur du composant, liez la méthodehandleSubmit() nouvellement ajoutée àthis afin que vous puissiez 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);
}
...

Ensuite, définissez la méthodehandleCreate() pour créer un client à partir des données du formulaire. Au-dessus de la méthodehandleSubmit(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.');
        });
}

...

La méthodehandleCreate() sera utilisée pour créer un client à partir des données saisies. Il appelle la méthodeCustomersService.createCustomer() correspondante qui effectue l'appel d'API réel au backend pour créer un client.

Ensuite, sous la méthodehandleCreate(), définissez la méthodehandleUpdate(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éthodeupdateCustomer() mettra à jour un client parpk en utilisant les nouvelles informations du formulaire d'informations client. Il appelle la méthodecustomersService.updateCustomer().

Ensuite, ajoutez une méthodecomponentDidMount(). Si l'utilisateur visite un itinérairecustomer/:pk, nous souhaitons remplir le formulaire avec des informations relatives au client en utilisant la clé primaire de l'URL. Pour ce faire, nous pouvons ajouter la méthodegetCustomer(pk) après le montage du composant dans l'événement du cycle de vie decomponentDidMount(). Ajoutez le code suivant sous le constructeur du composant pour 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;
        })
    }
}

Ceci est le contenu complet 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;

Une fois le composantCustomerCreateUpdate créé, nous pouvons mettre à jour le composant principalApp pour ajouter des liens vers les différents composants que nous avons créés.

[[step-9 -—- update-the-main-app-component]] == Étape 9 - Mise à jour du composant principal de l'application

Dans cette section, nous mettrons à jour le composantApp de notre application pour créer des liens vers les composants que nous avons créés au cours des étapes précédentes.

Depuis le dossierfrontend, exécutez la commande suivante pour installer lesReact Router, ce qui vous permet d'ajouter le routage et la navigation entre les différents composants React:

cd ~/djangoreactproject/frontend
npm install --save react-router-dom

Ensuite, ouvrez~/djangoreactproject/frontend/src/App.js:

nano ~/djangoreactproject/frontend/src/App.js

Supprimez tout ce qui se trouve là et ajoutez le code suivant pour importer les classes nécessaires à l’ajout de routage. Ceux-ci incluentBrowserRouter, qui crée un composant de routeur, etRoute, qui crée un composant de route:

~/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 maintient l'interface utilisateur synchronisée avec l'URL en utilisant lesHTML5 history API.

Ensuite, créez une présentation de base qui fournit le composant de base à encapsuler par le composantBrowserRouter:

~/djangoreactproject/frontend/src/App.js

...

const  BaseLayout  = () => (

)

Nous utilisons le composantRoute pour définir les routes de notre application; le composant que le routeur doit charger une fois qu'une correspondance est trouvée. Chaque route a besoin d'unpath pour spécifier le chemin à rechercher et d'uncomponent pour spécifier le composant à charger. La propriétéexact indique au routeur de correspondre au chemin exact.

Enfin, créez le composantApp, le composant racine ou de niveau supérieur de notre application React:

~/djangoreactproject/frontend/src/App.js

...

class  App  extends  Component {

render() {
    return (
    
        
    
    );
}
}
export  default  App;

Nous avons encapsulé le composantBaseLayout avec le composantBrowserRouter puisque notre application est censée s'exécuter dans le navigateur.

Le fichier terminé 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 CRM.

Conclusion

Dans ce tutoriel, vous avez créé une application de démonstration utilisant Django et React. Vous avez utilisé la structure Django REST pour construire l'API REST, Axios pour utiliser l'API et Bootstrap 4 pour styliser votre CSS. Vous pouvez trouver le code source de ce projet dans ceGitHub repository.

Cette configuration de didacticiel a utilisé des applications distinctes, frontales et principales. Pour une approche différente de l'intégration de React avec Django, vérifiez cetutorial et cetutorial.

Pour plus d'informations sur la création d'une application avec Django, vous pouvez suivre lesDjango development series. Vous pouvez également consulter lesofficial Django docs.