1
00:00:03,710 --> 00:00:10,380
Ahora que hemos tenido una rápida visión general de Mangoose ODM y

2
00:00:10,380 --> 00:00:16,710
cómo Mangoose trae esquemas para estructurar los documentos que almacenamos en nuestro MongoDB,

3
00:00:16,710 --> 00:00:19,830
veamos cómo hacemos uso

4
00:00:19,830 --> 00:00:27,000
del módulo de nodo de mangosta y luego lo incorporamos a nuestra aplicación de nodo.

5
00:00:27,000 --> 00:00:31,065
Luego use Mangosta para comunicarse con

6
00:00:31,065 --> 00:00:35,760
nuestro servidor MongoDB y luego almacenar y recuperar

7
00:00:35,760 --> 00:00:41,355
documentos con información de estructura en los documentos.

8
00:00:41,355 --> 00:00:44,830
Para comenzar a realizar este ejercicio,

9
00:00:44,830 --> 00:00:48,080
vaya a una ubicación conveniente en su computadora.

10
00:00:48,080 --> 00:00:52,760
Entonces, aquí estoy en la carpeta Node JS donde he estado almacenando

11
00:00:52,760 --> 00:00:57,020
todos los ejemplos de este curso y luego voy a

12
00:00:57,020 --> 00:01:02,210
crear una nueva carpeta llamada nodo Mangoose.

13
00:01:02,210 --> 00:01:10,320
Aquí es donde vamos a crear la aplicación de nodo usando Mangoose siguiente.

14
00:01:10,320 --> 00:01:12,900
En el terminal o la ventana de comandos,

15
00:01:12,900 --> 00:01:19,080
mueva a la carpeta Mangoose nodo y luego inicialice una aplicación de nodo allí.

16
00:01:19,080 --> 00:01:22,385
Entonces, déjame escribir npm init y luego

17
00:01:22,385 --> 00:01:26,359
inicializar la aplicación del nodo y luego nombraría la aplicación

18
00:01:26,359 --> 00:01:34,174
como node-mangosta y el punto de entrada es index.js git history,

19
00:01:34,174 --> 00:01:42,590
palabras clave, autor y licencia y diremos que está bien.

20
00:01:42,590 --> 00:01:49,574
Una vez creado el archivo package.json del nodo,

21
00:01:49,574 --> 00:01:54,500
abra el proyecto en el editor de texto de su elección.

22
00:01:54,500 --> 00:02:02,809
Entonces, aquí tengo mi proyecto abierto en Visual Studio.

23
00:02:02,809 --> 00:02:05,915
Permítanme entrar en el archivo package.json y luego agregar

24
00:02:05,915 --> 00:02:14,750
el script de inicio y luego

25
00:02:14,750 --> 00:02:24,160
diremos índice de nodo de inicio como de costumbre cada vez que comenzemos con una nueva aplicación de nodo.

26
00:02:24,160 --> 00:02:29,945
Luego, yendo a la terminal o a la ventana de comando, instalemos Mangoose.

27
00:02:29,945 --> 00:02:37,290
Por lo tanto, en el símbolo del sistema, escriba npm install Mangosta, guarde.

28
00:02:39,470 --> 00:02:45,570
Que en este momento es Mangosta 5.1.7.

29
00:02:45,570 --> 00:02:49,760
Por lo tanto, estas son las versiones que voy a usar en este curso.

30
00:02:49,760 --> 00:02:54,920
Luego voy a mi aplicación en el editor.

31
00:02:54,920 --> 00:03:01,430
Permítanme crear una subcarpeta en el proyecto llamada como Modelos.

32
00:03:01,430 --> 00:03:07,320
Entonces, aquí es donde voy a almacenar todos los modelos para mi aplicación.

33
00:03:07,340 --> 00:03:10,230
En la carpeta de modelos,

34
00:03:10,230 --> 00:03:15,170
permítanme crear un nuevo archivo llamado dishes.js.

35
00:03:15,170 --> 00:03:19,535
Entonces, aquí es donde voy a crear el esquema y el modelo

36
00:03:19,535 --> 00:03:24,680
de mis platos documento que voy a almacenar,

37
00:03:24,680 --> 00:03:29,770
la colección de platos que almacena los documentos para cada plato.

38
00:03:29,770 --> 00:03:36,730
Así que, justo ahí, déjame primero importar Mangosta.

