Comme nous l'avons compris lors de la conférence précédente dans cette leçon,
notre objectif dans cette leçon est d'
intégrer le serveur API REST que nous avons déjà développé,
ainsi que l'accès à la base de données MongoDB.
Donc, nous allons commencer avec le serveur API REST
que nous avons construit dans la toute première leçon de ce module,
puis après avoir appris comment interagir de
notre application de noeud vers le serveur MongoDB en utilisant Mongoose,
nous allons développer notre serveur API REST plus loin pour intégrer
l'ensemble entre la requête du client entrant dans le serveur,
jusqu'à l'opération de base de données correspondante à effectuer,
puis construire et renvoyer la réponse à ce client à partir de notre site serveur.
Pour commencer bien sûr,
allez d'abord dans le dossier du serveur de confusion que nous avons déjà créé dans
le tout premier exercice de ce module dans la leçon de l'API REST,
puis, dans le dossier de confusion,
nous avons déjà construit le serveur API REST.
Maintenant, ce que nous ferions est d'emprunter
les modèles que nous avons développés dans l'exercice précédent,
le fichier dishes.js que nous avons développé dans l'exercice précédent,
copié sur le projet de serveur de confusion,
et aussi installer Bluebird Mongoose,
et un autre module appelé Mongoose monnaie, à notre projet.
Donc, en allant à notre dossier JS nœud,
nous allons d'abord dans le dossier Mongoose noeud,
et nous voyons que dans le sous-dossier des modèles du dossier Mongoose noeud,
nous avons le fichier dishes.js.
Je vais juste copier le dossier models,
puis passer au dossier du serveur de confusion,
puis percer simplement le dossier models dedans.
Donc, une fois que nous faisons cela,
alors le fichier dishes.js qui contient le schéma et le modèle du document plats,
sont intégrés dans notre serveur API REST.
Bien sûr, pour en faire usage,
nous devons installer le module de noeud Mongoose,
et un nouveau module de noeud appelé monnaie Mongoose dans notre projet.
Donc, aller au terminal dans le projet de serveur de confusion,
assurez-vous que votre terminal ou la fenêtre de commande se trouve
dans le projet de serveur de confusion où vous développez l'API REST plus tôt,
et dans ce projet, installons.
Donc, nous allons faire npm installer Mongoose,
puis, un nouveau module de noeud appelé comme monnaie Mongoose.
Le module de nœud de monnaie Mongoose,
et vu dans un autre type de schéma à notre application Mongoose, de
sorte que le Mongoose lui-même,
a certainement déjà intégré des types de schéma.
Nous avons vu l'utilisation du nombre, de
la chaîne et du booléen, et du tableau.
Maintenant, la monnaie mongoose ajoute en support pour la monnaie.
Maintenant, pourquoi aurions-nous besoin de ce soutien monétaire ?
Ainsi, ce module de monnaie Mongoose ajoute un nouveau type appelé comme le type de devise,
ce qui nous permet de stocker une valeur monétaire.
Puisque notre plat va contenir un prix,
c'est pourquoi je vais utiliser le module de monnaie Mongoose ici.
Maintenant, l'exercice ici,
nous allons illustrer l'utilisation du module de monnaie Mongoose,
vous pouvez lire plus de détails sur le module de noeud de monnaie Mongoose aussi,
dans la documentation de cela un lien vers lequel est fourni dans les ressources supplémentaires.
Donc, maintenant que nous avons installé ces modules de noeud,
Mongoose et Mongoose monnaie,
allons à notre application et configurons-la pour communiquer avec le serveur MongoDB.
Maintenant, assurez-vous que votre serveur MongoDB est opérationnel.
Donc, ici, vous voyez que
mon serveur MongoDB est en cours d'exécution dans un autre onglet de terminal sur mon ordinateur.
Si vous l'exécutez sur un ordinateur Windows,
assurez-vous qu'il est en cours d'exécution dans une autre commande Fenêtre de votre ordinateur Windows.
Aller à notre application dans l'éditeur,
nous allons d'abord commencer par le fichier app.js.
Maintenant, dans le fichier app.js,
c'est là que nous avons construit notre application express plus tôt.
Mais maintenant, cette négation supplémentaire n'est pas connectée au serveur MongoDB back-end.
Nous allons utiliser le module Mongoose,
afin d'établir la connexion avec le serveur.
Donc, en allant ici,
je vais ajouter le module require Mongoose ici.
Donc, nous allons dire, « Const Mongoose a besoin de Mongoose. »
Et puis aussi, puisque nous avons copié sur le dossier des modèles,
qui contient le fichier plats,
qui déclare le schéma des plats et le modèle.
Alors, laissez-moi importer la vaisselle.
Donc, nous allons dire, « nécessiter.Slash modèles plats. »
Donc, une fois que nous avons terminé cela, maintenant bien sûr,
nous devons établir la connexion avec le serveur.
Donc, configurez
l'URL mongodb// localhost7017/confusion,
tout comme nous l'avons fait avec l'exercice Mongoose,
puis nous dirons,
« Const connect, l'URL de connexion de Mongo ».
Donc, c'est exactement le même code que nous avons utilisé dans l'exercice précédent.
Ensuite, établissons la connexion.
Donc, nous allons dire, « se connecter », puis nous dirons,
« DB do it console log. »
Dire : « Connecté correctement au serveur. »
Et nous allons également gérer l'erreur ici.
Nous allons simplement faire un journal de la console de l'erreur ici, c'est tout.
Cela établira la connexion au serveur à partir de notre fichier app.js.
Donc, une fois que nous avons établi la connexion au serveur,
alors, ouvrons le fichier dishes.js à partir de nos modèles.
Maintenant, dans le fichier dishes.js,
pour utiliser
le module de noeud que nous venons d'installer.
Donc, nous allons dire, « Exiger la monnaie mongoose », et dire,
« Charger le type et Mongoose ».
Donc, ce que cela fera est de charger ce nouveau type de devise dans Mongoose.
Par la suite, nous pouvons dire const,
monnaie Mongoose types monnaie.
C' est ça. Donc, ce nouveau type,
le type de devise est ajouté dans Mongoose et cela ajoutera un nouveau type appelé
monnaie et alors je vais déclarer
cette monnaie constante comme monnaie de types de Mongoose.
Pour que je puisse utiliser cela dans la définition du schéma dans mon application.
Maintenant, dans ce cas,
le schéma commun restera exactement le même qu'avant, mais
le schéma plat comme vous le rappelez du fichier db.json.
Lorsque vous regardez la structure d'un document plat,
vous voyez que le document plat contient le nom et l'image qui, comme vous le voyez ici, est une chaîne,
une catégorie, une étiquette,
un prix, qui est un type de chaîne ici.
Mais nous allons déclarer ceci comme un type de devise,
une fonctionnalité qui comme vous vous attendez est une variable booléenne,
et une description qui est une chaîne, puis des commentaires
qui n'est rien d'autre qu'un tableau de type commentaires.
Maintenant, donc ce que nous allons maintenant faire est d'étendre le schéma plat pour
soutenir toutes ces diverses propriétés ou divers champs dans mon document json.
Donc nous avons déjà le nom.
Nous avons donc déjà la description en place.
Donc, nous devons ajouter dans les prochains, nous avons déjà les commentaires,
le tableau de commentaires du type de schéma de commentaire là-bas.
Donc, nous allons ajouter dans les prochains.
Donc, le prochain que nous allons ajouter est le type d'image,
qui serait de
la chaîne de type et
nous dirons nécessaire true.
Cela ajoute donc le type d'image.
Le suivant que j'ajouterai est la catégorie,
qui est aussi le type de chaîne.
Le suivant est l'étiquette,
qui est également ce type de chaîne.
Puisque tous ces éléments sont du même type et requis,
je les copie juste ici.
Ensuite, pour l'étiquette,
je dirais que ce n'est pas nécessaire mais à la
place je peux également spécifier une valeur par défaut si je veux.
Donc, je peux spécifier une valeur par défaut comme ça.
La valeur par défaut est une chaîne vide.
Donc, si je ne spécifie pas requis, je peux simplement spécifier une valeur par défaut ici.
Maintenant, en plus, le champ suivant que je vais introduire est le champ des prix.
Le champ de prix je vais déclarer le type comme devise.
Rappelons que nous avions déclaré le type de devise plus tôt
ici en exigeant d'abord
le module de monnaie Mongoose, puis en déclarant le type de devise.
Donc, c'est ainsi que vous utiliseriez le type de devise dans notre application.
Donc, nous allons dire que la monnaie de type de prix
et requise est vraie et alors je peux également spécifier la valeur minimale qui serait zéro.
Ensuite, le champ suivant est
le champ vedette qui serait de type booléen,
et la valeur par défaut sera false.
Donc, si mon document manque cela,
alors la valeur par défaut sera ajoutée dans le document ici.
Notez donc que j'ai maintenant élargi
le schéma plat en ajoutant le type d'image, la catégorie, l'
étiquette, le prix et la fonctionnalité pour correspondre à la
structure de l'exemple de document plat que je viens de vous montrer plus tôt.
Alors maintenant, mon schéma de vaisselle est prêt à être utilisé.
Alors, commençons maintenant à travailler sur mon routeur.
Où est le routeur ?
Vous rappelez que le routeur qui prend en charge les points de terminaison de l'API REST pour les plats de barre oblique,
le point de terminaison de l'API REST et les plats de
barre oblique, le point de terminaison de l'ID de barre oblique se trouve dans le
Donc, nous allons aller à plat router.jsfile et ensuite nous allons étendre le fichier dish router.js.
Donc, dans le routeur à plat avec Express et BodyParser,
je vais maintenant inclure Mongoose.
Donc, nous allons dire exiger Mongoose et
alors nous aurons besoin de plats modèle.
Où est le modèle des plats ?
Il est dans. /modèles/vaisselles.
Donc, il est là-dedans.
Donc, notez que nous sommes dans le dossier du routeur,
vous devez donc monter d'un niveau, puis aller dans
le dossier du modèle, puis le fichier dishes.js est juste là.
C' est donc ce que nous importons ici.
Donc maintenant, je peux mettre à jour mon routeur plat pour pouvoir interagir
avec le serveur MongoDB en utilisant
Mongoose et nous avons déjà importé le modèle de vaisselle dans mon routeur plat.
Donc, il est temps pour moi d'aller mettre à jour toutes les méthodes ici.
Donc, pour le routeur à plat,
la barre oblique qui signifie que la barre plats terminaison point.
Je vais supprimer tout cela d'ici, à la place,
je vais déclarer explicitement tous les différents points de terminaison.
Pour obtenir post put and delete, je vais gérer chacun d'eux indépendamment.
Donc, dans la méthode get,
je vais couper ça et ensuite dans la méthode get, que dois-je faire ?
Rappelons que nous avions défini méthode de Mongoose qui nous permet de trouver tous les plats.
Donc, lorsque vous effectuez une opération get sur le point de terminaison des plats barre oblique,
vous vous attendez à ce que tous les plats soient retournés
au client en réponse à la demande get.
Donc, je vais aller à la vaisselle et ensuite effectuer l'opération de recherche.
Donc maintenant vous voyez que depuis mon serveur Express,
j'accède à mon MongoDB.
Donc, fera une recherche et dans la recherche, je vais maintenant gérer la demande.
Donc, je peux dire
que les plats trouvent, puisque cela va rendre une promesse,
alors je peux gérer ça à l'intérieur ici.
Donc, je vais dire plat et donc si la promesse résout correctement,
je vais l'obtenir dans le puis et donc je vais dire plat et puis nous allons gérer le
code d'état res est 200 et puis nous allons dire le
type de contenu d'en-tête res set.
Puisque nous allons retourner la valeur en tant que json,
nous allons donc définir cela à l'application json.
Ok, ça va retourner un tableau de plats.
Donc, je peux simplement dire de la vaisselle et ensuite nous dirons res.json.
Donc, le res.json prendra comme entrée dans la chaîne json
, puis le renvoyer à mon client.
Donc, lorsque vous appelez res.json et fournissez la valeur, puis il
prendra simplement le paramètre que vous donnez ici et ensuite le renvoyer en tant que réponse json.
Il va mettre ces plats dans le corps
du message de réponse, puis le renvoyer au serveur.
Maintenant, nous pouvons gérer l'erreur
ici en disant l'erreur suivante.
Nous pouvons également faire une erreur de capture juste pour le bien de complet.
Je vais simplement mettre les deux en place ici, de
sorte que les deux soient traités comme tels.
Donc, si une erreur est renvoyée,
cela va simplement transmettre l'erreur
au gestionnaire d'erreur global pour mon application
et laisser cela s'inquiéter de la façon de gérer l'erreur.
Donc on va l'envoyer à ça.
Donc, vous voyez comment j'utilise l'opération de recherche et ensuite j'effectue la requête ici.
Maintenant, pour le poste,
comme vous l'auriez déjà prévu,
je vais faire des plats.create
parce que nous allons créer un nouveau plat ici.
Donc, rappelez-vous que nous avons déjà vu les plats créer l'
utilisation de la méthode plus tôt et rappelez-vous que l'analyseur de corps aurait
déjà analysé tout ce qui est dans le corps du message et l'a chargé
sur la propriété body de la requête.
Donc, je vais juste prendre le corps de la requête, puis l'analyser en tant que paramètre à ma
méthode dishes.create et gérer la valeur de retour.
Donc, nous dirons alors et cela rendrait
un plat et nous nous occuperons de ça ici.
Donc, nous dirons si les plats retournent correctement et si les plats affichés correctement, dira res res.
Ok, faisons un console.log pour notre propre usage.
Du côté serveur, nous allons faire un console.log disant « Dish Created » plat ici.
Nous allons enregistrer ce plat sur la console et ensuite nous dirons ces deux codes d'état de repos.
Nous allons juste copier ce code, puis le coller dedans et dans ce cas,
nous retournons le plat ici.
Le plat qui est entré en tant que paramètre ici, puis laisser
le client gérer cette valeur côté client,
tout ce qui est retourné dans le plat.
Maintenant, aussi, ils vont ajouter
ici et puis la prise.
Donc, c'est comme ça que nous gérons le poste.
Pour le PUT, parce que PUT n'est pas autorisé,
donc nous allons le laisser en tant que tel.
Pour DELETE, nous allons supprimer tous les plats.
Donc, nous allons dire, « vaisselles.Retirer. »
Il s'agit essentiellement d'une opération dangereuse.
Donc, vous supprimez tous les plats
du serveur et donc nous dirons,
« vaisselles.Retirer puis » et le « puis » recevra une réponse.
Donc, nous allons simplement dire, « resp ici » et la façon dont nous gérerions
cette réponse est simplement de prendre cette valeur et de la retourner au client.
Donc, nous allons dire, « RES.StatusCode 200 application de type de contenu json »,
puis nous allons simplement renvoyer la réponse au client et nous allons gérer l'erreur
comme nous l'avons fait plus tôt.
C' est l'opération DELETE.
Donc, vous voyez que maintenant nous faisons l'
opération GET, POST, PUT et DELETE.
Maintenant, nous allons continuer la même chose avec le point de terminaison /dishid.
Donc, dans ce cas,
nous sommes spécifiquement motif obtenir un plat spécifique.
Nous allons rendre cette valeur de plat spécifique.
Donc, dans le GET,
ce que nous faisons, c'est que nous dirons « Plaises.FindById.
Donc, le FindById est une méthode qui est disponible à partir de mongo ainsi que le pilote MongoDB.
Donc, nous allons dire, » req.params.dishid. »
Rappelons que nous savons déjà que l'ID plat est présent dans la propriété params.
Vous en avez déjà appris plus tôt.
Donc, je vais dire, « FindById (req.params.dishid) » et
puis et le reste.
Donc, je vais juste copier cela puis et d'autre à partir de
là et ensuite descendre sur le Dish.Router et
puis simplement coller ça ici.
Donc, nous allons dire, "
application res.statusCode200 json.res.jsondish, puis la gestion des erreurs.
Pour le POST, évidemment, nous ne gérerons pas la publication pour un point de terminaison /dishid.
Donc nous allons le laisser en tant que tel.
Pour PUT, nous allons mettre à jour
un plat spécifique identifié par son identifiant de plat.
Donc, c'est là que nous allons utiliser des plats.FindbyIdAndUpdate.
Donc, c'est la méthode que nous allons utiliser,
findByidAndUpdate et cela prend comme premier paramètre
req.params.dishid et la deuxième valeur est
l'ensemble et la mise à jour
sera dans le corps du message.
Donc je vais juste récupérer ça du
corps de req et puis aussi de l'autre drapeau que je vais avoir.
Donc dira, « new : true », de sorte que cette méthode findById retournera
le plat mis à jour sous forme de chaîne json dans la réponse.
Donc c'est ce que je vais obtenir ici et quand cette valeur entrera en jeu,
je vais juste prendre le plat et
ensuite simplement retourner le plat au côté client.
Donc, je vais dire res.jason (plat) et ensuite nous allons gérer l'erreur en conséquence.
Enfin pour la DELETE.
Pour la DELETE à nouveau,
la méthode correspondante que nous allons
utiliser est la méthode de Mongo appelée FindByIdAndRemove.
Donc, vous pouvez voir que nous avons cette méthode appelée
FindByIdAndRemove et cette FindByIdAndRemove,
prendra req.params.dishid parce que c'est le plat que nous essayons de supprimer.
Ensuite, quand cela est supprimé,
donc tout comme nous avons géré cela ici,
donc je vais juste copier ce code à partir des plates.Retirer.
C' est la même chose que je vais faire ici aussi.
Donc findByIdAndRemove et quelle que soit la réponse que
j'obtiens, je vais le retourner à mon client.
Avec cela, nous avons mis à jour le Dish.Router.
Sauvegardons tous les changements que nous avons faits
jusqu'à présent, puis nous allons démarrer notre serveur et voir ce qu'il fait.
Donc, en allant au terminal ou à la fenêtre de commande, démarrez le serveur.
Donc, je vais dire « npm start » et le serveur est maintenant opérationnel.
On va utiliser le facteur pour communiquer avec ce serveur.
Alors allons voir le facteur et ensuite effectuer certaines opérations.
Alors voici mon facteur qui court ici.
Alors laissez-moi faire une opération GET sur le localhost : 3000/plats.
Donc, lorsque vous faites une opération GET comme vous le voyez,
il retournera une chaîne vide.
Ma base de données est maintenant vide, donc je n'ai rien là-bas.
Donc, je vais juste être retourné une chaîne vide.
Envoyez-nous un plat.
Donc, lorsque vous publiez un plat,
évidemment dans le corps,
vous serez enfermant un plat et le corps sera défini pour être le type d'application json.
Maintenant, pour poster un plat,
je vous ai déjà donné le fichier db.json dans les ressources d'exercice.
Alors ouvrez simplement le fichier db.json et copiez le tout premier plat à partir de
là, puis nous allons le coller ici et ensuite poster ce plat.
Alors, laissez-moi aller au fichier db.jason.
Permettez-moi de copier le tout premier plat d'ici.
Donc je vais juste copier
le plat entier jusqu'à là et ensuite je vais poster ce plat.
Cela contient beaucoup de champs que nous avons déjà ici.
Postons ce plat sur le serveur et voyons ce qui se passe.
Alors, revenons au facteur.
Ici, dans les données de forme,
dans le corps, laissez-moi coller le plat en place.
Donc, nous avons tous les détails du plat là-bas.
POSTONS ce plat sur le serveur.
Ensuite, une fois que le plat est posté sur le serveur,
vous voyez que le facteur a,
laissez-moi juste réduire cela,
et puis vous voyez en bas que ce plat particulier a été posté dans la base de données, dans
la base de données MongoDB par mon serveur.
Donc, vous voyez que la valeur renvoyée
ici montre quand le plat a été inséré dans ce serveur.
Donc, vous avez le CreateDAT et UpdateDAT ajoutés là.
Vous voyez que les champs restants y sont tous stockés.
Notez en particulier comment la valeur du prix y est stockée.
C' est ainsi que la devise stocke la valeur du prix.
Donc, lorsque vous obtenez la valeur de retour,
vous devez interpréter cela de manière appropriée du côté de votre client ce que cela signifie.
Notez également que l'ID a été ajouté à mon plat et pour chaque commentaire lui-même,
car chacun des commentaires est lui-même un sous-document.
Vous aurez les UpdateDAT et CreateDAT ajoutés,
et l'ID de chacun des commentaires également ajoutés automatiquement par ma base de données.
Voilà, tu y vas. Donc maintenant,
ce plat a été ajouté à ma base de données.
Effectuons à nouveau l'opération GET,
et évidemment à ce stade,
le serveur devrait renvoyer ce plat particulier qui a été ajouté dans.
Donc, il retournera un tableau de plats ici, de
sorte que vous pouvez le voir, il retourne un tableau de plats.
Bien sûr, ce tableau ne contient qu'un seul plat
ou ce plat particulier a été retourné ici.
Jusqu' à présent, si bien.
Alors, faisons un PUT sur la vaisselle et voyons ce qui se passe.
Lorsque vous faites un PUT, évidemment, il est dit,
« opération PUT non supportée sur les plats », comme nous nous y attendons.
Faisons une DELETE. En
faisant une opération DELETE,
il renvoie cette réponse disant,
« N est égal à un », ok,
un signifiant qu'il a supprimé un plat.
Revenons maintenant, effectuez une opération GET,
et puis vous verrez que mes plats sont vides comme nous nous y attendions.
Ainsi, vous voyez que les
opérations GET, PUT, POST et DELETE fonctionnent toutes correctement.
Maintenant, laissez-moi POST le plat
à nouveau sur le serveur parce que je veux avoir un plat dans le serveur.
Donc, laissez-moi POST ce plat,
et vous remarqueriez que l'ID a maintenant changé.
Donc, laissez-moi sélectionner cet ID,
puis nous ferons un GET avec l'ID en place.
Lorsque vous faites un GET avec l'ID en place,
vous voyez qu'il renvoie ce plat spécifique comme vous l'attendez.
Allons au terminal et voyons ce qui
est imprimé sur le terminal ou votre fenêtre de commande.
Donc, en allant au terminal ou à votre fenêtre de commande,
vous voyez qu'il est en train d'imprimer toutes ces choses sur la fenêtre de commande.
Donc, quand nous avons fait la première opération GET,
il est dit, GET /plats.
Donc, c'est encore une fois,
Morgan qui fait ce travail pour vous, il est d'imprimer, de
tracer cette information et il dit plat créé
et ensuite que les informations de plat particulier ont été imprimées,
puis il dit POST /plats, GET /plats,
puis quand vous avez fait un PUT, il a retourné un 403
là et vous avez encore créé des plats et ainsi de suite.
Donc, vous voyez que votre serveur fait tout le travail,
et ces choses sont insérées dans votre base de données MongoDB comme prévu.
Maintenant, revenons au Facteur,
faisons un POST sur la vaisselle.
Maintenant, cela n'est pas pris en charge côté serveur,
donc votre serveur doit dire,
« L'opération POST n'est pas prise en charge sur ce point de terminaison particulier », comme vous pouvez vous y attendre.
Faisons une opération PUT.
Lorsque vous faites une opération PUT,
ce que je vais faire dans l'opération PUT, c'est que je vais
remplacer l'étiquette là-bas.
Donc, dans mon corps du message.
Donc, rappelez-vous que si vous regardez le fichier DB.json,
l'étiquette pour cela serait nouvelle,
et donc je vais changer cette étiquette en hot.
Puisque cela doit être en Json,
donc étiqueter aussi entre guillemets Json étiquette chaude,
puis faisons un PUT sur ce point de terminaison particulier.
L' opération PUT a réussi,
et vous voyez donc que lorsque l'opération PUT a été terminée,
vous remarqueriez que l'étiquette est maintenant passée de new à hot ici,
et notez en particulier la valeur
CreatedAt et la valeur UpdateDAT.
Donc, notez que cet enregistrement a été créé
à ce moment et a été mis à jour un peu plus tard.
Donc, la mise à jour a été faite par l'opération PUT que je viens d'
effectuer sur ce plat particulier.
Supprimons le plat.
Ceci est permis. Donc, nous allons supprimer le plat,
puis le plat sera supprimé et la valeur sera retournée.
Maintenant, si vous effectuez une opération GET sur
le point de terminaison vaisselle, vous verrez que cela retournera un vide.
Donc, vous venez de supprimer le plat de notre base de données.
Ce que je vais faire est d'effectuer
une opération GET sur un plat inexistant et de voir ce qui se passe.
Lorsque j'effectue une opération GET sur un plat inexistant,
il renvoie null car ce plat n'existe pas.
Donc, il renvoie une valeur nulle disant que le plat n'existe pas.
Maintenant, laissez-moi effectuer une opération GET sur un non-Objectid et voir ce qui se passe.
Il revient comme vous le voyez.
Laissez-moi en prévisualiser.
Donc, il est dit, « Cast to ObjectID a échoué pour la valeur ici au chemin. »
Donc, je serai évidemment ce n'est pas
un ObjectID valide donc j'ai juste réussi à en supprimer une partie,
puis à effectuer l'opération afin qu'il renvoie une erreur disant,
donc vous voyez qu'il y a 500 erreur de serveur interne.
Le serveur n'a pas pu gérer cela, puis retourner cette valeur ici.
Donc, il est dit, « Non,
ce n'est pas permis. »
Donc, parce que ce n'est pas un ObjectID valide.
Ainsi, même les erreurs sont traitées de manière appropriée comme vous le voyez ici.
Donc, laissez-moi encore une fois, faites une opération GET sur les plats,
et votre serveur est toujours en cours d'exécution,
et il retournera une valeur vide ici.
Donc, nous avons vu comment en modifiant
notre serveur API REST pour être en mesure d'interagir avec le serveur MongoDB.
Nous avons maintenant un serveur d'API REST à part entière qui est capable de stocker
, récupérer et effectuer diverses opérations
sur les données stockées sur mon serveur MongoDB.
Avec cela, nous terminons cet exercice.
Donc, dans cet exercice,
nous avons vu comment nous sommes capables d'interagir avec notre serveur API REST
, et à son tour, avec le serveur MongoDB,
puis nous exploitons le serveur MongoDB pour stocker et récupérer des données du serveur.
Vous pouvez interagir depuis
notre application Express avec le serveur MongoDB en utilisant Mongoose.
C' est le bon moment pour vous de faire un commit GIT avec le message
« Express REST API with Mongoose Part One ».