Il s'agit de la deuxième partie de l'Exercice Express Sessions.
Nous avons terminé la première partie plus tôt,
où nous avons ajouté la prise en charge des
sessions Express, et nous utilisons les sessions Express comme moyen de suivre les utilisateurs côté serveur
et de reconnaître les demandes entrantes des utilisateurs.
Dans cet exercice, nous ne nous concentrons pas tellement sur les sessions Express elles-mêmes,
mais nous chercherons un moyen d'étendre notre serveur API REST express
pour prendre en charge un nouveau modèle d'enregistrement et d'authentification des utilisateurs.
Nous allons donc introduire un nouveau modèle d'utilisateur et un nouveau schéma dans notre application.
Nous avons déjà la route des utilisateurs slash que
le générateur express a déjà monté le routeur d'un utilisateur.
Donc, nous allons tirer parti de cela, puis mettre à jour cela
pour prendre en charge l'enregistrement de nouveaux utilisateurs, l'
authentification d'un utilisateur existant,
et également la déconnexion d'un utilisateur de notre site serveur.
Par conséquent, nous allons examiner les sessions Express comme un moyen de suivre les utilisateurs une fois que l'utilisateur se connecte,
puis lorsque l'utilisateur se déconnecte,
la session sera supprimée du système.
Alors, comment pouvons-nous faire cette extension dans cet exercice ?
Allons le découvrir.
En continuant avec notre serveur d'API REST express,
allons maintenant dans les modèles et ajoutons un nouveau fichier nommé user.js.
C' est le fichier où nous allons créer le schéma utilisateur et le modèle.
Nous allons créer un schéma utilisateur simple qui suit le nom d'utilisateur et le mot de passe,
ainsi qu'un indicateur qui est défini pour indiquer
si l'utilisateur est un administrateur ou un utilisateur normal.
Donc, c'est une façon de distinguer les différents types d'utilisateurs.
Donc, dans ce fichier, nous
allons d'abord exiger Mongoose parce que nous créons un schéma Mongoose,
puis nous allons créer un schéma nommé schéma Mongoose,
puis nous allons dire utilisateur var.
C' est donc le schéma utilisateur que nous allons créer,
et nous allons dire nouveau schéma utilisateur.
Le schéma utilisateur sera défini comme je viens de le mentionner,
avec trois champs ici appelés nom d'utilisateur
qui serait évidemment de la chaîne de type,
et c'est un champ obligatoire,
et c'est un champ unique.
Vous ne voulez pas deux utilisateurs avec le même nom d'utilisateur dans votre système,
donc nous créons le nom d'utilisateur et ensuite le deuxième champ est le champ mot de passe.
Maintenant, bien sûr, vous pouvez étendre
ce schéma utilisateur pour permettre à l'utilisateur de suivre son profil entier,
mais nous le ferons dans l'un des exercices ultérieurs, pour le moment,
un utilisateur est reconnu dans le système par simplement le nom d'utilisateur et le mot de passe.
Ainsi, le mot de passe est de la chaîne de type et est ensuite requis.
Le troisième champ que je vais utiliser est appelé l'admin.
Donc, l'administrateur est du type booléen,
et nous dirons false par défaut.
Ainsi, par défaut, lorsqu'un utilisateur est créé,
un nouvel utilisateur est créé,
l'indicateur admin sera défini sur false.
Vous pouvez définir explicitement la valeur true à partir de
votre code afin de marquer un utilisateur en tant qu'utilisateur administratif.
Peut-être pourriez-vous fournir des privilèges supplémentaires à un utilisateur administratif,
ou peut-être autoriser l'utilisateur administrateur à effectuer
certaines opérations que les utilisateurs normaux ne le feraient pas.
Nous allons regarder cela dans l'un des exercices ultérieurs,
pour le moment, c'est le schéma utilisateur que nous avons créé,
créons un module à partir de cela et exportons à partir de
ce module un modèle Mongoose de l'utilisateur nom.
Donc, c'est le modèle Mongoose et le schéma est
le schéma utilisateur que nous venons de définir un peu plus tôt.
Donc, c'est ainsi que nous définissons notre schéma utilisateur.
Donc, maintenant que nous avons défini notre schéma utilisateur,
allons dans le routeur qui a déjà été configuré
par le générateur express lorsqu'il génère cette application express.
Donc, si vous allez dans le dossier routes,
vous verrez ce fichier appelé users.js.
Donc, ce fichier users.js sera étendu pour créer le routeur.
Donc, juste là ce que je vais faire est d'importer l'analyseur de corps,
puis ils vont déclarer le routeur express,
et puis nous dirons également importer
le schéma utilisateur et le
modèle de l'utilisateur de modèles utilisateur,
puis pour le routeur express, nous dirons,
routeur utiliser l'analyseur de corps.
Donc, maintenant que nous avons déclaré l'analyseur de corps là-dedans,
nous allons laisser cette partie en tant que telle,
plus tard nous allons modifier ceci pour permettre
à l'administrateur de pouvoir récupérer
tous les utilisateurs qui sont enregistrés dans le système mais pour le moment,
nous allons quitter cette route en tant que telle.
Nous allons ajouter quelques autres routes ici,
donc nous allons dire, « Poste de routeur ».
Nous prendrons donc en charge la post-opération sur un itinéraire appelé inscription et comme vous vous y attendez,
cette route d'inscription permettra à un utilisateur de s'
inscrire sur le système, donc cela prendra en charge l'inscription de l'utilisateur.
Donc, nous allons dire, « Rec, res, suivant. »
Et donc ce serait l'inscription de post routeur,
les méthodes restantes ne seront pas autorisées sur la partie de fin d'inscription.
Donc, pour y accéder,
puisque ce routeur d'utilisateurs est monté sur les utilisateurs de barre oblique,
nous spécifierons ce point de terminaison comme slash utilisateurs slash sup,
et c'est le point final qui sera utilisé pour inscrire de nouveaux utilisateurs dans le système.
Donc, la première chose que nous allons faire est d'utiliser
la méthode utilisateur et l'attente est que pour un utilisateur de s'inscrire,
le nom d'utilisateur et le mot de passe seront fournis sous la forme d'une chaîne JSON
dans le corps de la demande de publication entrante.
Donc, à partir du corps,
puisque le corps aurait déjà été analysé par l'analyseur de corps,
donc à partir du corps,
vérifiera d'abord que
l'utilisateur avec ce nom d'utilisateur n'existe pas dans le système.
Si l'utilisateur avec ce nom d'utilisateur existe,
vous essayez d'inscrire un utilisateur en double
et cela ne devrait pas être autorisé dans le système.
Donc, nous allons dire, « Les utilisateurs en trouvent un », puis nous allons essayer de trouver s'
il y a un utilisateur avec le nom d'utilisateur qui a été
sélectionné par le client qui essaie d'inscrire un nouvel utilisateur.
Si l'utilisateur existe déjà,
il est évident que vous n'autorisez pas le nouvel utilisateur à s'inscrire avec le même nom d'utilisateur.
Donc, nous allons dire, « Alors utilisateur. »
Donc, cela retournera l'utilisateur ici et à l'intérieur de ce champ utilisateur,
alors nous allons vérifier le fait que l'utilisateur existe déjà,
puis laissez-moi attraper l'erreur ici.
Donc, nous allons dire, « Attraper erreur », puis, « prochaine erreur ».
Donc, nous allons simplement le transmettre au gestionnaire d'erreurs là-bas.
Donc, si cette recherche pour l'utilisateur renvoie le champ utilisateur,
si l'utilisateur n'est pas égal à null.
Donc, si l'utilisateur qui est renvoyé par cette recherche
n'est pas nul, cela signifie que l'utilisateur avec ce nom d'utilisateur donné existe déjà,
donc vous ne devriez pas autoriser une inscription en double.
Donc, nous allons dire, « Var err nouvelle erreur. »
Et nous dirons, « Nom d'utilisateur req. body. »
Existe déjà. Donc, fondamentalement,
vous empêchez un utilisateur en double de s'inscrire, puis nous dirons
err.status 403 par rapport à l'interdit, puis quitterons,
appelant le gestionnaire d'erreur, prochaine erreur.
Sinon, cela signifie que l'utilisateur n'existe pas
, donc vous devriez autoriser l'utilisateur à être approuvé.
Donc, dans la partie autre,
nous allons dire, retourner User.create ().
Nous allons créer un nouvel utilisateur avec le nom d'utilisateur défini sur req.body.username,
puis laissez-moi le mettre dans la ligne suivante afin que ce soit plus clair pour vous,
et nous dirons mot de passe : req.body.password.
Maintenant, nous savons déjà que l'indicateur admin par défaut sera défini sur false,
donc nous allons le laisser en tant que tel,
et cela permettra à notre nouvel utilisateur d'être inscrit et lorsque le nouvel utilisateur sera inscrit,
cela retournera une promesse et à l'intérieur du « puis » nous gérerons cette promesse ici.
Donc, cela va retourner la promesse de
ce « puis » et ensuite nous allons la gérer dans le prochain « puis » ici.
Dire alors, RES.statusCode est 200,
RES.setHeader et nous dirons application/json de type de contenu
et nous dirons, res.json (statut : Enregistrement réussi),
et si vous voulez,
nous pouvons charger l'utilisateur dans
ce message de réponse ici comme une propriété dans le json.
Sera que l'inscription a réussi.
Ensuite, s'il y a une erreur dans
cette opération dira « prochaine erreur ».
Donc, cela va gérer l'erreur.
Si la promesse ne résout pas avec succès,
alors sera gérée par cela. Alors c'est tout.
Donc, ici, nous avons un moyen pour l'utilisateur de s'inscrire.
Ainsi, pour que l'utilisateur s'inscrive,
l'utilisateur fera un post sur /users/inscription et dans le corps du message,
le client inclura une chaîne json
avec les propriétés de nom d'utilisateur et de mot de passe dans cette chaîne json.
C' est ainsi que vous vous inscrivez pour un nouvel utilisateur.
Maintenant, voyons comment nous allons nous connecter à l'utilisateur.
Maintenant, nous allons toujours utiliser les sessions Express que nous avons faites plus tôt pour suivre l'utilisateur.
Donc, pour la journalisation, un utilisateur dira « router.post » sur le point de fin/login.
Donc, sur le point de terminaison /login,
nous allons faire un router.post.
Nous allons évidemment au lieu de dire la fonction,
vous pouvez utiliser la fonction flèche ici pour le router.post,
je vais faire la même chose ici.
J' ai aimé les fonctions de flèche.
Donc, nous allons faire une fonction de flèche ici.
Donc, pour la connexion, comment se déroule la connexion ?
Donc, pour la connexion,
ce que nous allons faire est que nous allons aller au fichier app.js et puis à l'intérieur de cette authentification,
nous faisions cela s'inscrire pour l'utilisateur là-bas.
Donc, ce que je vais faire, c'est que je vais copier
tout ça parce que je ne ferais pas tout ça de toute façon.
Donc, plutôt laissez-moi copier tout le chemin à partir de ce point jusqu'au req.session.user.
Donc, la partie si de req.session.user je vais copier,
puis venir au users.js et pour la connexion.
C' est exactement comme ça que je vais faire l'authentification.
Donc, nous allons dire si ce n'est pas req.session.user.
Cela signifie donc que l'utilisateur ne s'est pas encore authentifié lui-même.
Ensuite, vous vous attendez à l'authentification de base comme
un mécanisme que l'utilisateur doit utiliser pour l'authentification.
Donc, nous allons dire var AuthHeader si ! AuthHeader alors nous allons soulever l'erreur,
sinon nous allons récupérer le nom d'utilisateur et le mot de passe de l'en-tête.
Maintenant, ici, nous faisions si le nom d'utilisateur est égal à admin et mot de passe est égal à mot de passe.
Mais maintenant, nous allons faire une recherche dans
la base de données pour voir si cet utilisateur en particulier existe.
Donc, au lieu de le faire ici,
au lieu de le faire si le nom d'utilisateur et le mot de passe,
nous dirons, user.findone
et nous dirons que le nom d'utilisateur est le nom d'utilisateur.
Donc, cette propriété est égale à ce nom d'utilisateur que nous venons de récupérer
et puis nous dirons alors utilisateur.
Donc, à l'intérieur de ce « puis ».
Donc, je vais déplacer ce code dans ce « puis » parce que
maintenant ce que je vais vérifier est maintenant que j'ai récupéré l'utilisateur,
je dois vérifier pour m'assurer que cet utilisateur est exactement ce que je cherche.
Donc, à ce stade,
nous allons d'abord vérifier que l'utilisateur n'est pas nul.
Donc, nous dirons si l'utilisateur est nul.
Donc, si l'utilisateur est nul,
ce qui signifie que nous ne pouvions pas trouver un utilisateur avec ce nom d'utilisateur particulier.
Donc, vous devrez retourner une erreur ici.
Alors laissez-moi juste copier cette partie et puis collez-la
ici et puis nous reviendrons dire var nouvelle erreur
et nous dirons que le nom
d'utilisateur de l'espace utilisateur
n'existe pas.
Donc, dans ce cas,
cet utilisateur n'existe pas donc je vais juste supprimer cette partie et
alors le statut d'erreur correspondant serait 403 ici.
C' est donc la première partie.
Si l'utilisateur est nul alors nous allons évidemment dire que l'utilisateur n'existe pas.
La deuxième partie que nous allons vérifier est Else si mot de passe utilisateur.
Donc, ce qui signifie que l'utilisateur existe à ce stade.
Donc, la deuxième vérification que nous allons faire est que le mot de passe de l'utilisateur n'est pas
égal à mot de passe alors.
Nous devons à nouveau indiquer l'erreur là.
Donc, l'erreur serait de dire,
dans ce cas, nous dirons
« votre mot de passe est incorrect ».
Donc c'est la deuxième partie ici.
Donc votre mot de passe est incorrect, puis la dernière partie.
Nous dirons « autre ».
Alors laissez-moi mettre en retrait ce code.
Donc, sinon si
user.username est un nom d'utilisateur qui devrait évidemment être vrai dans ce cas.
Ensuite, la deuxième partie,
user.password est égale au mot de passe qui devrait également être correct à ce stade.
Mais en tout cas,
je vais vérifier ce problème ici et cela ne se produira pas du tout dans ce cas.
Donc, au moment où vous atteignez ce point,
le nom d'utilisateur devrait être le
même que le nom d'utilisateur et le mot de passe devrait être le même qu'un mot de passe,
mais en tout cas j'ai mis dans une double vérification à ce stade juste pour être doublement sûr.
Ensuite, dans ce cas,
nous dirons que req.session.user est authentifié.
Donc, nous allons définir ceci sur authentifié
et aussi celui-ci, nous dirons que
RES.StatusCode est 200.
Nous avons donc réussi à authentifier l'utilisateur.
Donc, nous dirons que RES.StatusCode est 200, puis nous dirons Res.setHeader
Content-Type texte plain et
res.end, nous allons simplement envoyer un message disant « Vous êtes authentifié ».
C' est ça. Donc, cela couvre la partie alors de l'utilisateur finDone.
Donc, d'abord, nous vérifions que si l'utilisateur est nul,
cela signifie que nous n'avons pas pu trouver l'utilisateur,
donc nous retournons évidemment une erreur indiquant que le nom d'utilisateur n'existe pas.
Si le mot de passe de l'utilisateur ne correspond pas au mot de passe,
donc à ce stade,
l'utilisateur existe mais le mot de passe ne correspond pas, donc nous allons dire,
« Votre mot de passe est incorrect », et puis, enfin,
nous atteignons ce point alors le nom d'utilisateur et le mot de passe doivent être correctement identifiés.
Bien que je n'ai pas besoin de cette vérification, mais je l'ai juste mis en place et puis à ce stade,
je vais définir le req.session.user pour l'authentifier,
puis définir le code d'état sur 200 ce qui signifie que vous avez
réussi à authentifier l'utilisateur et ensuite vous pouvez terminer à ce stade.
Parce que c'est un alors,
je vais mettre un catch à ce stade,
donc nous allons dire catch error et si l'erreur se produit,
alors je vais simplement passer
l'erreur à
la suivante afin que le gestionnaire d'erreur puisse traiter l'erreur correctement.
Donc, cela se termine cet utilisateur finDone.
Maintenant, c'est le cas lorsque req.session.user n'est pas défini.
Si cela est déjà défini,
cela signifie que l'utilisateur est déjà connecté.
Donc, dans ce cas,
l'autre partie traite ici de la situation en disant que nous allons définir
le StatusCode sur 200
et le Content-Type sur text/plain, puis nous dirons,
« Vous êtes déjà authentifié. »
Donc, si vous atteignez cette autre partie,
vous viendrez ici parce que req.session.user n'est pas déjà null,
ce qui signifie que l'utilisateur a déjà été authentifié, ce
qui signifie que lorsque vous atteignez ce point,
l'utilisateur s'est déjà connecté plus tôt,
donc vous n'avez pas besoin de vérifier.
Donc, vous allez simplement dire,
« Vous êtes déjà authentifié », puis terminer à ce stade.
D' accord. Donc maintenant, la dernière méthode que nous allons implémenter est de déconnecter l'utilisateur.
Donc, nous allons faire un routeur .get sur /logout.
Vous devez vous demander pourquoi on fait un get sur
la déconnexion plutôt qu'un post que nous avons fait lors de la connexion ?
Lors de la connexion, vous devez soumettre le nom d'utilisateur et le mot de passe.
Pour la déconnexion, vous vous déconnectez simplement du système, de
sorte que vous n'avez pas besoin de fournir d'autres informations car
le serveur vous suit déjà en fonction de
votre ID de session et à l'intérieur de ce cookie de session ici.
C' est pourquoi nous n'avons pas
explicitement besoin d'envoyer d'autres informations dans le corps du message.
Donc, nous dirons si req.session donc ce qui signifie que la session doit exister
, sinon, vous essayez de déconnecter un utilisateur qui ne s'est pas connecté.
Donc ça n'a pas de sens.
Maintenant, la session elle-même fournit cette méthode
appelée destroy et lorsque vous appelez la méthode destroy,
la session est détruite et les informations sont
supprimées du côté serveur relatives à cette session.
Donc, ce qui signifie que si le client essaie à nouveau d'envoyer
les informations de session qui sont stockées sous la forme
d'un cookie signé côté client,
ce sera invalide.
Nous avons donc besoin d'une méthode pour supprimer le cookie qui est stocké du côté client.
Maintenant, cette opération supprimera
les informations de session du côté serveur afin que la session ne soit plus valide.
Donc, à ce stade,
nous dirons req.session.destroy et ensuite nous dirons, RES.clearCookie.
Ainsi, le ClearCookie est un moyen de demander au client de
supprimer le cookie et le nom du cookie est l'ID de session.
Ainsi, dans l'exercice précédent,
nous avons vu que le cookie était stocké avec le nom de l'ID de session côté client.
Nous demandons donc au client de supprimer ce cookie du
côté client dans le message de réponse, puis nous dirons,
res.redirect et nous allons le rediriger vers la page d'accueil ici.
Donc, c'est une façon de rediriger l'utilisateur pour entrer dans sa page standard,
donc par exemple, la page d'accueil de votre application.
Donc, c'est la façon dont vous gérez la déconnexion du système.
Si req.session n'existe pas,
cela signifie que vous n'êtes pas connecté,
donc nous devrons générer une erreur.
Donc, nous allons dire var err,
nouvelle erreur, « Vous n'êtes pas connecté »,
et nous allons définir l'état d'erreur sur 403,
c'est une opération interdite,
puis générer l'erreur au gestionnaire d'erreur, c'est tout.
Donc maintenant, vous voyez que nous avons étendu le routeur de l'utilisateur pour prendre en charge trois nouveaux terminaux,
le point de terminaison d'inscription qui permet à un utilisateur de s'inscrire,
le point de terminaison de connexion qui permet à un utilisateur inscrit de se connecter,
puis le point de terminaison de déconnexion qui permet à un utilisateur connecté de se déconnecter du système.
Dans le processus de déconnexion,
vous détruisez la session côté serveur,
vous effacez également le cookie côté client, de
sorte que le client ne peut pas être utilisé dans la session expirée pour essayer de contacter ce serveur.
Une correction mineure dans users.js,
cela devrait être var User require.. /models/user,
rappelez-vous que le fichier users.js se trouve dans le dossier routes, puis
le fichier user.js se trouve dans
le dossier models qui est d'un niveau, puis dans le dossier models.
Donc, ça devrait être.. /models/user,
alors faites cette correction mineure, c'est tout.
Nous avons modifié le fichier users.js,
maintenant la dernière chose que nous devons faire est d'aller réparer le fichier app.js.
Dans le fichier app.js de l'application,
si vous naviguez dans le fichier app.js,
vous verrez que nous avons
cet index barre oblique ici et slash utilisateurs ici après l'authentification.
Maintenant, cela ne fonctionnera pas pour nous parce que si vous devez vous inscrire,
alors l'utilisateur s'inscrirait et se connecterait avant que l'autorisation soit confirmée, de
toute façon si l'inscription et la connexion sont pour le processus d'inscription,
donc je vais les déplacer vers le haut avant l'étape d'authentification ici.
Donc, nous allons déplacer ça à cet endroit.
Ainsi, un utilisateur entrant peut accéder
au fichier d'index à la barre oblique et également accéder au point de terminaison des utilisateurs sans être authentifié,
mais tout autre point de terminaison,
l'utilisateur doit être authentifié,
donc c'est la façon dont nous avons configuré cela.
À l'intérieur de l'authentification de la fonction, nous dirons,
« Si ce n'est pas req.session.user », alors notez que cet endroit,
nous ne permettrions pas à l'utilisateur de venir ici sans que l'utilisateur s'est connecté.
Donc, si ce n'est pas req.session.user,
alors nous dirions simplement que vous n'êtes pas authentifié.
Cette authentification doit être effectuée en utilisant la méthode de connexion ici.
Donc, je vais enlever toute cette partie ici.
Donc, nous dirons, sinon req.session.user,
nous dirons que vous n'êtes pas authentifié et nous devrons donc envoyer une photo trois ici, ce
qui signifie que vous ne devriez jamais revenir à ce point du
tout sans que l'utilisateur se connecte.
Donc, nous dirons que vous n'êtes pas authentifié.
Rappelez-vous que vous devez vous authentifier en effectuant un POST sur
le point de fin de connexion des utilisateurs barre oblique.
Donc, nous dirons que vous n'êtes pas authentifié, sinon,
si req.session.user est égal à,
rappelez-vous que dans la fonction de connexion dans le
users.js, nous avons défini l'utilisateur de session suivante sur la chaîne authentifiée.
C' est donc ce que nous allons vérifier.
Nous dirons, si req.session.user est authentifié,
nous dirons ensuite, sinon vous n'êtes pas authentifié à nouveau.
Ensuite, nous enverrons un message interdit. C'est ça.
Donc, avec cette mise à jour,
mon fichier app.js est également prêt.
Maintenant, après avoir fait ces mises à jour,
allons vérifier comment fonctionne notre application maintenant.
Aller au terminal,
si votre serveur est en cours d'exécution, arrêtez-le, puis redémarrez votre serveur.
Mon serveur ne fonctionne pas pour le moment,
donc je vais dire npm start,
et mon serveur devrait être opérationnel.
Voyons maintenant comment nous allons accéder au serveur.
Aller à Postman, laissez-moi faire un GET sur
localhost : 3000/plats et puis vous verrez immédiatement
qu'il se plaint en disant que vous n'êtes pas authentifié.
Évidemment, je ne suis pas authentifié ici.
Laissez-moi essayer d'accéder seulement au localhost : 3000 et vous verrez
que, cette racine est disponible pour nous.
Maintenant, bien sûr, nous voulons d'abord enregistrer un utilisateur, puis nous connecter en
tant qu'utilisateur, puis obtenir l'accès au reste des points de terminaison de l'API REST.
Donc, d'abord, laissez-moi enregistrer un utilisateur.
Pour enregistrer l'utilisateur,
j'ai besoin de faire un POST à l'hôte local:3000/users/inscription.
Pour ce message POST,
dans le corps du message,
je dois inclure dans le corps
du message une chaîne JSON avec le nom d'utilisateur.
Donc, laissez-moi me connecter et
ensuite je vais juste utiliser le mot de passe comme mot de passe.
Il s'agit d'une inscription valide.
Donc, lorsque je m'inscrit
en tant qu'utilisateur avec cette information sous la forme d'une chaîne JSON incluse dans le corps du message,
laissez-moi voir que l'en-tête contient maintenant l'application de type de contenu,
JSON parce que j'ai configuré le JSON dans le corps du
message, puis envoyer le POST à l'inscription.
Ensuite, lorsque j'envoie le POST à l'inscription,
vous voyez immédiatement ce qui est retourné par le serveur ici.
Donc, vous voyez que le serveur est revenu en disant,
« Enregistrement réussi » et lui-même,
il me donne les détails de l'utilisateur ici.
Donc, c'est un enregistrement qui existe dans mon MongoDB et
notez que le type de modèle est le type de modèle utilisateur que nous avions configuré.
Donc, nous avons le nom d'utilisateur et
le mot de passe et l'indicateur admin comme vous pouvez le voir est défini sur false par défaut.
Une fois que nous avons enregistré l'utilisateur,
cet utilisateur est maintenant un utilisateur valide.
Donc, laissez-moi essayer de nouveau POST le même utilisateur et voir ce qui se passe.
Donc, quand je POST le même utilisateur évidemment,
là du côté serveur,
il répond en disant que cet utilisateur existe déjà.
Ainsi, vous pouvez voir que nous avons mis en place notre procédure d'inscription pour ne pas permettre à
l'utilisateur de dupliquer le registre avec le même ID utilisateur.
D' accord. Donc, c'est la deuxième partie.
Maintenant, faisons un login de l'utilisateur.
Pour faire une connexion de l'utilisateur,
laissez-moi supprimer le type de contenu, puis je vais également
supprimer le corps parce que pour la connexion, ce n'est pas nécessaire.
Donc, je ne remplit rien dans
l'en-tête, puis essaie de me connecter et quand j'ai essayé de me connecter,
il répond en disant que vous n'êtes pas authentifié.
Vous êtes non autorisé.
Maintenant, je dois me connecter.
Donc, c'est là que je peux utiliser l'authentification de base.
Donc, dans l'authentification de base,
je vais juste taper mon nom d'utilisateur et mon mot de
passe que je viens d'enregistrer à l'étape précédente, puis mettre à jour ma demande,
puis faire un POST sur la connexion.
Donc, quand je fais un POST sur la connexion,
vous voyez que le serveur répond en disant, « Vous êtes authentifié ».
Donc, à ce stade,
je peux effectuer les
requêtes GET, PUT, POST et DELETE sur tous les autres points de terminaison.
Donc, à ce stade, si je fais un GET sur le point de terminaison des plats,
vous verrez que cela renvoie
le champ vide car ma base de données est actuellement vide.
Permettez-moi d'effacer l'autorisation et aussi de l'en-tête supprimer
l'autorisation, puis faire le GET et c'est la boîte à outils très bien.
Donc, vous pouvez voir que je suis maintenant en mesure d'
accéder aux points de terminaison parce que je me suis connecté.
Alors maintenant, laissez-moi faire une déconnexion de l'utilisateur.
Donc, nous allons dire, localhost : 3000 et déconnexion.
Notez également que, dans les cookies,
un cookie a été installé à l'ID de session juste là.
Donc, ce cookie existe sur mon site client.
Alors maintenant, laissez-moi me déconnecter en disant GET localhost : 3000/users/déconnexion.
Donc, quand je fais une déconnexion de l'utilisateur,
vous verrez immédiatement que je suis redirigé vers
ce point de terminaison localhost:3000 et remarquerez également que le cookie a disparu.
Donc, quand je regarde les cookies,
vous voyez que le localhost,
le cookie est parti parce que de mon côté serveur quand je fais la déconnexion,
il renvoie un cookie clair de repos au côté client et donc le cookie est parti.
Maintenant, si j'essaie de faire un GET
sur le point de terminaison localhost:3000/plats,
cela ne fonctionnera pas car je ne suis pas authentifié.
Donc, cela vous montre comment vous pouvez étendre votre serveur Express pour
permettre aux utilisateurs de s'enregistrer eux-mêmes, puis permettre à l'utilisateur de se connecter au système,
puis également se déconnecter du système.
Côté serveur, vous suivez un utilisateur connecté à l'aide de la session et en utilisant
le cookie côté client et lorsque l'utilisateur
se déconnecte, le cookie est détruit côté client.
Avec cela, nous complétons cet exercice.
C' est un bon moment pour vous de faire un commit Git,
avec le message, les sessions Express deuxième partie.