39
00:03:39,320 --> 00:03:47,880
Por lo tanto, vamos a requerir mangosta en este archivo y luego decir

40
00:03:47,880 --> 00:03:57,940
const esquema es el esquema de mangosta.

41
00:03:59,420 --> 00:04:03,510
A continuación, crearemos el esquema aquí.

42
00:04:03,510 --> 00:04:13,845
Por lo tanto, vamos a decir const DishSchema nuevo esquema.

43
00:04:13,845 --> 00:04:19,590
Entonces, aquí es donde defino el esquema para mi plato.

44
00:04:20,830 --> 00:04:27,270
Dentro de este esquema, permítanme definir los diversos valores.

45
00:04:27,270 --> 00:04:29,830
Entonces, diré nombre,

46
00:04:29,890 --> 00:04:34,405
que es el tipo String.

47
00:04:34,405 --> 00:04:41,480
Por lo tanto, este es el tipo de esquema y luego esto lo declararía según sea necesario.

48
00:04:41,480 --> 00:04:43,460
Así que, voy a decir verdad.

49
00:04:43,460 --> 00:04:52,790
Por lo tanto, cada documento tendrá el nombre como un campo obligatorio allí y luego

50
00:04:52,790 --> 00:04:57,185
también declararé esto como un significado único de que

51
00:04:57,185 --> 00:05:02,545
no hay dos documentos que tengan el mismo campo de nombre allí.

52
00:05:02,545 --> 00:05:08,230
Por lo tanto, ese es el primer campo de mi documento.

53
00:05:10,190 --> 00:05:19,440
Luego, también incluiremos otro campo llamado como, descripción.

54
00:05:19,440 --> 00:05:29,205
La descripción es del tipo string y se requiere true.

55
00:05:29,205 --> 00:05:35,165
Además, podemos hacer que Mongoose inserte automáticamente

56
00:05:35,165 --> 00:05:41,639
marcas de tiempo en nuestro modelo.

57
00:05:41,639 --> 00:05:50,340
Así que, justo ahí podemos configurar las marcas de tiempo de la bandera: true.

58
00:05:50,340 --> 00:05:55,810
Por lo tanto, esto agregará automáticamente el creado en y actualizado en,

59
00:05:55,810 --> 00:06:01,340
dos marcas de tiempo en cada documento que se almacena

60
00:06:01,340 --> 00:06:07,235
en nuestra aplicación y actualizará automáticamente estos valores.

61
00:06:07,235 --> 00:06:11,330
Cada vez que actualicemos el documento y el creado en se

62
00:06:11,330 --> 00:06:15,390
inicializará automáticamente cuando el documento sea el primer creador de este tiempo.

63
00:06:15,390 --> 00:06:22,680
Después de esto, diremos platos var.

64
00:06:22,680 --> 00:06:24,549
Por lo tanto, dado el esquema,

65
00:06:24,549 --> 00:06:29,605
ahora vamos a construir el modelo a partir de este esquema.

66
00:06:29,605 --> 00:06:35,215
Por lo tanto, diremos modelo y plato de mangosta,

67
00:06:35,215 --> 00:06:43,570
y esto va a ser usando el esquema de plato que acabamos de declarar antes.

68
00:06:43,570 --> 00:06:48,590
A continuación, vamos a exportar

69
00:06:48,590 --> 00:06:55,725
este modelo desde este archivo aquí.

70
00:06:55,725 --> 00:06:58,410
Por lo tanto, diremos platos de exportación de módulos.

71
00:06:58,410 --> 00:07:00,545
Por lo tanto, ahora hemos construido

72
00:07:00,545 --> 00:07:05,780
el esquema Mangosta y el modelo correspondiente y el modelo ahora se exporta desde aquí.

73
00:07:05,780 --> 00:07:10,580
Por lo tanto, esto se puede importar en nuestra aplicación y usar.

74
00:07:10,580 --> 00:07:13,345
Entonces, dentro de nuestra carpeta de proyecto,

75
00:07:13,345 --> 00:07:20,415
permítanme crear un nuevo archivo llamado index.js.

76
00:07:20,415 --> 00:07:23,265
En el archivo index.js,

77
00:07:23,265 --> 00:07:31,450
permítanme primero requerir Mangosta,

78
00:07:31,820 --> 00:07:34,900
y luego después de esto podemos decir que los

