Transcription
1. Nestjs pour débutants : cours Introduction: Bonjour et bienvenue dans
mon cours sur STS, un framework Node
JS progressif permettant créer des applications Web efficaces et
évolutives. Ses est un framework qui combine
le meilleur des deux mondes, la puissance et la flexibilité
des nœuds, oui, avec l'élégance et la
simplicité de TypeScript. Oui, il vous fournit
un modélisateur , en fait des dépendances
tectorales, des
injections, une gestion des exceptions, des utilitaires de
test et bien plus encore. Dans ce cours, vous
apprendrez à utiliser
less simplement pour créer
une application de blog avec
authentification à une application de blog avec l'aide de Off
Guard Cell Mongoose. Vous
apprendrez également à configurer votre environnement de développement
et à installer un STS. Créez des contrôleurs, des services, des modules, des gardes et des décorateurs. Utilisez l'interface de ligne de commande Nests pour générer
du code et exécuter des commandes. Connectez-vous à une
base de données MongoDB en utilisant Mongoose, les schémas fins, les modèles, les
interfaces et les vidéos, et en effectuant des opérations d' encodage pour les articles de
blog et les actions des utilisateurs. points de sécurité ou les terminaux dotés d'une authentification
JWT et gardes gèrent les erreurs et les
exceptions avec élégance. Ce cours est conçu pour
les débutants qui souhaitent
démarrer avec un SES ou améliorer
leurs compétences existantes. Vous n'avez pas besoin d'
expérience préalable avec un STS, mais vous devez avoir une connaissance de
base de Node.JS, JavaScript et un
peu de TypeScript. D'ailleurs, si vous voulez en savoir plus sur NodeJS
et TypeScript, j'ai un autre
cours sur la sculpture, qui
couvre tout ce que vous
devez savoir. Notez que ce cours
vous apprendra à utiliser NodeJS pour créer des yeux d'API
RESTful, applications
en temps réel, des serveurs
GraphQL, etc. Vous
apprendrez également à utiliser certains des frameworks
et bibliothèques
les plus populaires qui
fonctionnent avec les nœuds, oui,
tels que Mongoose, socket IO type ramp plus
validator, etc. Ce cours a été conçu pour vous
préparer à utiliser Nes Yes et vous donner une
base solide de compétences en matière de nausées. Donc, si vous souhaitez
apprendre la nausée, le chagrin, améliorer vos compétences existantes, je vous recommande vivement de
consulter mon autre cours
sur Skillshare. Maintenant, ces
notes succinctes sont structurées d'une manière particulière qui suit les meilleures pratiques
du développement Web. Sa section couvre un sujet
spécifique avec des explications claires, des
exemples et des exercices. Vous pouvez également télécharger
le code source de chaque section
et suivre. Vous aurez également accès à une
communauté amicale et solidaire d'autres étudiants et instructeurs de
Skillshare,
prêts à vous aider en cas
de questions ou de doutes. Alors qu'est-ce qu'on attend ? Inscrivez-vous maintenant et commencez à
apprendre NES dès aujourd'hui.
2. générer votre premier projet Nestjs !: Bienvenue dans le premier chapitre
du module loudness js. Dans ce chapitre, nous
allons plonger dans le monde passionnant de Nicias et apprendre à créer une application de blog
simple avec authentification. Je suis sur le site Web
efficace de SES. N'hésitez pas à jeter
un coup d'œil et découvrir l'humidité que
Yes a à offrir. Cependant, ne vous inquiétez pas si vous vous sentez dépassé, car
dans ce module, nous fournissons
toutes les informations dont
vous avez besoin pour démarrer avec Nestea, vous aborderez les bases et
développerez une application concrète. Nous pouvons commencer à utiliser
Nicias en toute confiance. Maintenant, quelle est la prochaine étape ? Oui. Lets us est un framework
qui s'appuie sur le célèbre
framework CS supplémentaire pour NodeJS. Mais contrairement à Express, JS fournit une structure plus modulaire et évolutive
pour votre application, il intègre également bon nombre
des meilleures pratiques et
modèles de conception utilisés dans Angular. Il n'est pas nécessaire d'avoir une connaissance
préalable d'Angular pour comprendre STS. En fait, les projets que
nous avons construits ensemble dans le module précédent à l'aide Node.JS exprimé sur TypeScript vous
ont déjà donné un avant-goût
de la structure
jaune de ses applications. Dans ce module, nous allons
approfondir le STS et la manière dont il peut être utilisé pour créer des applications
évolutives et maintenables. Utilise également la puissance
de TypeScript et la dernière
architecture Angular pour rendre création d'
applications côté serveur plus efficace et plus agréable. Et dans ce module, nous
utiliserons la CLI, ou interface de ligne de commande, qui est un outil incroyable qui nous
permet de générer facilement un nouveau projet avec tous les fichiers et
répertoires nécessaires pour démarrer. Avant que nous ne
comprenions cela, oui. PMPM be npm installé par CLI est un gestionnaire de
packages rapide et peu encombrant pour Nokias. Cela permet d'économiser de
l'espace sur votre disque et ne pas perdre votre temps en
installation et en maintenance. L'APM est également disponible
sous Windows, Linux et Mac. Pour arrêter le NPM, vous devez avoir installé NPM ou Yarn sur
votre système. Une fois que l'un de ces gestionnaires de
packages est installé, ouvrez votre terminal, puis vous pouvez exécuter la commande
suivante. Si vous êtes sous Linux, vous utiliserez npm. Installez ces C, P et B F. Mais si vous êtes sur des
fenêtres latérales comme moi, vous devez utiliser yarn at that She
don't stall PMPM en tant que package
global, puis P NPM. Bien, après cela,
vous pouvez installer la CLI Azure en exécutant
la commande npm. Ajoutez ça G. Alors voyons nous. Cli, BI, BPM
et SES yellow sont
déjà installés. Ainsi, une fois l'installation
terminée sur votre site, nous pouvons utiliser la CLI pour
générer un nouveau projet. Disons que
le blog doit faire cela. Nous exécuterons le nid de commandes, puis vous brancherez Dash. Comme vous pouvez le constater, nous pouvons accéder à la CLI Azure avec le
nom nest, puis utiliser la nouvelle balise pour générer
un nouveau projet d'application de blog. Maintenant, appuyez sur Entrée. La CLI vous demandera simplement choisir entre ces
trois gestionnaires de packages. Donc, si vous avez installé
PMPM comme moi, vous pouvez choisir PMPM, sélectionner le NPM
puis appuyer sur Entrée. Mais si vous ne l'avez pas fait, vous pouvez choisir
entre NPM ou Yarn. Je l'ai déjà fait. Ainsi, lorsque vous aurez terminé, vous aurez un tout
nouveau projet SES prêt à être lancé dans
une application Blog Dash. donc à la racine de notre projet Vous trouverez donc à la racine de notre projet plusieurs fichiers
de configuration communs
à la plupart des projets. Ces fichiers contiennent des
informations importantes sur notre projet. Cela signifie que les dépendances et les scripts contenus dans le sac appartiennent à Jason. Mais l'un des conseils les plus
importants est l'erreur ES lint. Vous voyez, ce fichier est utilisé pour configurer les
règles de linting pour notre projet. Cela nous aide à garder notre code
propre et maintenable en assurant que nous suivons les meilleures pratiques
et normes. C'est pourquoi je vous
recommande vivement d'installer une extension portant le nom
ES lint à côté de votre VSCode. Dans cette section, vous obtiendrez commentaires
et des suggestions
en temps réel sur la manière d'améliorer votre code. Alors allez-y et installez AS et extension à côté de votre VSCode. Très bien,
revenons au projet. Vous remarquerez également
un dossier de test et la racine du projet. Ce dossier contient
deux fichiers importants, le fichier adjacent et le fichier txt des spécifications de
l'application. fichier JSON est donc
un fichier de configuration destiné à un framework de test populaire
pour les projets JavaScript. Il configure l'
environnement de test pour votre nid, oui. Candidature. Oui. Et pour ce qui est de la
spécification supérieure, le fichier ts, il s'
agit d'
un exemple de test de bout en bout
pour votre application. Des tests de bout en bout
sont donc utilisés pour tester
la chute de votre application du début à la
fin afin de s'assurer que tout
fonctionne correctement. Maintenant, en résumé,
le fichier ts
perturbe la réponse du
point de terminaison racine de votre application. Il utilise la bibliothèque de
tests de support pour envoyer une demande à l'application
et tester la réponse. C'est un excellent moyen de
vous assurer que votre application fonctionne comme prévu et de détecter tout problème dès le début du processus de
développement. ensemble, le dossier de test et les fichiers
qu'il contient jouent un
rôle crucial pour garantir la qualité et la fiabilité de votre
Nestea, cette application. Revenons maintenant
au fichier package.json. Nous pouvons voir ici plusieurs scripts ou
commandes écrits que nous pouvons utiliser pour exécuter et gérer
notre application. Ces scripts simplifient et rationalisent considérablement
notre processus de
développement . Certains des scripts les plus
importants incluent le script de démarrage. Cette commande permet de démarrer l'application en mode
développement. Lorsque nous exécutons npm, npm bland en
commençant par le terminal, il compile et démarre l'application sur
le port spécifié. Oui, mais je préfère, ou tous les développeurs préfèrent les
lancer en appelant did, car cette commande
contiendra le tag dice dice watch qui nous permettra de
lancer l'application et ce qui changera
en même temps. Maintenant, nous avons également
le script de construction. Ce script est utilisé pour compiler et construire l'application
en mode production. La version compilée
de l'application sera prête à être déployée. Et nous
allons placer ce dossier
dans le répertoire
de notre projet. Nous avons également le script de test. Nous utilisons le script pour exécuter les scénarios de test de
l'application. Nous pouvons l'utiliser pour nous
assurer que notre application fonctionne comme prévu
avant de la déployer. Et peut-être une nouvelle commande
pour nous est la commande lint. Cette commande est utilisée pour exécuter le processus de linting sur notre code. Linting nous aide à maintenir le style de code de
l'écosystème et à éviter les erreurs de
codage courantes. Et parlons du format ou
de la commande. Cette commande, le format est utilisée pour formater notre
code conformément
aux règles spécifiées dans les configurations
de
linting du fichier GIS ARC terrestre américain. Vous pouvez jouer avec ces configurations
comme vous le souhaitez. Mais les configurations par défaut fournies par un STS
sont largement suffisantes. Oui, alors fermons ça. Et en général, ces bandes trouvent
dans le plus gros fichier
adjacent ou sont très utiles pour automatiser
le processus de développement et faciliter la gestion de notre application. Il est important de
comprendre ce que chacun de ces scripts met en vedette
et comment nous pouvons les
utiliser à notre avantage. Très bien, passons maintenant
au dossier SRC parcourons chaque fichier ce dossier et
expliquons son objectif. Nous avons le fichier main.js. C'est le point d'entrée
de notre application. Il crée une instance de l'application et commence à
écouter le port spécifié. Nous avons également le
module App Dot qui contient un fichier. Il s'agit d'un modèle qui regroupe
tous les contrôleurs, services, vibrations et
plus encore sur un seul toit. C'est similaire au concept
de modules dans Angular. Nous avons également l'app
dot controller.js. C'est ici que nous définissons nos itinéraires et traitons les demandes
entrantes. Il utilise les valeurs les plus importantes
, comme GET ou post, qui ne sont pas données
à app.get ou abduct post dans Express. La classe de contrôleur de
SES est chargée de
définir les points de terminaison et gérer les requêtes HTTP entrantes. Sa méthode à l'intérieur
du contrôleur représente une route
dans votre application. Les méthodes peuvent gérer différents types de
demandes telles que GET, post, PUT, delete, etc. Cela se fait encore à l'
aide de décorateurs, tels que la catégorie ultérieure, qui est équivalente à la méthode
get dans Express. Maintenant, nous avons également le conservateur
du contrôleur. Ceci est utilisé pour identifier
la classe en tant que contrôleur. C'est important
car cela nous permet savoir que cette classe doit gérer les requêtes HTTP entrantes. Très bien, passons au fichier
abducts services.js. Maintenant, c'est là que nous
mettons notre logique commerciale. C'est l'endroit idéal pour placer
toutes les requêtes de base de données ou autre logique complexe que nos
contrôleurs doivent utiliser. Nous avons l'injectable, plus il est utilisé
pour identifier les classes qui peuvent être injectées en tant que dépendances
dans d'autres classes. Dans notre exemple, nous avons la classe
App Service that yes, qui est marquée comme injectable. Cela signifie qu'
il peut être utilisé comme dépendance dans d'autres
parties de notre application.
Nous pouvons injecter la vitre App
Service dans le contrôleur à
l'aide du décorateur
injectable, Nous pouvons injecter la vitre App
Service dans le puis appeler la méthode get's hello à partir de la classe App Service nous contrôlons, comme
vous pouvez le voir ici. s'agit désormais d'un moyen puissant de
gérer En Il s'agit désormais d'un moyen puissant de
gérer les dépendances de votre application. organisant
votre code de cette manière, vous pouvez vous assurer que
votre contrôleur se concentre sur la gestion des demandes
entrantes. Pourquoi la classe des observateurs peut-elle être utilisée pour gérer une logique
plus complexe Maintenant que nous avons
configuré la structure du projet, exécutons le serveur et examinons la réponse
du routeur Hello
World dans le navigateur. Pour ce faire, nous exécutons la
commande npm run start, site ,
our terminal ou PMPM car
nous l'avons installée. Alors soyez npm, courez, commencez à tomber, mourez
et appuyez sur Entrée. Bien sûr, nous devons
accéder à un blog en ligne. Et puis reliez la
commande une fois de plus, soyez npm run start going in there. Très bien, si vous obtenez
cette dernière ligne ici, l'application
a démarré avec succès, cela signifie que vous avez
démarré votre application avec succès. Maintenant,
ouvrons le navigateur et
testons le Hello
World à propos d'une réponse. Ici, naviguons
vers localhost thousand et
attendons la réponse. Et voilà, le string
Hello World. Maintenant, vous vous demandez peut-être
comment nous avons fait cela, mais à l'intérieur de la manette. Permettez-moi de résumer ceci :
ce routeur, cette méthode représente le point de terminaison
racine de notre API. Je peux changer cela en
ajoutant une chaîne dans le get decorator comme
ceci, par exemple hello. Ensuite, enregistrez. Par ici. Nous allons insérer la chaîne Hello World
dans la chaîne Hello Route. Revenons au navigateur. Permettez-moi d'abord d'accéder à la racine et au point
d'application. Vous pouvez voir que nous ne pouvons pas obtenir le point de terminaison racine de notre API. Et c'est parce que nous l'avons
changé en Hello. Comme vous pouvez le constater, c'est
très simple grâce à
l'aide des niveleuses
qui se trouvent à l'intérieur des filets. Oui. Maintenant, nous avons réussi à
configurer en unités, oui, Project. Et nous avons une
compréhension de base de sa structure et de ses principaux combats. Dans le chapitre suivant,
nous aborderons plus en les contrôleurs, les services et les modaux et expliquerons comment les
utiliser correctement.
3. Mise en place de mongoose: Bonjour à tous. Dans cette vidéo, nous
allons commencer par un
projet assez structuré que vous trouverez dans la section
des ressources. Alors allez-y, téléchargez-le et ouvrez-le dans votre VSCode. Il est important de
prendre un moment pour comprendre la structure de notre projet et pourquoi nous l'avons divisé en composants
plus petits. Notre application est organisée
en quatre répertoires principaux,
le répertoire des applications, et à l'intérieur duquel
se trouvent l'auteur, le blog et l'utilisateur final. Chacun de ces
répertoires contient un ensemble de composants
ayant un rôle spécifique. Le répertoire de l'application est désormais le répertoire principal de
ces trois composants. Et il contient le modèle
point de l'application, le fichier ts. Mais nous n'allons pas
travailler là-dessus pour le moment. Mais chacun de ces
répertoires contient un ensemble de composants
ayant un rôle spécifique. Ces composants sont ensuite
divisés en contrôleurs, services et schémas rapides. Mais le répertoire est vide
pour l'instant car nous
allons y ajouter
des fichiers
et des configurations très spécifiques . Oui, mais maintenant nous allons
travailler uniquement avec ces
deux composants, le blog et l'utilisateur. Cette structure nous aide donc à gérer et à maintenir le
code plus efficacement, tout
en facilitant la mise
à l'échelle de l'application. Par exemple, lorsque nous ajoutons de nouveaux composants
ou étendons des composants existants, ils n'affectent pas le
reste du système. De plus, ce
détecteur a découplé différentes parties de
notre application, rendant ainsi moins
dépendante des
détails de mise en œuvre des autres parties. Enfin, l'organisation structurée des
fichiers permet aux développeurs de
comprendre
plus facilement les différentes
parties de notre application, la manière dont elles s'imbriquent et
le fonctionnement de l'ensemble du système, ce qui en fait la meilleure pratique
à suivre en matière de développement de SDS. En résumé, la structure de notre
projet se traduit une meilleure gestion du code, une meilleure
évolutivité pour faire face aux liens et une meilleure compréhension de
la conception globale du système. Très bien, maintenant, dans ce projet, nous allons utiliser MongoDB
comme base de données pour
stocker nos articles de blog
et les informations sur les utilisateurs. Nous travaillons avec MongoDB
et Honest Yes Project. Nous utiliserons la
célèbre bibliothèque de
modélisation d'objets MongoDB , Mongoose. Mongoose fournit une solution simple
et élégante pour définir des schémas,
valider des données et interroger la base de données
MongoDB Mongoose sera en mesure
d'interagir facilement avec notre base de données MongoDB
et de modéliser nos données d'une
manière qui
convient à notre application. Commençons donc et
intégrons l'un d'entre
eux à notre projet. Tout d'abord, nous allons accéder
aux autres
sites Web de MongoDB pour mettre à jour
notre URI MongoDB. Donc, ici, si vous n'
avez pas de compte, vous pouvez cliquer sur ce bouton Drive for EE
et créer un nouveau compte. Ou si vous avez un
compte, il vous suffit de vous connecter dans la section clusters. Si vous utilisez MongoDB pour la première fois, vous pouvez créer un
nouveau cluster à l'aide ce bouton, puis choisir le cluster partagé
afin
d'obtenir un plan gratuit, puis créer le cluster en cliquant
sur ce bouton. Une fois que vous avez terminé, retournez à la
section clusters et cliquez sur Connecter, puis connectez
votre application. Et voici l'URI MongoDB. Nous allons utiliser cet URI pour connecter notre projet ECS
à la base de données MongoDB. Assurez-vous de ne sélectionner aucun GS ici. Et la dernière version de NodeJS. Très bien, maintenant copions ceci. Et puis
revenons au code VS. Et à l'intérieur du fichier, vous trouverez une variable URI
MongoDB. Allez-y et collez-y
notre URI. Ensuite, nous allons
changer le mot de passe avec le mot
de passe réel de notre compte. Donc, si vous avez déjà
votre mot de passe, vous pouvez le mettre ici. Si vous n'avez pas enregistré le mot de passe, vous pouvez revenir à MongoDB Atlas, puis le fermer
et accéder à la base de données. Cliquez ensuite sur
Modifier sur votre compte, puis sur Modifier le mot de passe. Et puis ici, nous pouvons
générer un nouveau mot de passe
en cliquant sur le bouton de génération automatique d'un mot de passe
sécurisé. Je vais donc le faire. Je vais le copier. Ensuite, assurez-vous de
mettre à jour un utilisateur. Et revenez ensuite au code VS. Allez-y et entrez simplement le mot de passe , puis enregistrez le m5. Ensuite, nous allons
ouvrir le terminal. Ensuite, nous allons
installer Mongoose. Exécutons la commande
PMPM, puis mongoose. Et parce que nous
l'utilisons, oui, nous allons installer Mongoose. Ce module va nous
fournir un ensemble de décorateurs et d'autres fonctions utilitaires
utiles pour travailler avec MongoDB. Appuyez sur Entrée et
attendez l'installation. Une fois nos
modules installés, nous allons les importer
dans notre modèle pour adultes, le fichier ts, fermer le terminal
et ici, c'est M4. Ensuite, dans le tableau des
importations, nous allons importer le module
mongoose et l'utiliser dans notre projet en appelant
le module mongoose point pour la méthode root. Allons-y et écrivons le module 4 de
Mongoose. Et dans cette méthode, nous allons ajouter l'URI
MongoDB à partir du processus. Soulignement de la base de données Mongo. Mais pour
accéder à l'empire, nous devons utiliser le
service de configuration fourni par Nest. Oui, nous devons d'abord l'
installer. Alors allez-y et ouvrez à nouveau
le côté terminal ici, utilisez le npm puis ajoutez. Cela signifie Enregistrer pour enregistrer
en tant que dépendance de développement, le Nest CSF. Ensuite, le mode de configuration. Appuyez sur Entrée, attendez
l'installation. Très bien, une fois l'
installation terminée, nous pouvons importer le module de configuration
dans le module d'application et
contrôler son comportement, la méthode des quatre racines. Allons-y
étape par étape et importons. Maintenant, nous allons placer
cela dans le tableau. Allez-y et ajoutez une virgule. Et puis ici, à droite, la racine du module de
configuration 4. Et cette méthode acceptera
un objet de propriétés. La première propriété est globale. Cette propriété indiquera au module de configuration de rendre le fichier m disponible dans le monde entier
dans notre application. La deuxième propriété
est le chemin du fichier. Maintenant, ajoutons le fichier
point comme ceci. Je viens donc d'ajouter le nom. Dans ce cas, nous faisons référence au répertoire racine
de notre projet. Et le modèle de conflit
va
rechercher ce fichier dans
le répertoire racine. Très bien, vous pouvez maintenant ajouter plusieurs fichiers en
ajoutant un tableau. Et puis si vous avez un fichier like not
int et un autre fichier int , peut-être, je ne
sais rien. Vous pouvez l'ajouter comme
ça sous forme de tableau. Mais pour nous, nous n'
avons qu'un seul fichier, alors gardons-le comme ça. Comme vous pouvez le constater, la classe modale config
est un outil puissant qui nous permet d'accéder à la variable d' environnement de
manière globale dans notre projet. En utilisant le
module de configuration pour la méthode de démarrage, nous pouvons facilement configurer le module pour rendre les variables d'
environnement stockées dans le fichier point M accessibles dans
l'ensemble de l'application. Cela signifie que nous n'avons pas à ampérer manuellement
le fichier point M dans chaque module ou composant qui a besoin d'accéder
à ces variables. Au lieu de cela, nous pouvons simplement
utiliser le service de configuration pour accéder aux variables
d'environnement depuis n'importe où dans
notre application. Cela facilite grandement gestion
de notre
configuration et le maintien d'un environnement cohérent dans toutes les parties de notre application. Très bien, nous avons maintenant terminé
de configurer Mongoose et nous sommes prêts à commencer à
travailler sur notre application. Dans la vidéo suivante,
nous allons donc créer le schéma de
notre blog. Hormis le schéma de points de blog, le fichier ts utilisant Mongoose
l'a fait dans les projets précédents, mais cette fois-ci, ce sera légèrement différent car
nous utilisons Nest. Oui. Alors on se voit là-bas.
4. Concevoir et mettre en œuvre le schéma de blog: Dans cette vidéo, nous allons créer le schéma du blog dans
notre projet Nest Yes. Nous allons commencer par ouvrir le répertoire des composants sanguins ,
puis ils bloqueront
le schéma dans le fichier ts. À l'intérieur de ce fichier,
commençons par exporter une nouvelle classe et nommons-la verrouillée. Dans cette classe, nous
allons ajouter deux propriétés, le titre du type chaîne et
le contenu du type chaîne. Nous avons maintenant quelques zones
provenant d'ES
et il ne vous reste plus
qu'à enregistrer le fichier. Si les erreurs ne
disparaissent pas automatiquement, vous pouvez accéder à Fichier et préférences puis à Paramètres
et rechercher ES lint. Faites défiler la page vers le bas et
assurez-vous d'activer ES et en tant que
formateur pour votre VSCode. Et puis faites défiler les paramètres
de Jason vers le haut. Assurez-vous ensuite de copier toutes ces lignes pour
citer vos paramètres, le fichier adjacent,
puis fermez. Ceci. Ça n'a toujours pas marché pour toi. Assurez-vous d'avoir LLF comme séquence
de fin de ligne.
Votre VS, VSCode. Vous pouvez le modifier à partir d'ici, mais cela
reviendra à la valeur par défaut en tant que LLF lorsque vous
rouvrirez VSCode pour obtenir. Donc, pour rendre cela permanent, vous pouvez revenir aux paramètres, puis
rechercher la fin de la ligne. Faites défiler la page vers le bas et assurez-vous choisir la barre oblique inverse n comme caractère de
fin de ligne. Ensuite, fermez à
nouveau le fichier, s'il a encore des erreurs, revenez à un RRC plus joli et
ajoutez une fin de ligne égale à L F. Maintenant, ce sont tous les paramètres
requis pour avoir des ajustements automatiques
sur Save with ES. Revenons maintenant à notre schéma. s'agit donc que d'une classe
simple et ce n'est pas encore un schéma de mangouste. Pour en faire un schéma de mangouste, nous allons utiliser ce
décorateur de schéma
importé de TS Mongoose. Alors allez-y et importez le schéma depuis la bibliothèque
Nes Yes, mongoose. Et nous allons le placer
au sommet de notre classe sanguine. Comme ça. Vérifie qu'il n'y a aucune ligne entre la classe
et l'intégrateur. Maintenant, pour identifier
les deux propriétés en tant que propriétés de
Mongoose, nous allons utiliser un autre
décorateur importé à partir du même package. Nommez la sonde et
placez-la en haut de chaque propriété. Pour le titre. Soutenez le contenu. Nous pouvons également ajouter une
configuration à sa propriété en ajoutant un objet dans le décorateur de
propriétés. Ainsi, par exemple, si vous souhaitez que le
titre soit obligatoire, nous pouvons ajouter un objet, puis ajouter la propriété requise
et la définir sur true. Il en va de même pour la propriété de
contenu. Je vais donc copier cet
objet et le coller ici. Enregistrez ensuite pour supprimer toutes
les erreurs d'Eastland. Maintenant, pour exporter la
classe sanguine sous forme de schéma, nous allons importer la classe Schema
Factory à partir de cette
bibliothèque Yes, last Mongoose, n'est-ce pas ? Schéma, usine. Et autre, mais je vais
exporter une constante, la nommer schéma de
journal et la définir comme
étant une usine de schémas. Ensuite, créez une méthode de classe et nous
transmettrons la classe sanguine. Cela va configurer le schéma de
notre blog. Maintenant, nous devons également exporter le type de document de
blog
pour ce fichier. Pour ce faire, c'est important. Le document hydraté
provenant directement du package Mongoose. Ensuite, en haut,
nous allons exporter
un type et le nommer, insérer le document
et le définir comme
un document hydraté. Et passe le bouchon. Enfin, pour rendre le schéma accessible dans l'ensemble de
notre application, nous devons accéder au module de l'application. Permettez-moi d'abord de dire ceci
et d'accéder au module de l'application. Ensuite, nous allons utiliser le module Mongoose
dans le tableau des importations, comme Mongoose deal. Et cette fois, nous allons
utiliser la méthode des fonctionnalités. Et à l'intérieur, nous
allons y faire passer un tableau. Et ce tableau
contiendra des modèles Mongoose. Bien que son modèle Mongoose soit un objet doté de deux propriétés. La première propriété est le nom. Et nous pouvons obtenir le nom grâce au cours
sur les classes sanguines. Vous devez l'importer depuis le blog, le
blog et le nom du point de schéma. Et la deuxième propriété
est la propriété du schéma. Et nous allons obtenir le
schéma à partir du schéma du blog et nous assurer de l'
importer également depuis blogged at
schema, le fichier ts. Désormais, la
méthode Mongo is model.fit est utilisée pour importer des modaux
Mongoose dans un module de
fonctionnalités spécifique de STS. Cette méthode prend en compte deux
propriétés, le nom et le schéma. La propriété name indique
le nom du modèle
importé et est généralement définie sur le nom de
la classe du modèle. La propriété schema spécifie le schéma Mongoose qui correspond au
modèle importé. En utilisant le
modèle Mongoose pour la méthode des fonctionnalités. Nous rendons nos modèles Mongoose accessibles dans ce module. Maintenant, si j'ai dû
importer le schéma du blog
ici, c'est parce que le module d'application dont il dispose est un
service de fichiers en tant que module racine
dans votre nid, oui. Projet. Il est chargé de
rassembler tous les
différents composants, contrôleurs et fournisseurs
qui composent votre application. En important ces modules
dans le module de l'application, le fichier ts, nous
les rendons disponibles dans le monde entier. Rejetez votre candidature. Cela vous permet de réutiliser facilement
les composants et les fournisseurs, ce qui rend votre code plus organisé
et plus facile à gérer. Lorsque vous créez
un nouveau composant, il est important de ne pas oublier de l'
importer dans le module de l'application, le fichier ts, afin qu'il puisse être utilisé par d'autres parties
de votre application. De même, lorsque vous créez
un nouveau modèle Mongoose, vous devez également l'importer dans
le module de l'application, le fichier ts, afin qu'il puisse être utilisé par vos contrôleurs
et fournisseurs. Cela vous permet d'interagir
facilement avec votre base de données MongoDB et effectuer des opérations
telles que la création,
la lecture, la mise à jour et
la suppression de documents. Très bien, ceci
conclut cette leçon. Et dans la prochaine, nous allons nous
pencher sur le service de blog
qu'est son fichier. C'est là que la vraie magie
opère . Nous utiliserons
le modèle de bloc que nous venons créer pour effectuer diverses opérations
de
base de données, notamment la lecture et la
création d'articles de blog Leur
mise à jour et leur suppression aborderont tout cela
dans la leçon suivante. Assurez-vous donc de garder vos notes à portée de main et préparez-vous à coder. Je te verrai dans la prochaine leçon.
5. Créer le service de blog: Dans cette vidéo, nous allons
explorer la puissance des services dans SES en utilisant
la classe de service de blog, qui a déjà
été configurée avec le décorateur injectable dans
le fichier block services.js. Avant de commencer,
je tiens à
vous rappeler que toutes ces
configurations de cette vidéo sont déjà disponibles dans le projet passant à la section
des ressources. Assurez-vous donc de le télécharger, ouvrir dans votre éditeur de
code préféré et d'exécuter PMPM installant le terminal pour télécharger tous les packages
nécessaires. Une fois cela fait, plongeons-nous dans le monde
des services et du SES. Cette classe
sera donc
chargée de gérer toutes les opérations de notre
base de données. Cela signifie récupérer, créer, mettre à jour et
supprimer des articles de blog. En utilisant le décorateur
injectable, nous pouvons définir cette classe
comme un service pouvant être facilement réutilisé dans l'ensemble de
notre application. À la fin de cette vidéo, vous aurez une
solide compréhension du fonctionnement des services dans SES et de la manière de les utiliser pour
interagir avec la base de données. Alors allons-y. Maintenant, dans les leçons précédentes, nous avons discuté de
l'importance
du décorateur injectable dans le SDS. Ce décorateur est utilisé pour indiquer que la
classe est conçue comme un service pouvant être injecté dans
d'autres composants. C'est un aspect crucial
de l'écriture de
code propre
, modélisable et maintenable dans SDS. En utilisant le décorateur
injectable, nous pouvons facilement gérer les
dépendances et les surfaces des
chaises entre les différentes
parties de notre application. N'oubliez donc pas d'ajouter le décorateur injectable avant définir votre
classe de service dans SDS. Cela étant dit,
il est conçu pour utiliser la puissance de MongoDB au
sein de notre service. Pour ce faire, nous devons importer le décorateur
de modèle d'injection depuis une bibliothèque SES mongoose. Ce décorateur est utilisé pour injecter un modèle Mongoose dans
un service d'initiation, ce qui facilite l'exécution des opérations
de base de données
sur le modèle. Dans notre cas, nous voulons définir une variable privée dans le
constructeur de cette classe. Branchons Modal. Et il sera de
type modèle Mongoose. Pour ce faire, nous devons importer l'interface Moodle
depuis Mongoose. Cette interface est une interface
générique qui accepte un document
mongoose. Mais dans notre cas,
nous allons transmettre le document sanguin importé
depuis le blog, ce fichier de schéma. Cette variable privée
va maintenant être injectée à l'aide du décorateur
modal d'injection. Ainsi, l'évaluateur
acceptera le nom du modèle de blog, pourra l'obtenir à partir du nom de
la classe de blog et s'assurer de déplier
le fichier de schéma à points de blog de la classe de blog. Désormais, avec cette variable
injectable, il
sera possible d'effectuer diverses opérations de base de données
sur notre blog Moodle, et de la rendre accessible sur l'
ensemble de notre service. Maintenant que nous avons notre
connexion MongoDB, nous commençons à créer des méthodes
pour effectuer des opérations
de base de données. Tout d'abord, nous créons
la méthode create. Assurez-vous qu'il est asynchrone. Cette méthode sera responsable
de la création
d'un nouveau blocage des sorties. Mais avant de commencer à travailler
sur la méthode elle-même, il est important de
noter les arguments que la méthode prendra en compte. Au lieu d'être directement pris
en compte dans les arguments, comme c'est , chaîne de
titre, contenu, chaîne. Il est recommandé de créer des objets de transfert de données
ou
une interface DTO dans un autre fichier distinct qui contiendra les données
que vous souhaitez enregistrer. Cela nous aidera à maintenir la structure des
données et à éviter toute erreur qui pourrait survenir lors de la
transmission des données d'Anchorage à la méthode. Ou alors, vous
trouverez comment créer un DTO, le fichier ts, enregistrer
le dossier de détails. Nous allons
exporter ce fichier et créer une interface avec le nom
create blog, the teal. Cette interface contiendra les
propriétés que nous voulons enregistrer, le titre du type chaîne et
le contenu du type chaîne. Enregistrez ce fichier et fermez-le. Revenez ici, supprimez
le titre et les arguments de contenu et
remplacez-les par un seul argument, créez un blog, une transaction de type. Créez le journal D POUR vous
assurer de l'importer depuis le dossier Tiers
et depuis le fichier DO du créateur. Maintenant, dans la méthode create, nous devons créer une
instance d'un modèle de blog. Alors allez-y et créez
une constante de blog. Utilisez le nouveau mot clé. Ensuite, tapez ce mot clé
pour accéder au modèle sanguin. Ensuite, nous allons transmettre les détails
de la création du blog. Cela créera une instance
du modèle de bloc. Ensuite, nous devons l'enregistrer
et le renvoyer au client. Renvoie un poids. Enregistrer les points de blog. Ensuite, nous allons créer une autre méthode avec
la mise à jour du nom. Cette méthode sera responsable de la mise
à
jour d' un article de blog spécifique. Tout d'abord, nous devons créer
le blog de mise à jour DTO. Alors allez-y et ouvrez les
mises à jour DTO, le fichier ts. Et voici les
mises à jour de l'interface d'exportation, concluez l'offre. Maintenant, pour mettre à jour
ce billet de blog spécifique, le client doit envoyer l'identifiant. Nous allons donc attendre l'identifiant du trait de
soulignement du type chaîne. Comme vous le savez, Mongo enregistre l'
identifiant avec un trait de soulignement. Assurez-vous donc de l'ajouter. Ensuite, pour le titre
et le contenu, nous allons les recevoir
dans un objet client Props. Et le titre ici est de type chaîne et le
type de contenu chaîne également. Mais nous voulons donner au client
la liberté de mettre à jour
uniquement le titre ou uniquement. Mais rendons ces
propriétés facultatives en ajoutant le point d'interrogation avant les deux points
devant chaque propriété. Enregistrez ce fichier, fermez-le. Ici, enregistrez la méthode de mise à jour. Ajoutons le
blog de mise à jour à cet argument. Sera du type vlog de
mise à jour d'une vidéo. Assurez-vous de l'importer à
partir du fichier vidéo mis à jour. Enregistrez maintenant la méthode de mise à jour. Nous allons utiliser la
méthode
find one and update de la bibliothèque mongoose pour mettre à jour le billet de
blog dans la base de données. Nous allons donc
renvoyer un poids, ce modèle de blog à
points, en trouver un et le mettre à jour. Maintenant, avec cette méthode, nous allons d'abord accepter un objet
en tant que requête de filtre. Cet objet filtrera le document de blog à
l'aide de l'ID de soulignement. Et nous pouvons l'obtenir sur
le blog de mise à jour DTO dots. Et le risque d'identification. Le deuxième argument sera
le document mis à jour
ou
la requête de mise à jour. Bien sûr, vous pouvez l'obtenir à partir
des invites du client
Dto Dto Dot des mises à jour. Le dernier argument sera un objet dont la nouvelle
propriété sera définie sur true. La nouvelle propriété
indiquera à la méthode
find one and update de
renvoyer le document de données
au lieu de l'ancien document. Ensuite, créons
une méthode asynchrone, et ils en obtiendront peut-être une. Cette méthode prendra l'identifiant de l'article de blog comme
argument de type chaîne. Et il va renvoyer le billet de blog
correspondant à
partir de la base de données. Donc, à l'intérieur, d'accord,
revenez, oh attendez. Ce bloc modal, trouvez-en un. Cette méthode
acceptera un objet. Et à l'intérieur, nous
allons interroger notre article de blog avec
l'ID de soulignement. Il doit être égal
à l'ID de l'argument. La méthode suivante
va être bonne. Oh, et il
sera chargé de
renvoyer les articles de
blog et la base de données. Maintenant, cette méthode n'
acceptera aucun argument. Et au lieu de cela, il va
immédiatement revenir à 08. Ce modèle de journal à points. La méthode Find by ID doit accepter un objet vide pour renvoyer tous les articles du
blog et la base de données. Enfin, nous allons
créer la méthode delete one. Cette méthode prend
l'ID du billet de blog comme argument de type
chaîne et supprime l'article de blog correspondant de
la base de données à l'aide de la méthode find
one and remove. Allez-y et reportez un poids, ce modal sanguin de 0,1. Et supprimez et supprimez le document de blog dont l'ID de soulignement est égal
à l'ID de l'argument. Nous allons maintenant définir le type de
retour de chaque méthode. La méthode create est
une promesse qui permettra résoudre un document ou un bloc
de titre. Pour la méthode de mise à jour. C'est la même chose. Promesse. Cela résoudra le document de
blog ici. La même chose également. Promesse. Branchez-le pour l'obtenir. Tout. Ce sera une promesse qui résoudra toute
une série de blocages. Pour la suppression,
nous allons
renvoyer un non ou un booléen. Vous pouvez définir ce type
de résolution pour cette méthode ou vous
pouvez le laisser vide. Sauvegardons donc ce fichier et
c'est tout pour cette vidéo. Avec ces méthodes, nous disposons désormais d'un serveur fonctionnel capable effectuer toutes les opérations de
base de données requises, mais je vais télécharger le composant. Dans la vidéo suivante. Nous utiliserons ce service et
le contrôleur de blog pour définir les points de terminaison de notre API. Alors restez à l'affût.
6. Créer le contrôleur de blog: Bon retour. Jusqu'à présent, nous avons créé
avec succès
notre composant sanguin, qui inclut le
schéma du blog et le Blood Service. Il est maintenant temps de travailler
sur le contrôleur de blog. Vous trouverez le point
de départ du projet dans la section
ressources vidéo. Pour commencer, il suffit de
télécharger le projet et de l'ouvrir dans votre éditeur
VSCode. Et avant de commencer à coder, assurez-vous d'exécuter le PMPM installé dans le terminal pour installer toutes
les dépendances requises. Dans cette vidéo, nous allons créer le fichier blog dot
controller.js, qui servira de pont entre
le front-end et
le
back-end de notre application utiliserons ce fichier pour définir
les différents points de terminaison de notre composant blog
et également intégré
à
notre service de blog pour composant blog
et également intégré
à
notre effectuer des opérations de base de données. Alors allons-y. Notre prochaine étape est de nous plonger dans
le monde du raisin. Plus précisément, nous examinerons le décorateur de la
manette. Ce décorateur nous
permettra de rendre le contrôleur de blog accessible
depuis le routeur de RBI. Cependant, si nous voulons
changer le routeur de
la racine à, par exemple, blog. Comme ça. Nous pouvons simplement transmettre
la chaîne de caractères au contrôle ou à un décorateur. De cette façon, nous
pourrons contrôler le chemin d'accès à notre
contrôleur de blog. l'étape suivante, nous devons importer
notre service de blog afin utiliser toutes les méthodes de base de données que nous avons créées dans la dernière leçon. Pour ce faire, nous allons ajouter l'instruction d'importation
en haut de ce fichier et importer le Blood Service depuis le blog qui gère le fichier ts dans
le contrôleur de blocs. Créons le constructeur et définissons une variable
appelée blogs. Le service définira son type
en fonction de la classe de service. De cette façon, TypeScript
peut comprendre les propriétés et les méthodes mises à notre disposition par
le service de blog. Cela facilite l'écriture et la
maintenance de notre code et évite les
erreurs qui pourraient
survenir lors de l'exécution. Cela nous aide également à compléter
le code, ce qui nous permet d'écrire du code
rapidement et avec précision. Créons maintenant
le Create Router. Tout d'abord, nous allons ajouter un nom de
méthode asynchrone et créer. Mais le simple fait créer à
elle seule un
véritable routeur fonctionne. Nous devons décider
du type de demande que ce
routeur traitera. Dans notre cas, nous voulons envoyer les informations du blog
du client au serveur. Nous allons donc implémenter
une demande de publication. Nous pouvons le faire facilement avec
le post-décorateur qui pourrait être importé du nid
qu'elle a livré dans son emballage. Alors allez-y, faites-le
et placez-le en haut de la méthode de
création, comme ceci. Désormais, la plupart des décorateurs peuvent accepter un argument de
chaîne facultatif qui représente le
chemin du routeur où ils créent. Le routeur
acceptera les demandes. Si nous le laissons vide, le client enverra la demande à l'
hôte local 3,000 block. Toutefois, si nous voulons
ajouter plusieurs routeurs, il est préférable de rendre le
Create Router accessible via le chemin du routeur create. Alors allons-y. La méthode create va maintenant
recevoir un argument body. L'argument
body sera de type create log detail. Assurez-vous d'importer l'interface d'E/S
du créateur TO by. Maintenant, ajouter l'argument body dans notre méthode create n'est pas suffisant car nous devons établir un lien entre le corps de la
requête et cet argument. C'est là qu'intervient le body
decorator de Nes Yes, come in, importez-le abord depuis un
bagage SES. Et nous allons le placer
dans la liste des arguments de notre méthode create avant
l'argument body, comme ceci. Enfin, nous pouvons utiliser
le service de blog pour créer le document de blog et le
renvoyer côté client ici. Retournez une liste d'attente, blog à
points, un service, créez. Ensuite, nous allons transmettre l'argument body à
la méthode create. Lorsque nous enregistrons le fichier
, les zones disparaissent. Parce que l'argument body
est du même type que l'argument DTO create blog
de la méthode create. C'est ainsi que nous avons terminé la configuration du Create Router
dans notre contrôleur de blog. Félicitations. Dans la vidéo suivante,
nous continuerons à travailler avec le contrôleur
de
blog et à
implémenter les autres routeurs
tels que update, delete et get. Ils nous permettront d'effectuer toutes les opérations nécessaires sur notre blog. Les documents
expliqueront également comment gérer les erreurs
pouvant survenir lors ces opérations et nous assureront de la
robustesse et de la fiabilité de
notre application. Restez donc connectés pour la prochaine vidéo et continuons à
construire ensemble.
7. Créer le contrôleur de blog: Excellent travail pour en
arriver là. Dans la leçon. Dans le segment suivant, nous allons examiner
le reste
de la classe des contrôleurs de blocs. Commençons par créer
la mise à jour Troutman. Tout d'abord, nous allons créer une méthode
asynchrone avec le nom de la date. Cette méthode prendra
en compte un argument corporel. Alors allez-y, utilisez le décorateur corporel créez l'argument corporel et
donnez-lui le type de mise à jour. vidéo en vlog et assurez-vous de l'
importer depuis le fichier vidéo. Maintenant, cette méthode va
recevoir une demande de publication. Utilisons donc le post-intégrateur et mettons-lui le chemin à jour. Outre cette méthode, je vais appeler la méthode de mise à jour sur
le service de blog. Alors allez-y et revenez 08. Ce service qui met à jour et
transmet l'argument body. Maintenant, cette méthode de mise à jour va mettre
à jour le
document de blog dans la base de données. Passons
au routeur Get One. Allez-y et créez à nouveau une méthode
asynchrone, et ils en obtiendront peut-être une. Cette méthode nous permettra de
récupérer un seul
article de blog de la base de données. Et il prendra en compte un
argument d'identification de type chaîne. Cet identifiant sera transmis en tant que paramètre au chemin
du routeur, qui sera défini à l'aide
du décorateur get. Alors allez-y et importez
le package commun get degraded à partir du package
commun Nest Yes Slash. Et puis à l'intérieur, nous
allons lui donner le chemin de l'identifiant Post Slash. Ensuite, dans la
liste des arguments de cette méthode, nous allons utiliser
un autre décorateur pour extraire l'identifiant
du chemin du routeur. C'est le plus grand
qui s'appelle par. Alors allez-y et importez-le
également depuis le mesial,
c'est un package courant. Ensuite, nous devons nommer notre parlement ou, dans notre cas, notre paramètre porte le nom id. Maintenant, nous allons utiliser cette
méthode pour appeler la méthode getline
sur le service de blog. Alors allez-y et renvoyez
ce service de blocage. Obtenez-en un et transmettez
l'argument ID. Cela permettra de récupérer le billet de
blog souhaité dans la base de données. Ensuite, nous allons créer
le routeur Get. Cette méthode nous permettra de
récupérer tous les chiens, oh, ils proviennent de la base de données. Nous allons d'abord créer, encore
une fois, une méthode asynchrone
avec le nom gets. Tout. Cette méthode ne
prendra aucun argument car elle récupérera simplement
tous les messages de la base définira le chemin du
routeur à
l'aide du décorateur get
suivi du chemin. Enfin, nous utiliserons
cette méthode pour appeler la méthode get depuis
le service de blocage. Alors allez-y et revenez 08. Ce service de blocage, un service qui obtient tout cela récupérera tous les
articles de blog de la base de données. Enfin et surtout, nous allons créer le routeur
entrelacé. Cette méthode nous
permettra de supprimer un seul article
de blog de la base de données. Tout d'abord, nous allons créer une méthode
asynchrone et la nommer, la supprimer. Cette méthode
prendra un identifiant comme argument de type chaîne. Cet identifiant sera transmis en tant que paramètre dans
le chemin du routeur, qui sera défini en
supprimant le cratère en haut. Importez et utilisez le décorateur
Supprimer, suivi du chemin Supprimer l' identifiant à deux points
importants pour obtenir l'identifiant
du billet de blog souhaité. Ensuite, nous allons
utiliser le paran,
le plus grand, pour extraire
l'identifiant de la requête. Nous allons maintenant utiliser cette
méthode pour appeler la méthode de suppression sur
le service de blog. Revenez donc, attendez ce service de
blocage qui en
supprime un et transmet l'argument ID. Cela supprimera le billet de
blog souhaité de la base de données. Avec cette dernière méthode, nous avons maintenant terminé la classe des contrôleurs
sanguins et tous ses routeurs. Excellent travail pour suivre et mettre en œuvre ces
éléments importants de notre projet. D'ailleurs, il n'est pas
nécessaire que l'
argument ID soit exact. Semblable au nom du paramètre ? Oui, cela peut être quelque chose
comme, par exemple, un identifiant de soulignement. Oui. Et ici, vous devez changer
cela pour souligner l'ID. Mais le paramètre contenu dans le chemin du
routeur doit être égal au paramètre correspondant au nom
du paramètre dans
le décorateur de programme. Sinon, vous ne pourrez pas
obtenir l'identifiant à partir du package du
routeur. Bien, maintenant que nous avons
fini de créer tous les routeurs pour
notre contrôleur de blog, il est important de
réfléchir à la gestion des erreurs. Après tout, les choses peuvent
mal tourner dans n'importe quelle application. Et il est crucial de gérer ces situations de manière appropriée
et professionnelle. Dans SDS, nous disposons de plusieurs
méthodes pour gérer les erreurs, notamment en utilisant des filtres d'
exception, des vibrations et des gardes. Dans cette leçon, nous allons
utiliser des filtres d'exceptions pour gérer les erreurs liées à notre contrôle
sanguin ou à nos méthodes. Tout d'abord, examinons la classe d'exception
HTTP à partir du package ***** yes,
coming. Ainsi, en haut de l'exception
HTTP d'importation, cette classe nous permet de lancer une
exception liée au protocole HTTP et
d'envoyer un code d'état et un message
d'erreur spécifiques au client. Ensuite, exécutons notre code
dans un bloc try catch et via une exception HTTP
dans le diagramme Guts, par exemple dans la méthode create. Nous pouvons faire quelque chose
comme ça. Essaie. Alors voilà, attrapez. Et détectons l'erreur. Ensuite, prenez cette ligne et
placez-la dans le bloc d'essai. Et si nous en avons d'autres, nous
allons utiliser ou nous
allons créer une
nouvelle exception HTTP. Et la classe d'exception HTTP prendra un argument de message. Ces rassemblements peuvent donc être n'importe quoi. Donc, dans notre cas, nous ne savons pas ce qui s'est mal passé
dans les serveurs de logs. Créez cette méthode de création. Nous allons donc envoyer quelque chose comme si c'était le cas. Ensuite, nous devons introduire
un autre argument. Cet argument sera
le code d'état HTTP. Et nous pouvons l'obtenir à
partir
d'une autre classe nommée http status. Assurez-vous également de l'importer. D'un SDS, ça vient. Cette classe contient de
nombreux autres types. Et celui que nous
allons choisir ici est l'auto interne. Enregistrez ceci pour supprimer toutes les erreurs du type «
oui ». Comme vous pouvez le constater, gestion des
erreurs dans SES est bien
plus simple qu'une simple application
NodeJS. Nous pouvons implémenter
ce même modèle dans le reste des méthodes. Détecter les erreurs et envoyer un message d'erreur et un code d'
état appropriés au client. En mettant en œuvre la
gestion des erreurs de cette manière, nous nous assurons que notre
application
se comportera correctement, même si d' autres applications offrent une
meilleure expérience utilisateur
et préservent l'
organisation et le professionnalisme de notre code. Et maintenant c'est tout
pour cette vidéo. Nous avons maintenant terminé la classe
Blog Controller et tous ses routeurs trouveront le résultat final de cette leçon vidéo dans
la section des ressources. Alors allez-y et téléchargez-le au cas où quelque chose
ne tournerait pas rond dans votre code. Dans la vidéo suivante,
nous allons tester
notre application à l'aide
du logiciel Postmen. Alors on se voit là-bas.
8. Testez le composant de blog avec postman: Dans cette leçon, nous allons tester nos composants sanguins à l'aide
du logiciel Boltzmann. Avant de commencer les tests,
assurons-nous que je place la
fois le contrôleur bleu
et le service de blog dans l'application qui a modélisé
le fichier ts pour ce faire. Ouvrez d'abord App Model
, puis dans le tableau
des contrôleurs. Ajoutons le contrôleur sanguin. Bien sûr, vous
devez l'importer à partir du fichier blog dot
controller.js. Pour le service. Nous allons intégrer cela
à la liste
des fournisseurs. Alors allez-y, écrivez un service de
blog et importez-le également à partir de
son fichier correspondant. Maintenant, cela est important pour s'assurer que le
composant est entièrement intégré à notre application et qu'il est possible d'y accéder
par courrier postal. Maintenant, avant de lancer
notre application, nous devons nous assurer d'importer le fichier avant tout le reste. Alors allez-y et placez cette ligne comme premier élément du tableau. Parce que si vous ne le faites pas, vous obtiendrez une erreur de base de données. Très bien, enregistrons
ce fichier et fermons-le. Ouvrez ensuite le terminal
ici et exécutez la commande npm
run, commencez à appeler diff. Très bien, comme vous pouvez le voir
comment une application SES s' exécute et attend des
connexions sur le port 3 000. Ouvrons maintenant nos facteurs
et veillons à créer
un nouvel espace de travail. Et puis, dans
la section de collection, cliquez sur le bouton Nouveau
, puis choisissez Demande HTTP. Nous allons maintenant commencer à
tester le Create Router. Fais ça. Choisissons la
demande de publication dans cette liste. Ici, transmettons l'URL
http localhost, puis le chemin du routeur
de la méthode create. La méthode de la grille existe donc
dans le blog Create. Maintenant, dans la section corps
de la requête, nous allons envoyer
une charge utile JSON qui représente le billet de
blog que nous voulons créer. Pour ce faire, cliquez sur une ligne. Et puis ici, changez dx2, json. Ensuite, créons un objet ici et
transmettons le titre. Le titre va donc être
blogué ou blog de test. Et le contenu sera
un contenu de test. Maintenant, pour envoyer cette demande,
cliquez sur le bouton Envoyer. Maintenant, comme vous pouvez le voir, nous avons reçu une réponse
avec un statut 200 et l'objet adjacent représentant le billet de
blog nouvellement créé avec l'identifiant, le titre, le contenu
et le trait de soulignement. Le trait de soulignement V représente la
version de ce document. Nous allons maintenant utiliser l'ID de ce bloc de document
dans les routeurs suivants. Alors allons-y
et copions cet identifiant. Et nous allons l'enregistrer en tant que variable
d'environnement
dans Postman. Cliquez donc sur la section
environnements. Et puis, à l'intérieur, donnons à ce
blog le nom de soulignement ID. Et je vais définir la valeur
de l'identifiant du document de blog. Cliquez sur le bouton Enregistrer pour enregistrer cette variable d'
environnement. Alors revenons ici. Et nous allons
avoir un routeur. Ce routeur récupère un
seul article de blog en fonction son identifiant. Ce routeur
enverra une requête get. Changeons donc cela pour obtenir. Ensuite, nous allons
envoyer une demande
au chemin Blog, puis publier. Ensuite, nous allons
envoyer l'identifiant que nous venons d'enregistrer en tant qu'
environnement global dans Postman pour
accéder à cette
variable d'environnement à des
accolades comme celle-ci. Ensuite, bloquez l'identifiant du trait de soulignement de 2 secondes. Nous n'avons pas besoin d'envoyer de corps. Alors allez-y et n'en choisissez aucun ici, puis envoyez la demande. Et voilà, nous avons le document de
notre blog invité. Maintenant, allons-y et
testons le routeur Get All. Ce routeur permet de récupérer
tous les articles de blog
stockés dans notre base de données. Nous avons actuellement un article de blog. Nous allons donc
obtenir un tableau d' un document de blog
contenant ce routeur. Assurez-vous d'avoir le type de demande de
chat ici. Et puis modifiez également cette URL. Blog, puis 0, envoyez la demande et vous devriez obtenir un tableau contenant
un document de blog. Mais comme vous pouvez le voir ici, j'
ai plusieurs documents de blog parce que je l'ai testé
avant de commencer à enregistrer. J'ai donc plusieurs articles de
blog ici. Mais comme vous pouvez le voir, nous avons également
notre dernier document de bloc, représenté dans ce tableau. Donc, dans votre cas, vous n'y trouverez que ce document en bloc. Enfin, nous allons
tester le routeur de suppression. Ce routeur supprime ou supprime un seul article de blog
en fonction de son identifiant. Ainsi, lorsque nous enverrons la demande, j'obtiendrais un tableau
de tous ces arguments enregistrés. Et ce document de blog
n'y figurera pas. Il sera supprimé. pour toi. Vous
obtiendrez un tableau vide. Allons-y, testons
ce blog, puis supprimez-le. Dans. Ajoutons notre identifiant de blog, deux accolades, puis
sélectionnons Bloquer l'identifiant du trait de soulignement. Assurez-vous de modifier le type de
demande à supprimer. Envoyons ça. Et nous y voilà. En fait, nous avons obtenu le document de blog supprimé. Oui, nous n'avons reçu ni
site ni application. Nous n'avons pas renvoyé une
série de documents. Alors voilà, celui à supprimer. Cette méthode
renverra uniquement le document de blog et renverra une valeur nulle si elle n'a pas trouvé le document
demandé. Oui, revenons
ici et testons à nouveau le routeur
get all et vérifions si ce bloc de document a
vraiment été supprimé ou non. Déplaçons ça. Et au lieu de cela, appelons blog slash bowl et changeons leur brut pour obtenir
que des ascendants. Et comme vous pouvez le constater, le journal des tests n'
est pas si n dans ce tableau. Il a donc été vraiment supprimé. Nous avons ainsi testé tous les routeurs et
le contrôleur de blog l'aide du
logiciel Postmen en envoyant requêtes
HTTP et en inspectant les réponses du serveur Nous pouvons être sûrs que notre composant
fonctionne comme prévu. Assurez-vous donc d'
importer le contrôleur
et les serveurs de blocs ici. Et pour placer ce saut de colonne vertébrale ou le fichier M comme premier
élément du tableau. Dans la vidéo suivante,
nous allons commencer à travailler sur le composant utilisateur. Alors, des cils.
9. Concevoir et mettre en œuvre le schéma utilisateur: Dans la prochaine leçon, nous allons nous concentrer sur la
création du schéma utilisateur. Le schéma utilisateur
sera utilisé pour stocker les informations des
utilisateurs enregistrés dans notre application. Pour commencer, ajoutez uniquement
la propriété email en
tant que propriété de schéma. Cela simplifiera le processus de signature de l'objectif pour nos utilisateurs. Maintenant, je veux
vous mettre au défi d'essayer de créer vous-même le schéma utilisateur
avant de regarder cette vidéo. Cela vous aidera à
comprendre le processus de
création de votre schéma et
la logique qui le sous-tend. Et puis, après l'avoir essayé, quelle est la vidéo pour voir ce processus
étape par étape
et créer le schéma utilisateur, et assurez-vous de
suivre la procédure pour
éviter toute erreur. Commençons maintenant par
le schéma de points utilisateur,
le fichier ts. Allez-y, exportez une nouvelle
classe et nommez-la côté utilisateur. Cette classe aura une
propriété innée de type chaîne. Importons maintenant ces évaluateurs
schématiques et ajoutons-leur
le schéma à partir de ce package
yes Mongoose. Ensuite, placez-le en
haut de la classe d'utilisateurs. Comme ça. Ensuite, pour le courrier électronique,
il faut l'accessoire, l'évaluateur. Alors allez-y, importez-le et placez-le en haut de
la propriété e-mail. Cette propriété
va être requise. Alors allez-y et ajoutez la propriété requise
dans le décorateur d'accessoires. Ensuite, nous allons
exporter notre schéma utilisateur. Faisons-le sur le bouton. Créez une constante
nommée schéma utilisateur et définissez-la comme étant égale au schéma. Bactéries, assurez-vous de
les importer à partir de ce champignon, oui. Utilisez ensuite la méthode create for class et transmettez
la classe utilisateur. La dernière étape consiste maintenant à explorer un
type de document utilisateur à partir de ce fichier. Pour ce faire, exportez le type
et nommez-le document utilisateur. Ensuite, utilisez le document
hydraté et retirez-le de
l'emballage Mongoose. Nous allons utiliser ce type pour créer un
document mongoose de type user. Maintenant, enregistrons ce fichier
et accédons au module de l'application, le fichier ts ici, et ajoutons notre modèle
Mongoose nouvellement créé dans le module mongoose point for feature method
dans ce tableau. Ici, créez un autre objet, m plus n, le nom. Cette fois, le nom
va être extrait de la classe utilisateur. Assurez-vous donc de le déplier
à partir du schéma utilisateur ,
puis de transmettre le nom. Et nous avons besoin que le schéma
soit défini sur le schéma utilisateur. Assurez-vous de l'importer également à partir du
schéma de points de l'utilisateur, le fichier ts. Permettez-moi de sauvegarder ce fichier maintenant. Et comme vous pouvez le constater, il n'
y a rien de compliqué à créer un
schéma de mangouste à l'aide de SDS. Nous l'avons fait dans les leçons précédentes et
nous l'avons fait à nouveau ici. J'espère que vous avez
réussi à créer
le schéma utilisateur grâce à vous, oh, maintenant c'est tout
pour cette vidéo. Je tiens à ce que ce soit court. Et dans la
vidéo suivante, nous allons
commencer à travailler sur
le service utilisateur. Le service utilisateur ne
contiendra qu'une méthode ou créera, mais nous allons nous occuper
de
l'authentification à l'aide de jetons JWT ou de jetons Web
JSON. Restez donc à l'affût et à la prochaine leçon.
10. Créer le service utilisateur: Dans la prochaine leçon, nous aborderons
la création du service utilisateur en nous concentrant uniquement sur la création de
la méthode de création à partir de maintenant. Mais vous devez avoir
confiance en vos capacités à continuer à développer les autres
méthodes après cette leçon. Maintenant, pour vous lancer un défi,
vous pouvez essayer
de créer
vous-même la méthode de création avant de
regarder la vidéo. Vous pouvez ainsi
renforcer ce que vous avez appris et l'appliquer
à un nouveau scénario. Et vous pouvez aller au-delà
et essayer, lors de la création de la méthode de création, renvoyer un jeton
JWT à l'utilisateur. Ce sera une excellente
occasion de renforcer votre compréhension de la
création de services et de SCS. Préparez-vous donc à vous
retrousser les manches et à vous lancer dans la
création du service utilisateur. Nous allons commencer par créer notre constructeur
au sein du service utilisateur. À l'intérieur, nous allons y
injecter le modèle utilisateur. Donc, pour ce faire, créons d'abord une
variable privée, nommons-la
modèle utilisateur,
donnons-lui le
type de modèle importé depuis le package Mongoose et
transmettons le document utilisateur sous la forme onglet de document
Mongoose pour cela, également à partir du schéma de
points utilisateur, le fichier ts. Maintenant, définir le modèle
utilisateur de cette manière ne signifie pas que nous l'avons
injecté dans notre service utilisateur. Pour ce faire, nous allons utiliser le décorateur et
vérifié Moodle. Importez ça des
Nazis Slash Mongoose. Ce décorateur
acceptera le nom du modèle. Nous pouvons l'obtenir à partir
du nom de la classe utilisateur. Assurez-vous d'importer
la classe utilisateur partir du
schéma User Looks, le fichier ts. Nous avons ainsi réussi injecter le modèle utilisateur
dans notre service utilisateur. Nous pouvons maintenant l'utiliser dans
la méthode create. Ce sera donc une
méthode asynchrone avec le nom create. Et cette méthode acceptera un e-mail de type
chaîne comme argument. Et à l'intérieur de celui-ci, nous
allons créer une nouvelle instance
du document utilisateur. Pour ce faire, nous utiliserons le
nouveau mot clé, puis la classe UserModel dans laquelle
nous l'avons injecté qui utilisera leur
service pour créer une nouvelle instance de document utilisateur en
transmettant un objet
avec la propriété email. Nous allons maintenant enregistrer notre document utilisateur
en utilisant la méthode de sauvegarde. Mais cette fois, nous
allons conserver le document sécurisé dans un nom d'utilisateur enregistré
constant. Alors, oh, attendez,
ces méthodes sûres. Maintenant, si j'ai créé cette
constante utilisateur enregistrée ici, c'est parce que nous allons utiliser les données du document
utilisateur pour générer un jeton Web JSON et y enregistrer les
données utilisateur, puis le
renvoyer au client. Donc, dans la ligne suivante, nous retournerons un objet
avec la propriété Jason ou le jeton JWT. Cette propriété contiendra
la chaîne du jeton Web JSON. Maintenant, pour ce faire, pour générer le jeton
Web JSON, vous devez comprendre ce qu'est un jeton Web
JSON. En termes simples, un jeton
Web JSON est un moyen de transmettre des informations
en toute sécurité entre des parties en tant qu'objet adjacent. Dans ce cas, les
informations seraient un jeton
d'authentification identifiant l'utilisateur. Une fois qu'un utilisateur
se connecte à notre application, nous renvoyons un objet
contenant le jeton JWT. Ce jeton
sera désormais utilisé pour autoriser l'utilisateur à accéder à des routes
protégées. Mais pour l'instant, concentrons-nous sur la
génération du jeton JWT réel. Et pour cela, nous devons
installer de nouvelles dépendances. Ouvrez donc votre terminal. Ici. Exécutons la commande PMPM. Cela permet d'économiser. Ajoutez ensuite ness G, S plus T W T. Ce package est un package
utilitaire qui nous
aide à manipuler GW t. Le deuxième package
sera
constitué des paquets Passport JWT. Maintenant, ce compartiment est
le package de passeport qui met en œuvre
la stratégie JWT. Nous allons l'utiliser lorsque
nous commencerons à protéger nos itinéraires, en utilisant des dispositifs d'authentification pour empêcher les
utilisateurs non autorisés d'utiliser nos relations publiques. Maintenant, exécutez cette commande
et vous devriez installer
ces deux dépendances
dans votre application. Ensuite, vous
devez installer les types TypeScript
du
package Passport fait JWT, et vous assurer de
les installer en tant que dépendance de développement, en utilisant le desk
enregistré sous forme de balise div, puis ajouter des types, passport, c'est T W T. Et appuyez sur Entrée et terminez le processus
d'installation. Une fois ces dépendances installées dans
votre application, ouvrez
le module de l'application,
le fichier ts mis à part ici, et nous allons importer notre module JWT afin qu'il puisse être utilisé dans
notre application. Pour ce faire, nous allons
d'abord importer le module JWT à
partir des paquets de
Nest GS slash JWT. Ensuite, dans
l'enquête d'importation, nous allons utiliser
le module JWT. Puis résistance. Ici, nous allons transmettre un objet avec certaines
configurations. Maintenant, la première propriété de cet objet de configuration
va être le secret. Ici, nous allons enregistrer notre jeton secret
JWT. Le jeton secret
est maintenant utilisé pour déchiffrer le jeton JWT et en extraire
les données utilisateur. Le jeton secret JWT joue donc un rôle crucial dans le processus
d'authentification. Nous devons donc enregistrer ce
jeton dans le fichier m. Alors vas-y et ouvre-le. Et vous constaterez qu'un secret JWT
souligne une valeur inestimable. Vous pouvez mettre ici n'importe quel caractère
aléatoire. Puis enregistrez ce fichier. Retournez ici. Et
utilisons cette variable d'environnement issue du
processus que cet objet,
puis le point DWT placé sous le trait de
soulignement sécrète. La deuxième propriété sera la vente
aux enchères d'enseignes. Cette propriété sera un objet
doté d'autres propriétés de
configuration. L'une de ces propriétés est
la propriété expirant. Cela définira la
période pendant
laquelle le jeton Web JSON sera valide. Ou en d'autres termes, pour définir la période pendant
laquelle l'utilisateur sera authentifié dans notre
application et quand il devra se reconnecter pour obtenir
un nouveau jeton Web JSON. Nous allons donc fixer
ce délai à deux jours. Enregistrez ensuite le module
de l'application, fermez-le et fermez-le. plus, nous
allons générer le jeton Web JSON en utilisant la surface JWT
provenant de la bibliothèque SES slash DWT. Tout d'abord, c'est important
en haut de notre dossier. Et dans le constructeur
du service utilisateur, créons une nouvelle variable, un nom et un service GW t et
définissons son type sur JWT service. Revenons maintenant à notre JWT et à notre
propriété et utilisons ce service pour signer un nouveau jeton Web JSON avec
les données utilisateur de sécurité. La même méthode acceptera donc une charge utile pouvant contenir toutes les
propriétés
que vous
souhaitez enregistrer sur
l'utilisateur dans le jeton Web JSON. Donc, dans notre cas, nous voulons enregistrer le nom d'utilisateur. Nous pouvons l'obtenir à partir de la constante
utilisateur enregistrée , cet identifiant de
soulignement. Et comme l'
identifiant du trait de soulignement est de type Mongoose ID, nous devons le remplacer par
une chaîne à l'aide de la méthode
ToString. Maintenant, la propriété suivante
que je voulais enregistrer est l'e-mail. Vous pouvez également l'obtenir
à partir des utilisateurs enregistrés ou la constante utilisateur de sécurité point n. Avec ce dernier élément, nous avons
terminé notre service utilisateur avec succès. Dans la vidéo suivante,
nous allons créer notre contrôleur utilisateur et
créer le Create Router. Alors on se voit là-bas.
11. Créer le contrôleur d'utilisateur: Bienvenue dans cette vidéo où
nous allons nous concentrer sur la
création du contrôleur utilisateur
dans notre application SES. Dans les leçons précédentes, nous avons créé le
schéma utilisateur et le service utilisateur, qui serviront désormais de base
au contrôleur utilisateur. Le contrôleur utilisateur
serait chargé de gérer les demandes HTTP
entrantes
et de
les diriger vers la méthode de
service appropriée pour le traitement. Maintenant, il suffit de commencer, nous allons ajouter la chaîne user dans
le contrôle ou le décorateur. Cela nous permettra de créer un point de terminaison spécifique
pour le contrôleur utilisateur. En utilisant le décorateur de
contrôleur, nous définissons l'itinéraire de base
de notre contrôleur utilisateur, ce qui nous permettra de gérer
et
d'organiser facilement nos points de terminaison d'API. Maintenant, ajoutons la variable de service utilisateur
dans le constructeur. Alors allez-y, créez une variable privée,
nommez-la User Service, et définissez son type sur
User Service Class. Ensuite, nous allons créer une méthode asynchrone, la
nommer create. Cette méthode
acceptera une demande de publication. Alors allez-y, importez et utilisez le décorateur de publication situé en haut de notre méthode de création et, à l'intérieur, donnez-lui le chemin create. Maintenant, cette méthode ou ce routeur
va accepter un corps. Et nous pouvons extraire le corps
en utilisant le corps le plus grand. Alors allez-y et
importez-le également depuis le nid, oui, un package
commun. Et définissons
notre argument corporel. Notre argument body sera donc un objet
contenant une propriété de courrier électronique de type chaîne. Nous allons maintenant
revenir à 08, ce service utilisateur. Et nous allons utiliser
la méthode create intégrée au service utilisateur pour créer
un nouveau document utilisateur, l'
enregistrer dans service utilisateur pour créer
un nouveau document utilisateur, la base de données,
puis le renvoyer. Le jeton JWT sera transféré dans Bus dans l'e-mail
qui se trouve à l'intérieur du corps. Et grâce à cela, nous avons créé
avec succès le contrôleur utilisateur
et le Create Router. L'utilisateur
pourra donc créer
un nouveau compte à l'aide
du point de terminaison de création. Ensuite, nous
allons lui renvoyer un jeton JWT pour l'autoriser. d'envoyer uniquement le jeton
JWT ne
signifie pas que notre
application est entièrement
protégée contre toute utilisation malveillante. Il est important de
se rappeler que d'autres mesures doivent être prises
pour sécuriser notre application. Cela étant dit,
dans la vidéo suivante,
nous verrons comment protéger notre contrôleur de blog utilisateurs non autorisés
à
l'aide d'un JWT of God, qui agit comme un intergiciel
d'authentification. Grâce à cette implémentation,
nous pouvons garantir que seuls les utilisateurs autorisés peuvent accéder à nos points de terminaison et protéger notre application
contre toute utilisation malveillante. Alors, faisons en sorte que cette vidéo courte et
à bientôt dans la prochaine.
12. Implémenter l'authentification avec les gardes d'audition: Dans cette leçon, nous allons apprendre
à mettre en œuvre la stratégie
JWT. En toute honnêteté, l'obligation et la protection de
notre manette contre utilisateurs
non autorisés consistent à
utiliser un JWT par hasard. Mais avant de nous plonger dans
la mise en œuvre, examinons rapidement cartes de SES concernant les STI et les contextes
d'exécution, qui peuvent être ajoutées
en tant qu'intergiciel et vérifient si une demande est autorisée à accéder à un point de terminaison
particulier. Ainsi, en utilisant ce jardin, nous pourrons vérifier
si le jeton JWT est valide ou non et en extraire la charge utile de
l'utilisateur. Maintenant que nous avons une
compréhension de base des cartes JWT, nous devons commencer par
installer une nouvelle dépendance. Alors allez-y, ouvrez votre
terminal et exécutez la commande PMPM, save lives, passport. Ce
package est très important car il sera chargé extraire le jeton JWT
de l'en-tête et de le décoder. Et ensuite, s'il ne s'agit que de
le dater
et de nous fournir les données qui y
ont été enregistrées. Une fois que vous avez terminé d'installer
le package de passeport, fermez
le terminal,
puis assurez-vous de télécharger le point
de départ de ce
projet joint à la section
des ressources de cette vidéo dans votre système. Et puis dans le
dossier Earth, vous trouverez deux fichiers. En ce moment, nous
allons travailler sur la stratégie GWP, le fichier ts. Ici, nous allons
exporter une classe avec un nom de stratégie JWT. Et ce cours va
être injectable. Et comment le
rendre injectable, bien
sûr, avec le décorateur
injectable. Alors allez-y et ajoutez le W, cette classe ou le décorateur
injectable et importez-le à partir d'un commentaire de barre oblique
SES. Ce cours étendra ensuite
la stratégie de passeport de classe. Comme je l'ai dit, premiers packages de mots de passe seront chargés extraire le jeton JWT
de l'en-tête et de le décoder, puis de nous fournir les données décodées
à partir du jeton JWT. Maintenant, cette classe va
accepter une autre classe utilitaire
avec le nom strategy. Nous pouvons l'importer
depuis passport dash d, t. Maintenant, créons le constructeur de cette classe. Et pour les bretelles frisées, nous allons utiliser
la super méthode. Maintenant, la super méthode
est utilisée pour appeler le constructeur de
la classe parent. Bonjour, dans le
constructeur de la sous-classe, qui est la stratégie JWT, nous lui permettons d'
hériter propriétés et des méthodes
de la classe parent, qui est la stratégie Passport. Cela permet de créer un code
plus organisé et plus
facile à maintenir. Chaque fois que vous étendez
une autre classe, vous devez utiliser la super
méthode pour vous assurer que votre sous-classe hérite toutes les propriétés et méthodes
de la classe parent. Cette méthode
acceptera donc un objet, et cet objet
ajoutera quelques propriétés. La première propriété
est la requête JWT. Cette propriété indique à
la classe de mot de passe comment extraire le
jeton JWT de la demande. Nous voulons extraire le jeton de l'en-tête sous forme de
barrière ou de jeton. Pour ce faire, nous allons utiliser une autre classe avec
le nom extract JWT importé à partir du
mot de passe dash g, DWT. Ensuite, cette classe
nous fournit une méthode avec le nom de l'en-tête
comme jeton de barrière. Avec cette méthode,
notre classe Esports, qui va
extraire le jeton de
l' en-tête en tant que jeton de barrière. Maintenant, le deuxième argument
va être ignorer l'exploration
et le définir sur false. Nous faisons en sorte que la meilleure classe de
plateau n'
ignore pas le jeton expiré. Ainsi, si l'utilisateur a envoyé un
jeton expiré à l'API,
il rejettera sa demande et renverra
une bouteille, une réponse. Donc, réponse à
une demande non autorisée. Maintenant, la dernière propriété
va être une propriété
secrète ou clé. Cet établissement conservera le jeton JWT secret afin que les détenteurs de passeports puissent le
décoder. Nous l'enregistrons dans le
fichier en tant que variable d'entrée. Processus généralement destiné
à importer le secret JWT. Ensuite, nous finissons de
configurer les configurations de nos passeports. Nous pouvons maintenant créer une méthode au sein de la classe de stratégie
GW. Cette méthode sera une méthode synchrone
N
portant le nom body date. Cette méthode accepte une charge utile et tout ce
que nous avons à faire est de la transmettre
au routeur suivant renvoyant simplement la
charge utile à partir de cette méthode. Nous pouvons maintenant indiquer le type
de charge utile. Nous connaissons déjà la forme de
cette charge utile car nous l'avons enregistrée dans
le jeton JWT avec
deux propriétés, l'identifiant utilisateur et l'e-mail. Et les deux
sont de type string. Ajoutons donc deux points
et un objet avec identifiant utilisateur de type chaîne
et un e-mail de type chaîne. Maintenant qu'il s'agit de la classe Passport, nous créons un objet utilisateur basé
sur la valeur de retour de la méthode validate et nous l'
attachons en tant que propriété à
l'objet de demande. Donc, pour passer à autre chose, allons-y et ouvrons le fichier
JWT Asgard, le fichier ts. Et ici, nous allons
construire notre DWT. Ces Gardes seront donc un GWP de classe de Dieu. Et cette classe
sera une classe injectable. Ils utiliseront
le décorateur injectable. Et nous allons étendre un autre cours avec
le nom de Dieu. Vous pouvez l'importer à partir de paquets de passeports
SES plus. Cette classe de protection
va accepter le type de stratégie d'
authentification. Dans notre cas, nous
utilisons la stratégie JWT. Alors allez-y, écrivez DWT à l'intérieur de la Terre, puis enregistrez
ce fichier, fermez-le. Celles-ci, la stratégie GW, le fichier ts, renvoient à
notre composant de blocs. Et nous allons implémenter la méthode Start to the create. Nous allons donc empêcher les utilisateurs
non autorisés de créer des articles de
blog dans nos relations publiques. Pour ce faire, utilisons
le classeur que vous supprimez, qui sera
importé du nid sous forme de paquets moins courants. Ensuite, nous allons
utiliser le JWT sans précaution que nous avons créé
dans le
DWT des officiers . J'ai vu cette
carte, le fichier TS. Ensuite, enregistrons ceci, puis
passons au module de l'application. Et ici, nous devons importer notre classe de stratégie JWT dans le tableau des fournisseurs
afin qu'elle
soit accessible dans l'ensemble de
notre application. Alors allez-y, ajoutez un autre
élément et écrivez la stratégie JWT. Assurez-vous d'importer cette forme de Slides JWT Dot Strategy
et pourquoi nous sommes ici Importons également le
contrôleur utilisateur. Le réseau de contrôleurs
et le service utilisateur. Et disons que le fournisseur est Eddie. Très bien, revenons
au contrôleur de blog. Et en mettant ainsi en œuvre le
mode Off-Guard,
nous protégeons
le Create Router contre les utilisateurs non autorisés. Nous pouvons maintenant ajouter une couche supplémentaire à notre authentification en
ajoutant une propriété utilisateur dans le
schéma de blocs afin savoir quel utilisateur a
créé le document de blog. Nous pouvons donc dire que le schéma utilisateur est le ajoutons une autre sonde
et rendons-la obligatoire. Et nommez cette propriété utilisateur. Maintenant, cette propriété va
être de type class utilisateur. Assurez-vous de l'importer à
partir du fichier de schéma utilisateur. Et cette propriété sera également une référence
au document utilisateur. Maintenant, pour ce faire,
nous allons ajouter
la propriété type à cet objet nous allons ajouter
la propriété type à et lui attribuer la valeur Mongoose. Assurez-vous d'importer le package Mongoose
depuis mongoose, puis sélectionner l'ID d'objet des types de schéma. Parce que nous voulons désigner l'utilisateur par son identifiant, puis ajouter la propriété href pour définir la référence de ce
produit au modèle utilisateur. Enregistrez ensuite le schéma du blog, fermez-le et revenez
au contrôleur de flux. Et dans la méthode create, extrayons l'
objet utilisateur de la demande. Peut le faire dans la liste des
arguments de
la méthode create. Et en utilisant le reg decorator, assurez-vous de l'importer depuis
le package commun SES. Maintenant, ce décorateur
va nous donner accès à la requête et nous allons utiliser l'objet
utilisateur à partir de là. Donc, dans la méthode de création du service de blog, ajoutons un, en
particulier dans un objet
et l'objet ici. Et ajoutez une propriété utilisateur
provenant de l'utilisateur de la demande. Ensuite, ajoutez-y un point d'
interrogation car l'objet utilisateur
peut être indéfini. Sélectionnez ensuite le nom d'utilisateur. Nous devons maintenant passer aux serveurs
de blocs. Et dans la
méthode de création, vous trouverez l' interface Creative Blog DTO. Nous devons ajouter une
propriété d'identifiant utilisateur de type chaîne. Enregistrez le fichier créé
POUR revenir ici. Et lorsque nous sauvegardons, toutes les flèches devraient disparaître. Juste ici. Nous devons le remplacer
par un identifiant utilisateur. Maintenant, dans les autres
routeurs, comme dans la mise à jour, nous pouvons effectuer une opération
pour vérifier si l'utilisateur figurant dans le document de bloc demandé possède le même identifiant utilisateur que l'
identifiant utilisateur extrait du jeton JWT. Nous pouvons faire la même chose à l'intérieur du routeur Supprimer un ici. Je vais
vous laisser
le défi de pratiquer votre nid, oui. Balances. Cela ne devrait pas être si difficile. vous suffit de lire
le document de blog à partir de la
base de données, de l'accessoire utilisateur, et de vérifier s'il est égal à l'identifiant utilisateur
extrait du jeton. Si tel est le cas, renvoyez
le document de blog ou autorisez l'action de mise à jour sur
le document de bloc demandé. Nous avons donc
terminé la création notre contrôleur de blog et mise en œuvre d'
une application d'authentification interne. Vous trouverez le résultat final dans cette section de
ressources vidéo.