79
00:07:34,900 --> 00:07:44,970
platos const requieren modelos de platos.

80
00:07:44,970 --> 00:07:49,210
Porque ya hemos creado el modelo de platos en

81
00:07:49,210 --> 00:07:55,740
el archivo de platos de modelos allí y luego lo estamos requiriendo aquí.

82
00:07:55,740 --> 00:08:02,975
Ahora, para establecer la conexión con el servidor Mongo,

83
00:08:02,975 --> 00:08:09,330
diremos const URL mongodb.

84
00:08:09,840 --> 00:08:17,110
Localhost 27017, Confusión.

85
00:08:17,110 --> 00:08:25,760
Por lo tanto, esta base de datos es la que nos conectaremos desde nuestra aplicación y

86
00:08:25,760 --> 00:08:35,125
luego podremos establecer la conexión diciendo const connect Mangoose.

87
00:08:35,125 --> 00:08:38,195
Mangoose admite este método de conexión,

88
00:08:38,195 --> 00:08:41,695
que toma la URL como primer parámetro.

89
00:08:41,695 --> 00:08:44,250
Así que una vez que hemos establecido esto,

90
00:08:44,250 --> 00:08:49,470
entonces simplemente decimos conectar entonces.

91
00:08:49,470 --> 00:08:52,280
Tenga en cuenta que como ya estamos usando promesas,

92
00:08:52,280 --> 00:08:57,680
podemos decir conectar entonces y luego esto tomará

93
00:08:57,680 --> 00:09:03,774
una función como parámetro

94
00:09:03,774 --> 00:09:10,175
y dentro de aquí ahora podemos conectarnos a la base de datos.

95
00:09:10,175 --> 00:09:13,550
Así que ahora, una vez que se establece esta conexión,

96
00:09:13,550 --> 00:09:17,800
permítanme hacer un registro de consola

97
00:09:17,800 --> 00:09:26,060
diciendo conectado correctamente al servidor,

98
00:09:26,100 --> 00:09:36,355
y aquí puedo crear un

99
00:09:36,355 --> 00:09:45,560
nuevo plato diciendo var nuevo plato y luego platos y dentro de aquí puedo especificar un documento así que estoy creando

100
00:09:45,560 --> 00:09:50,170
un nuevo plato de este tipo y luego así aquí Voy a

101
00:09:50,170 --> 00:09:55,510
especificar los dos campos que son obligatorios.

102
00:09:55,510 --> 00:09:57,920
Así que voy a decir nombre,

103
00:10:07,950 --> 00:10:16,390
descripción y así es como se crearía un nuevo plato y luego una vez que creamos

104
00:10:16,390 --> 00:10:24,910
un nuevo plato a partir del modelo simplemente vamos a decir nuevo plato guardar.

105
00:10:24,910 --> 00:10:29,760
El método de

106
00:10:29,760 --> 00:10:35,060
guardado hará que este valor de Dish se guarde y luego, como esperas, devolverá una promesa y

107
00:10:35,060 --> 00:10:45,165
luego aquí obtendremos el valor de Dish como llamada de vuelta allí y luego,

108
00:10:45,165 --> 00:10:54,940
simplemente puedo registrar el valor de Dish aquí y luego, después de eso, diremos que los

109
00:10:54,940 --> 00:11:00,915
platos encuentran y así encontraremos

110
00:11:00,915 --> 00:11:07,090
todos los Platos y luego decir exec.

111
00:11:07,090 --> 00:11:10,255
El ejecutivo se asegurará de que esto se

112
00:11:10,255 --> 00:11:15,250
ejecute y que devuelva una promesa y por lo que

113
00:11:15,250 --> 00:11:19,660
se devolverá esa promesa para que luego pueda

114
00:11:19,660 --> 00:11:27,040
encadenar el método a los restantes.

115
00:11:27,040 --> 00:11:33,975
Así que ves cómo estoy usando promesas y luego estoy invocando el método anterior para que este

116
00:11:33,975 --> 00:11:41,395
encuentre todos los Platos dentro de mi base de datos,

117
00:11:41,395 --> 00:11:45,905
en la colección Platos y luego lo ponga a mi disposición.

118
00:11:45,905 --> 00:11:55,550
Así que cuando obtenga los Platos, entonces puedo simplemente registrar los Platos solo para ver lo que se

119
00:11:55,550 --> 00:11:58,790
devuelve y esto obviamente en esta etapa debería

120
00:11:58,790 --> 00:12:02,710
devolver este único plato que he insertado en

121
00:12:02,710 --> 00:12:10,940
mi colección de platos y luego diremos que

122
00:12:11,010 --> 00:12:15,550
devuelve platos elimine con

123
00:12:15,550 --> 00:12:19,930
un objeto JavaScript vacío que eliminará todos los platos de

124
00:12:19,930 --> 00:12:24,384
la base de datos y devolverá el cierre de la

125
00:12:24,384 --> 00:12:31,790
conexión de mangosta que cierra la conexión a la base de datos.

126
00:12:35,040 --> 00:12:38,830
Y atrapar cualquier error en este punto.

127
00:12:38,830 --> 00:12:49,430
Así que usaremos la captura y luego el registro de la consola.

128
00:12:50,600 --> 00:12:57,820
Eso es todo. Así que lo que estamos haciendo aquí es que estamos creando el nuevo este plato y luego estamos

129
00:12:57,820 --> 00:13:04,255
guardando el plato y luego estamos encontrando todos los platos de la colección.

130
00:13:04,255 --> 00:13:06,740
Eso es todo. Estamos usando promesas aquí,

131
00:13:06,740 --> 00:13:10,435
así que hemos encadenado todas las guaridas aquí. Eso es todo.

132
00:13:10,435 --> 00:13:15,595
Vamos a guardar los cambios y luego ver esta aplicación ejecutándose.

133
00:13:15,595 --> 00:13:17,455
Vaya a la terminal,

134
00:13:17,455 --> 00:13:21,505
en el indicador escriba npm start y

135
00:13:21,505 --> 00:13:25,735
verá que mi aplicación de nodo se ejecuta y luego muestra,

136
00:13:25,735 --> 00:13:33,110
primero, que ha creado este Dish en particular.

137
00:13:33,110 --> 00:13:37,285
Tenga en cuenta, en particular, que estos dos campos,

138
00:13:37,285 --> 00:13:39,365
actualizados en y creados en,

139
00:13:39,365 --> 00:13:43,465
estas dos marcas de tiempo se han agregado automáticamente en

140
00:13:43,465 --> 00:13:47,790
el plato aquí y por lo que puede ver que el creado en y

141
00:13:47,790 --> 00:13:51,630
actualizado en las marcas de tiempo son exactamente los mismos en este momento y

142
00:13:51,630 --> 00:13:57,235
luego el ID también se agrega automáticamente en.

143
00:13:57,235 --> 00:14:03,210
En el siguiente paso estamos imprimiendo todos los Platos que se han recuperado y así se

144
00:14:03,210 --> 00:14:10,340
puede ver que este único plato está en la colección, la colección de

145
00:14:10,340 --> 00:14:15,935
platos, y eso es lo que se imprime en la pantalla aquí.

146
00:14:15,935 --> 00:14:25,660
Vamos a inicializar el repositorio de Git y luego vamos a configurar el archivo gitignore conseguido

147
00:14:25,660 --> 00:14:35,125
así que vamos al editor, luego creamos el archivo.gitignore y luego agregamos

148
00:14:35,125 --> 00:14:40,240
módulos de nodo al archivo gitignore y guardamos los cambios y

149
00:14:40,240 --> 00:14:45,325
luego volvemos a la solicitud déjame

150
00:14:45,325 --> 00:14:48,550
escribir estado git y vemos que

151
00:14:48,550 --> 00:14:51,955
tenemos estos archivos que no se han registrado, así que diremos

152
00:14:51,955 --> 00:14:56,545
git add y luego git

153
00:14:56,545 --> 00:15:04,535
confirmar el mensaje Mangosta Parte Uno.

154
00:15:04,535 --> 00:15:08,110
Con esto completamos este ejercicio.

155
00:15:08,110 --> 00:15:14,300
En este ejercicio hemos visto lo fácil que es configurar una aplicación de nodo con

156
00:15:14,300 --> 00:15:21,335
mangosta y conectarse a nuestro servidor MongoDB y luego interactuar con él.

157
00:15:21,335 --> 00:15:24,985
Ahora ya que mangosta se basa en el servidor MongoDB,

158
00:15:24,985 --> 00:15:28,980
Mangoose puede acceder a todos los diversos métodos

159
00:15:28,980 --> 00:15:32,690
que son compatibles con el controlador MongoDB también.