1
00:00:03,920 --> 00:00:09,645
Como hemos entendido en la conferencia anterior en esta lección,

2
00:00:09,645 --> 00:00:12,585
nuestro objetivo en esta lección es

3
00:00:12,585 --> 00:00:16,590
integrar el servidor REST API que ya hemos desarrollado,

4
00:00:16,590 --> 00:00:20,525
junto con el acceso a la base de datos MongoDB.

5
00:00:20,525 --> 00:00:24,060
Por lo tanto, comenzaremos con el servidor REST API

6
00:00:24,060 --> 00:00:27,480
que construimos en la primera lección de este módulo,

7
00:00:27,480 --> 00:00:31,770
y luego después de haber aprendido cómo interactuar desde

8
00:00:31,770 --> 00:00:37,220
nuestra aplicación de nodo al servidor MongoDB usando Mongoose,

9
00:00:37,220 --> 00:00:43,865
vamos a desarrollar nuestro servidor REST API más para integrar

10
00:00:43,865 --> 00:00:50,749
todo el entre la solicitud del cliente que entra en el servidor,

11
00:00:50,749 --> 00:00:53,840
hasta la operación de base de datos correspondiente a realizar,

12
00:00:53,840 --> 00:01:00,880
y luego construir y enviar de vuelta la respuesta a ese cliente desde nuestro sitio de servidor.

13
00:01:00,880 --> 00:01:04,125
Para empezar, por supuesto, primero,

14
00:01:04,125 --> 00:01:08,300
vaya a la carpeta del servidor de confusión que ya hemos creado en

15
00:01:08,300 --> 00:01:15,215
el primer ejercicio de este módulo en la lección de API REST,

16
00:01:15,215 --> 00:01:17,915
y luego, en la carpeta de confusión,

17
00:01:17,915 --> 00:01:22,310
ya hemos construido el servidor de API REST.

18
00:01:22,310 --> 00:01:26,630
Ahora, lo que estaríamos haciendo es tomar prestados

19
00:01:26,630 --> 00:01:32,035
los modelos que desarrollamos en el ejercicio anterior,

20
00:01:32,035 --> 00:01:36,050
el archivo dishes.js que desarrollamos en el ejercicio anterior,

21
00:01:36,050 --> 00:01:41,220
copiado en el proyecto de servidor de confusión,

22
00:01:41,220 --> 00:01:44,430
y también instalar Bluebird Mangoose,

23
00:01:44,430 --> 00:01:51,225
y otro módulo llamado como Mangoose moneda, a nuestro proyecto.

24
00:01:51,225 --> 00:01:54,275
Entonces, yendo a nuestra carpeta JS nodo,

25
00:01:54,275 --> 00:01:57,050
primero entramos en la carpeta del nodo Mongoose,

26
00:01:57,050 --> 00:02:01,970
y vemos que en la subcarpeta de modelos de la carpeta Mongoose,

27
00:02:01,970 --> 00:02:03,810
tenemos el archivo dishes.js.

28
00:02:03,810 --> 00:02:07,354
Solo voy a copiar la carpeta de modelos,

29
00:02:07,354 --> 00:02:10,490
y luego ir a la carpeta del servidor de confusión,

30
00:02:10,490 --> 00:02:13,910
y luego simplemente perforar la carpeta de modelos allí.

31
00:02:13,910 --> 00:02:15,690
Entonces, una vez que lo hacemos,

32
00:02:15,690 --> 00:02:22,540
entonces el archivo dishes.js que contiene el esquema y el modelo para el documento de platos,

33
00:02:22,540 --> 00:02:28,155
se integran en nuestro servidor REST API.

34
00:02:28,155 --> 00:02:30,890
Por supuesto, para hacer uso de eso,

35
00:02:30,890 --> 00:02:34,400
necesitamos instalar el módulo de nodo de mangosta,

36
00:02:34,400 --> 00:02:40,990
y un nuevo módulo de nodo llamado como moneda de mangosta en nuestro proyecto.

37
00:02:40,990 --> 00:02:47,510
Por lo tanto, yendo al terminal en el proyecto de servidor de confusión,

38
00:02:47,510 --> 00:02:52,640
asegúrese de que su terminal o la ventana de comandos estén

39
00:02:52,640 --> 00:02:57,480
en el proyecto de servidor de confusión donde desarrolle la API REST anteriormente,

40
00:02:57,480 --> 00:03:01,070
y en este proyecto, instalemos.

41
00:03:01,070 --> 00:03:06,165
Por lo tanto, vamos a hacer npm instalar Mangosta,

42
00:03:06,165 --> 00:03:13,110
y luego, un nuevo módulo de nodo llamado como Mongoose currency.

43
00:03:13,250 --> 00:03:16,630
El módulo de nodo de moneda de mangosta,

44
00:03:16,630 --> 00:03:21,800
y visto en otro tipo de esquema a nuestra aplicación de mangosta,

45
00:03:21,800 --> 00:03:23,770
por lo que la mangosta en sí,

46
00:03:23,770 --> 00:03:26,390
ciertamente ya tiene tipos de esquema incorporados.

47
00:03:26,390 --> 00:03:29,505
Hemos visto el uso del número,

48
00:03:29,505 --> 00:03:35,550
la cadena y el booleano, y la matriz.

49
00:03:35,550 --> 00:03:39,760
Ahora, la moneda de Mangosta se suma en apoyo de la moneda.

50
00:03:39,760 --> 00:03:42,385
Ahora, ¿por qué necesitaríamos este apoyo monetario?

51
00:03:42,385 --> 00:03:49,040
Así que el módulo Mongoose añade un nuevo tipo llamado como el tipo de moneda,

52
00:03:49,040 --> 00:03:53,140
que nos permite almacenar un valor de moneda.

53
00:03:53,140 --> 00:03:56,650
Dado que nuestro plato va a contener un precio,

54
00:03:56,650 --> 00:04:00,760
es por eso que voy a usar el módulo de moneda de mangosta aquí.

55
00:04:00,760 --> 00:04:04,590
Ahora, el ejercicio aquí,

56
00:04:04,590 --> 00:04:07,545
vamos a ilustrar el uso del módulo de moneda de mangosta,

57
00:04:07,545 --> 00:04:11,880
se puede leer más detalles sobre el módulo de nodo de moneda de mangosta también,

58
00:04:11,880 --> 00:04:19,010
en la documentación de que un enlace a la que se proporciona en los recursos adicionales.

59
00:04:19,010 --> 00:04:22,489
Por lo tanto, ahora que hemos instalado estos módulos de nodo,

60
00:04:22,489 --> 00:04:24,890
Mongoose y Mongoose,

61
00:04:24,890 --> 00:04:33,920
vamos a nuestra aplicación y configurarlo para comunicarse con el servidor MongoDB.

62
00:04:33,920 --> 00:04:37,570
Ahora, asegúrese de que su servidor MongoDB está en funcionamiento.

63
00:04:37,570 --> 00:04:40,070
Entonces, aquí, ves que

64
00:04:40,070 --> 00:04:44,730
mi servidor MongoDB se está ejecutando en otra pestaña de terminal en mi computadora.

65
00:04:44,730 --> 00:04:46,670
Si lo está ejecutando en un equipo con Windows,

66
00:04:46,670 --> 00:04:54,005
asegúrese de que se está ejecutando en otro comando Window de su equipo con Windows.

67
00:04:54,005 --> 00:04:58,525
Ir a nuestra aplicación en el editor,

68
00:04:58,525 --> 00:05:01,685
primero comenzaremos con el archivo app.js.

69
00:05:01,685 --> 00:05:03,460
Ahora, en el archivo app.js,

70
00:05:03,460 --> 00:05:07,590
aquí es donde construimos nuestra aplicación expresa anteriormente.

71
00:05:07,590 --> 00:05:12,935
Pero ahora, esta negación de succión extra no está conectada al servidor back-end MongoDB.

72
00:05:12,935 --> 00:05:18,085
Vamos a hacer uso del módulo Mangoose,

73
00:05:18,085 --> 00:05:20,430
para establecer la conexión con el servidor.

74
00:05:20,430 --> 00:05:22,385
Así que, al entrar aquí,

75
00:05:22,385 --> 00:05:29,540
voy a agregar el módulo requiere el mangosta aquí.

76
00:05:29,540 --> 00:05:35,850
Entonces, diremos, «Const Mangosta requiere Mangosta».

77
00:05:38,120 --> 00:05:43,280
Y luego también, ya que hemos copiado sobre la carpeta de modelos,

78
00:05:43,280 --> 00:05:46,520
que contiene el archivo de platos,

79
00:05:46,520 --> 00:05:51,220
que declara el esquema de platos y el modelo.

80
00:05:51,220 --> 00:05:56,645
Así que, déjame importar los platos.

81
00:05:56,645 --> 00:06:04,930
Por lo tanto, vamos a decir, «requiere.Modelos slash platos.»

82
00:06:04,930 --> 00:06:07,640
Entonces, una vez que hayamos completado eso, ahora, por supuesto,

83
00:06:07,640 --> 00:06:11,000
tenemos que establecer la conexión con el servidor.

84
00:06:11,000 --> 00:06:13,560
Por lo tanto, configure la

85
00:06:14,120 --> 00:06:24,960
URL mongodb// localhost7017/confusion, al

86
00:06:27,340 --> 00:06:31,150
igual que hicimos con el ejercicio Mangosta,

87
00:06:31,150 --> 00:06:33,140
y luego diremos,

88
00:06:33,140 --> 00:06:44,040
«Const connect, Mongo connect URL».

89
00:06:44,040 --> 00:06:51,450
Por lo tanto, este es exactamente el mismo código que usamos en el ejercicio anterior.

90
00:06:51,450 --> 00:06:53,640
Entonces, establezcamos la conexión.

91
00:06:53,640 --> 00:07:01,695
Por lo tanto, diremos, «conectar» y luego diremos,

92
00:07:01,695 --> 00:07:11,610
«DB hágalo registro de consola».

93
00:07:11,610 --> 00:07:19,030
Decir: «Conectado correctamente al servidor».

94
00:07:21,020 --> 00:07:26,260
Y también manejaremos el error aquí.

95
00:07:33,980 --> 00:07:40,855
Simplemente haremos un registro de consola del error aquí, eso es todo.

96
00:07:40,855 --> 00:07:49,110
Eso establecerá la conexión al servidor desde nuestro archivo app.js.

97
00:07:49,110 --> 00:07:52,375
Entonces, una vez que hayamos establecido la conexión con el servidor,

98
00:07:52,375 --> 00:07:58,615
entonces, abramos el archivo dishes.js de nuestros modelos.

99
00:07:58,615 --> 00:08:00,995
Ahora, en el archivo dishes.js,

100
00:08:00,995 --> 00:08:02,970
para hacer uso

101
00:08:02,970 --> 00:08:11,760
del módulo de nodo que acabamos de instalar.

102
00:08:11,760 --> 00:08:18,990
Por lo tanto, diremos, «Requerir moneda de mangosta», y digamos,

103
00:08:18,990 --> 00:08:26,500
«Cargar el tipo y la mangosta».

104
00:08:26,500 --> 00:08:32,670
Entonces, lo que esto hará es cargar este nuevo tipo de moneda en Mangosta.

105
00:08:32,670 --> 00:08:39,970
A partir de entonces, podemos decir const,

106
00:08:39,970 --> 00:08:48,705
moneda tipos de mangosta moneda.

107
00:08:48,705 --> 00:08:51,720
Eso es todo. Entonces, este nuevo tipo,

108
00:08:51,720 --> 00:08:57,880
el tipo de moneda se agrega a Mangosta y eso agregará un nuevo tipo llamado

109
00:08:57,880 --> 00:09:00,160
moneda y luego voy a declarar

110
00:09:00,160 --> 00:09:04,840
esta moneda constante como la moneda de los tipos de mangosta.

111
00:09:04,840 --> 00:09:11,630
Para que pueda hacer uso de esto al definir el esquema en mi aplicación.

112
00:09:11,630 --> 00:09:14,270
Ahora, en este caso,

113
00:09:14,270 --> 00:09:17,970
el esquema común seguirá siendo exactamente el mismo que antes, pero

114
00:09:17,970 --> 00:09:24,060
el esquema de plato como recuerda del archivo db.json.

115
00:09:24,060 --> 00:09:28,050
Cuando miras la estructura de un documento de plato,

116
00:09:28,050 --> 00:09:35,630
ves que el documento de plato contiene nombre e imagen que como ves aquí es una cadena,

117
00:09:35,630 --> 00:09:38,570
una categoría, una etiqueta,

118
00:09:38,570 --> 00:09:42,555
un precio, que es un tipo de cadena aquí.

119
00:09:42,555 --> 00:09:46,865
Pero vamos a declarar esto como un tipo de moneda,

120
00:09:46,865 --> 00:09:51,495
una característica que como usted espera es una variable booleana,

121
00:09:51,495 --> 00:09:55,015
y una descripción que es una cadena y luego comentarios

122
00:09:55,015 --> 00:09:59,755
que no es más que una matriz de tipo de comentarios.

123
00:09:59,755 --> 00:10:05,790
Ahora, entonces lo que haremos ahora es extender el esquema de plato para

124
00:10:05,790 --> 00:10:12,865
admitir todas estas diversas propiedades o varios campos en mi documento json.

125
00:10:12,865 --> 00:10:15,225
Así que ya tenemos el nombre.

126
00:10:15,225 --> 00:10:18,505
Así que ya tenemos la descripción en su lugar.

127
00:10:18,505 --> 00:10:23,730
Así que tenemos que añadir en los próximos pocos allí ya tenemos los comentarios,

128
00:10:23,730 --> 00:10:27,185
la matriz de comentarios del tipo de esquema de comentario allí.

129
00:10:27,185 --> 00:10:30,075
Así que vamos a añadir en los próximos.

130
00:10:30,075 --> 00:10:34,150
Entonces, el siguiente que agregaremos es el tipo de imagen,

131
00:10:34,150 --> 00:10:37,640
que sería de

132
00:10:37,640 --> 00:10:44,300
la cadena de tipo y

133
00:10:44,300 --> 00:10:49,140
diremos que es necesario verdadero.

134
00:10:49,200 --> 00:10:52,240
Entonces esto agrega el tipo de imagen.

135
00:10:52,240 --> 00:11:00,460
El siguiente que agregaré es categoría,

136
00:11:00,460 --> 00:11:03,865
que también es el tipo de cadena.

137
00:11:03,865 --> 00:11:07,990
El siguiente es la etiqueta,

138
00:11:07,990 --> 00:11:10,720
que también es este tipo de cadena.

139
00:11:10,720 --> 00:11:14,560
Dado que todos estos son del mismo tipo y requeridos,

140
00:11:14,560 --> 00:11:16,625
solo los estoy copiando aquí.

141
00:11:16,625 --> 00:11:18,464
Luego, para la etiqueta,

142
00:11:18,464 --> 00:11:21,275
diría que esto no es necesario, pero

143
00:11:21,275 --> 00:11:26,945
en su lugar también puedo especificar un valor predeterminado si quiero.

144
00:11:26,945 --> 00:11:29,465
Entonces puedo especificar un valor predeterminado como ese.

145
00:11:29,465 --> 00:11:31,965
El valor predeterminado es una cadena vacía.

146
00:11:31,965 --> 00:11:37,245
Por lo tanto, si no especifico requerido, simplemente puedo especificar un valor predeterminado aquí.

147
00:11:37,245 --> 00:11:46,300
Ahora, además, el siguiente campo que voy a introducir es el campo del precio.

148
00:11:47,070 --> 00:11:53,575
El campo de precio declararé el tipo como moneda.

149
00:11:53,575 --> 00:11:57,085
Recordemos que habíamos declarado el tipo de moneda anteriormente

150
00:11:57,085 --> 00:12:00,380
aquí al requerir primero

151
00:12:00,380 --> 00:12:03,960
el módulo Mongoose y luego declarar el tipo de moneda.

152
00:12:03,960 --> 00:12:09,435
Entonces, así es como usarías el tipo de moneda en nuestra aplicación.

153
00:12:09,435 --> 00:12:16,170
Entonces diremos que la divisa del tipo de precio

154
00:12:16,170 --> 00:12:24,610
y requerida es verdadera y luego también puedo especificar el valor mínimo que sería cero.

155
00:12:24,610 --> 00:12:29,590
Luego, el siguiente campo es

156
00:12:29,590 --> 00:12:35,830
el campo destacado que sería del tipo booleano,

157
00:12:35,830 --> 00:12:40,900
y el valor predeterminado será falso.

158
00:12:40,900 --> 00:12:43,625
Por lo tanto, si a mi documento le falta eso,

159
00:12:43,625 --> 00:12:47,940
entonces el valor predeterminado se agregará al documento aquí.

160
00:12:47,940 --> 00:12:50,470
Así que tenga en cuenta que ahora he ampliado

161
00:12:50,470 --> 00:12:56,825
el esquema de plato añadiendo en el tipo de imagen, la categoría,

162
00:12:56,825 --> 00:13:01,710
la etiqueta, el precio y la característica para que coincida con

163
00:13:01,710 --> 00:13:07,925
la estructura del ejemplo de documento de plato que acabo de mostrar antes.

164
00:13:07,925 --> 00:13:13,795
Así que ahora, mi esquema de platos está listo para ser utilizado.

165
00:13:13,795 --> 00:13:20,185
Entonces, ahora comencemos a trabajar en mi enrutador.

166
00:13:20,185 --> 00:13:21,915
Entonces, ¿dónde está el enrutador?

167
00:13:21,915 --> 00:13:29,530
Recuerde que el enrutador que admite los extremos de la API REST para los platos de barra diagonal, el

168
00:13:29,530 --> 00:13:32,110
punto final de la API REST y los platos de barra

169
00:13:32,110 --> 00:13:35,170
diagonal, el punto final de ID de plato de barra se encuentra en el enrutador de plato.

170
00:13:35,170 --> 00:13:41,295
Por lo tanto, iremos al router.jsfile de plato y luego extenderemos el archivo router.js plato.

171
00:13:41,295 --> 00:13:46,735
Entonces, en el enrutador de platos junto con Express y BodyParser,

172
00:13:46,735 --> 00:13:55,310
ahora voy a incluir Mangoose.

173
00:13:56,640 --> 00:14:03,370
Así que vamos a decir requerir mangosta y

174
00:14:03,370 --> 00:14:10,944
luego vamos a requerir platos modelo.

175
00:14:10,944 --> 00:14:12,400
¿ Dónde está el modelo de platos?

176
00:14:12,400 --> 00:14:20,080
Está dentro. /modelos/platos.

177
00:14:20,080 --> 00:14:22,405
Así que está ahí dentro.

178
00:14:22,405 --> 00:14:24,470
Así que observe que estamos en la carpeta del enrutador,

179
00:14:24,470 --> 00:14:27,610
por lo que debe subir un nivel y luego ir a

180
00:14:27,610 --> 00:14:31,460
la carpeta del modelo y luego el archivo dishes.js está allí.

181
00:14:31,460 --> 00:14:34,010
Así que eso es lo que estamos importando aquí.

182
00:14:34,010 --> 00:14:41,039
Así que ahora, puedo actualizar mi router de platos para poder interactuar

183
00:14:41,039 --> 00:14:46,330
con el servidor MongoDB usando

184
00:14:46,330 --> 00:14:52,175
Mongoose y ya hemos importado el modelo de platos en mi router de platos.

185
00:14:52,175 --> 00:14:57,720
Por lo tanto, es hora de ir y actualizar todos los métodos aquí.

186
00:14:57,720 --> 00:14:59,465
Así que para el enrutador de platos,

187
00:14:59,465 --> 00:15:03,665
la barra que significa que el extremo de los platos de corte.

188
00:15:03,665 --> 00:15:07,880
Voy a eliminar todo esto de aquí, en su lugar,

189
00:15:07,880 --> 00:15:12,040
voy a declarar explícitamente todos los diversos puntos finales.

190
00:15:12,040 --> 00:15:16,995
Para publicar y eliminar, manejaré cada uno de ellos de forma independiente.

191
00:15:16,995 --> 00:15:19,135
Entonces, en el método get,

192
00:15:19,135 --> 00:15:24,360
voy a cortar eso y luego en el método get, ¿qué necesito hacer?

193
00:15:24,360 --> 00:15:32,760
Recordemos que habíamos definido el método de Mangosta que nos permite encontrar todos los platos.

194
00:15:32,760 --> 00:15:36,365
Por lo tanto, cuando realiza una operación get en el punto final de platos de barra,

195
00:15:36,365 --> 00:15:39,600
espera que todos los platos se devuelvan

196
00:15:39,600 --> 00:15:44,005
al cliente en respuesta a la solicitud get.

197
00:15:44,005 --> 00:15:49,890
Entonces, voy a ir a los platos y luego realizar la operación de búsqueda.

198
00:15:49,890 --> 00:15:53,040
Así que ahora ves que desde mi servidor Express,

199
00:15:53,040 --> 00:15:58,585
estoy accediendo a mi MongoDB.

200
00:15:58,585 --> 00:16:06,520
Entonces, haré un hallazgo y en el hallazgo ahora voy a manejar la solicitud.

201
00:16:06,520 --> 00:16:08,310
Así que puedo decir que los platos encuentran,

202
00:16:08,310 --> 00:16:13,885
ya que eso va a devolver una promesa,

203
00:16:13,885 --> 00:16:16,765
entonces puedo manejar eso aquí dentro.

204
00:16:16,765 --> 00:16:24,520
Por lo tanto, diré plato y así que si la promesa se resuelve correctamente,

205
00:16:24,520 --> 00:16:33,529
lo obtendré en el entonces y así diré plato y luego manejaremos el

206
00:16:33,960 --> 00:16:41,125
código de estado res es 200 y luego diremos

207
00:16:41,125 --> 00:16:48,920
res tipo de contenido de encabezado establecido res.

208
00:16:53,100 --> 00:16:57,830
Dado que vamos a devolver el valor como un json,

209
00:16:57,830 --> 00:17:00,770
lo estableceremos en la aplicación json.

210
00:17:00,770 --> 00:17:03,580
Vale, esto devolverá una variedad de platos.

211
00:17:03,580 --> 00:17:07,955
Así que simplemente puedo decir platos y luego diremos res.json.

212
00:17:07,955 --> 00:17:12,650
Entonces, res.json tomará como entrada en la cadena json

213
00:17:12,650 --> 00:17:17,680
y luego la enviará de vuelta a mi cliente.

214
00:17:17,680 --> 00:17:21,785
Entonces, cuando llame a res.json y proporcione el valor y luego simplemente

215
00:17:21,785 --> 00:17:27,650
tomará el parámetro que da aquí y luego lo enviará como una respuesta json.

216
00:17:27,650 --> 00:17:30,365
Pondrá estos platos en el cuerpo

217
00:17:30,365 --> 00:17:33,835
del mensaje de respuesta y luego lo enviará de vuelta al servidor.

218
00:17:33,835 --> 00:17:39,560
Ahora, podemos manejar el error

219
00:17:39,560 --> 00:17:47,370
aquí diciendo el siguiente error.

220
00:17:48,100 --> 00:17:59,140
También podemos hacer un error de captura solo por el bien de completo.

221
00:17:59,140 --> 00:18:03,290
Sólo voy a poner ambos en su lugar aquí,

222
00:18:03,290 --> 00:18:05,960
para que ambos sean manejados como tales.

223
00:18:05,960 --> 00:18:08,305
Entonces, si se devuelve un error,

224
00:18:08,305 --> 00:18:11,740
eso simplemente pasará el error al

225
00:18:11,740 --> 00:18:15,260
controlador de errores general para mi aplicación

226
00:18:15,260 --> 00:18:18,985
y el dejar que se preocupe sobre cómo manejar el error.

227
00:18:18,985 --> 00:18:21,490
Así que vamos a enviarlo a eso.

228
00:18:21,490 --> 00:18:28,610
Entonces verá cómo estoy usando la operación de búsqueda y luego realizando la solicitud aquí.

229
00:18:28,610 --> 00:18:30,595
Ahora, para el post,

230
00:18:30,595 --> 00:18:32,904
como ya habrías esperado,

231
00:18:32,904 --> 00:18:37,100
voy a hacer plates.create

232
00:18:38,790 --> 00:18:43,425
porque vamos a crear un nuevo plato aquí.

233
00:18:43,425 --> 00:18:47,195
Por lo tanto, recuerde que ya se ha visto que los platos crean el

234
00:18:47,195 --> 00:18:52,400
uso del método antes y recuerde que el analizador corporal

235
00:18:52,400 --> 00:18:56,950
ya habría analizado lo que está en el cuerpo del mensaje y lo ha cargado

236
00:18:56,950 --> 00:19:01,510
en la propiedad body de la solicitud.

237
00:19:01,510 --> 00:19:08,650
Por lo tanto, solo tomaré el cuerpo de la solicitud y luego lo analizaré como parámetro para mi

238
00:19:08,650 --> 00:19:16,120
método dishes.create y manejaré el valor de retorno.

239
00:19:16,120 --> 00:19:21,325
Entonces, diremos entonces y esto devolvería

240
00:19:21,325 --> 00:19:26,755
un plato y lo manejaremos aquí.

241
00:19:26,755 --> 00:19:35,220
Así que diremos si los platos regresan correctamente y si los platos se publican correctamente, dirán res.

242
00:19:36,060 --> 00:19:43,045
Bien, hagamos un console.log para nuestro propio uso.

243
00:19:43,045 --> 00:19:52,330
En el lado del servidor haremos un plato console.log diciendo «Dish Created» aquí.

244
00:19:52,330 --> 00:20:02,125
Vamos a registrar ese plato en la consola y luego diremos estos dos códigos de estado de descanso.

245
00:20:02,125 --> 00:20:09,820
Vamos a copiar ese código y luego pegarlo allí y en este caso,

246
00:20:09,820 --> 00:20:12,445
vamos a devolver el plato aquí.

247
00:20:12,445 --> 00:20:16,480
El plato que ha entrado como un parámetro aquí y luego deja que

248
00:20:16,480 --> 00:20:22,825
el cliente lidiar con ese valor en el lado del cliente,

249
00:20:22,825 --> 00:20:24,985
lo que sea que se devuelva en el plato.

250
00:20:24,985 --> 00:20:27,745
Ahora, también agregarán en

251
00:20:27,745 --> 00:20:41,770
esto aquí y luego la captura.

252
00:20:41,770 --> 00:20:44,860
Así que así es como manejamos el post.

253
00:20:44,860 --> 00:20:47,830
Para el PUT, porque PUT no está permitido,

254
00:20:47,830 --> 00:20:50,365
así que vamos a dejarlo como tal.

255
00:20:50,365 --> 00:20:54,250
Para DELETE, vamos a eliminar todos los platos.

256
00:20:54,250 --> 00:21:02,240
Así que vamos a decir, «platos.Quitar».

257
00:21:03,990 --> 00:21:08,185
Esta es esencialmente una operación peligrosa.

258
00:21:08,185 --> 00:21:11,080
Así que usted está eliminando todos los platos

259
00:21:11,080 --> 00:21:18,610
del servidor y así vamos a decir,

260
00:21:18,610 --> 00:21:25,600
«platos.Retire entonces» y el «entonces» obtendrá algo de respuesta.

261
00:21:25,600 --> 00:21:32,200
Así que simplemente diremos, «resp here» y la forma en

262
00:21:32,200 --> 00:21:40,550
que manejaríamos esa respuesta es simplemente tomar ese valor y luego devolverlo al cliente.

263
00:21:40,620 --> 00:21:48,550
Entonces diremos, «Res.statusCode 200 tipo de contenido json», y

264
00:21:48,550 --> 00:21:56,660
luego simplemente enviaremos la respuesta al cliente y manejaremos el error

265
00:22:06,000 --> 00:22:08,830
como lo hicimos antes.

266
00:22:08,830 --> 00:22:10,390
Esa es la operación DELETE.

267
00:22:10,390 --> 00:22:14,110
Así que ves que ahora estamos haciendo la

268
00:22:14,110 --> 00:22:17,545
operación GET, POST, PUT y DELETE.

269
00:22:17,545 --> 00:22:26,425
Ahora vamos a continuar lo mismo con el punto final /DISHID.

270
00:22:26,425 --> 00:22:28,270
Así que en este caso,

271
00:22:28,270 --> 00:22:34,040
estamos específicamente el motivo de obtener un plato específico.

272
00:22:34,040 --> 00:22:39,480
Vamos a devolver ese valor específico del plato.

273
00:22:39,480 --> 00:22:41,445
Así que en el GET,

274
00:22:41,445 --> 00:22:51,275
lo que hacemos es decir «dishes.FindbyId.

275
00:22:51,275 --> 00:22:57,965
Entonces, el findById es un método que está disponible tanto desde mongo como desde el controlador MongoDB.

276
00:22:57,965 --> 00:23:02,020
Así que diremos,» Req.Params.Dishid.»

277
00:23:03,600 --> 00:23:11,030
Recordemos que ya sabemos que el ID del plato está presente en la propiedad params.

278
00:23:11,030 --> 00:23:14,140
Ya has aprendido sobre esto antes.

279
00:23:14,140 --> 00:23:20,260
Así que diré, «findById (req.params.dishid)» y

280
00:23:20,260 --> 00:23:24,565
luego y el otro.

281
00:23:24,565 --> 00:23:30,520
Así que voy a copiar eso entonces y otra desde

282
00:23:30,520 --> 00:23:38,170
allí y luego bajar al DishRouter y

283
00:23:38,170 --> 00:23:46,150
luego simplemente pegar eso aquí.

284
00:23:46,150 --> 00:23:49,190
Entonces diremos, "Res.statusCode200

285
00:23:49,440 --> 00:23:55,585
aplicación json.res.jsondish y luego el manejo de errores.

286
00:23:55,585 --> 00:24:05,350
Para la POST, obviamente no vamos a manejar la publicación para un endpoint /DISHID.

287
00:24:05,350 --> 00:24:07,635
Así que vamos a dejarlo como tal.

288
00:24:07,635 --> 00:24:12,740
Para PUT, vamos a actualizar

289
00:24:12,740 --> 00:24:17,975
un plato específico que se identifica por su ID de plato.

290
00:24:17,975 --> 00:24:25,270
Así que aquí es donde vamos a utilizar dishes.FindByidandUpdate.

291
00:24:25,270 --> 00:24:27,690
Así que este es el método que vamos a usar,

292
00:24:27,690 --> 00:24:35,539
findByidandUpdate y esto toma como primer parámetro

293
00:24:37,410 --> 00:24:44,410
req.params.dishid y el segundo valor es

294
00:24:44,410 --> 00:24:53,290
el conjunto y la actualización

295
00:24:53,290 --> 00:24:55,150
estará en el cuerpo del mensaje.

296
00:24:55,150 --> 00:24:57,580
Así que voy a recuperar eso

297
00:24:57,580 --> 00:25:05,410
del cuerpo de reconocimiento y luego también de la otra bandera que voy a tener.

298
00:25:05,410 --> 00:25:10,840
Así dirá, «nuevo: verdadero», para que este método FindById devuelva

299
00:25:10,840 --> 00:25:18,730
el plato actualizado como una cadena json en la respuesta.

300
00:25:18,730 --> 00:25:23,650
Así que eso es lo que voy a conseguir aquí y cuando ese valor llegue,

301
00:25:23,650 --> 00:25:26,230
sólo voy a tomar el plato y

302
00:25:26,230 --> 00:25:39,040
luego simplemente devolver el plato al lado del cliente.

303
00:25:39,040 --> 00:25:47,095
Así que diré res.jason (dish) y luego manejaremos el error correspondientemente.

304
00:25:47,095 --> 00:25:49,090
Finalmente para el DELETE.

305
00:25:49,090 --> 00:25:50,695
Para el DELETE de nuevo,

306
00:25:50,695 --> 00:25:54,880
el método correspondiente que vamos a

307
00:25:54,880 --> 00:26:01,165
usar es el método de Mongo llamado FindByIDandRemove.

308
00:26:01,165 --> 00:26:03,760
Así que puedes ver que tenemos este método llamado

309
00:26:03,760 --> 00:26:08,080
FindByIDandRemove y este FindByIDandRemove,

310
00:26:08,080 --> 00:26:18,355
tomará req.Params.Dishid porque ese es el plato que estamos tratando de eliminar.

311
00:26:18,355 --> 00:26:20,970
Luego, cuando esto se elimina,

312
00:26:20,970 --> 00:26:23,940
así que al igual que manejamos esto aquí,

313
00:26:23,940 --> 00:26:30,830
así que solo voy a copiar este código de los plates.Remove.

314
00:26:30,830 --> 00:26:34,350
Es lo mismo que voy a hacer aquí también.

315
00:26:34,350 --> 00:26:38,750
Así que FindByidandRemove y cualquiera que sea la respuesta que obtenga,

316
00:26:38,750 --> 00:26:41,970
lo devolveré a mi cliente.

317
00:26:41,970 --> 00:26:45,490
Con esto hemos actualizado el DishRouter.

318
00:26:45,490 --> 00:26:49,960
Guardemos todos los cambios que hemos hecho

319
00:26:49,960 --> 00:26:57,185
hasta ahora y luego iremos a poner en marcha nuestro servidor y luego veremos qué hace.

320
00:26:57,185 --> 00:27:01,370
Entonces, yendo al terminal o a la ventana de comandos, inicie el servidor.

321
00:27:01,370 --> 00:27:06,045
Entonces diré «inicio npm» y el servidor ahora está en funcionamiento.

322
00:27:06,045 --> 00:27:12,030
Vamos a usar al cartero para comunicarnos con este servidor.

323
00:27:12,030 --> 00:27:15,700
Así que vayamos al cartero y luego realizamos ciertas operaciones.

324
00:27:15,700 --> 00:27:19,030
Así que aquí ves a mi cartero arriba y corriendo aquí.

325
00:27:19,030 --> 00:27:26,450
Así que déjame hacer una operación GET en el localhost: 3000/platos.

326
00:27:28,300 --> 00:27:31,875
Entonces, cuando haces una operación GET como ves,

327
00:27:31,875 --> 00:27:33,205
devolverá una cadena vacía.

328
00:27:33,205 --> 00:27:36,715
Mi base de datos ahora está vacía, así que no tengo nada allí.

329
00:27:36,715 --> 00:27:40,205
Así que solo me van a devolver una cadena vacía.

330
00:27:40,205 --> 00:27:45,600
Vamos a publicar un plato.

331
00:27:46,020 --> 00:27:48,340
Así que cuando publiques un plato,

332
00:27:48,340 --> 00:27:50,254
obviamente en el cuerpo,

333
00:27:50,254 --> 00:27:58,175
estarás adjuntando un plato y el cuerpo se configurará para ser el tipo json de aplicación.

334
00:27:58,175 --> 00:28:00,785
Ahora, para publicar un plato,

335
00:28:00,785 --> 00:28:06,770
ya te he dado el archivo db.json en los recursos del ejercicio.

336
00:28:06,770 --> 00:28:10,880
Así que simplemente abra el archivo db.json y luego copie el primer plato desde

337
00:28:10,880 --> 00:28:15,390
allí y luego lo pegaremos aquí y luego publicaremos ese plato.

338
00:28:15,390 --> 00:28:18,735
Así que, déjame ir al archivo db.jason.

339
00:28:18,735 --> 00:28:21,550
Déjame copiar el primer plato de aquí.

340
00:28:21,550 --> 00:28:22,810
Así que voy a copiar

341
00:28:22,810 --> 00:28:32,765
todo el plato hasta allí y luego voy a publicar este plato.

342
00:28:32,765 --> 00:28:36,610
Esto contiene muchos de los campos que ya tenemos aquí.

343
00:28:36,610 --> 00:28:39,895
Vamos a publicar este plato en el servidor y ver qué sucede.

344
00:28:39,895 --> 00:28:44,605
Así que volvemos con el cartero.

345
00:28:44,605 --> 00:28:47,620
Aquí, en los datos del formulario,

346
00:28:47,620 --> 00:28:51,535
en el cuerpo, déjame pegar el plato en su lugar.

347
00:28:51,535 --> 00:28:54,760
Entonces, tenemos todos los detalles del plato allí.

348
00:28:54,760 --> 00:28:58,010
Vamos a POST este plato al servidor.

349
00:28:58,320 --> 00:29:01,780
Luego, una vez que el plato se publica en el servidor,

350
00:29:01,780 --> 00:29:06,580
ves que el cartero tiene,

351
00:29:06,580 --> 00:29:09,700
déjame simplemente reducir esto,

352
00:29:09,700 --> 00:29:18,370
y luego ves en la parte inferior que este plato en particular ha sido publicado en la base de datos, en la base de datos de

353
00:29:18,370 --> 00:29:20,290
MongoDB por mi servidor.

354
00:29:20,290 --> 00:29:23,560
Por lo tanto, verá que el valor devuelto

355
00:29:23,560 --> 00:29:30,760
aquí muestra cuándo se insertó el plato en ese servidor.

356
00:29:30,760 --> 00:29:35,020
Por lo tanto, tiene CreateDat y UpdateDat agregados allí.

357
00:29:35,020 --> 00:29:39,880
Verá que los campos restantes se almacenan allí.

358
00:29:39,880 --> 00:29:45,865
Tenga en cuenta en particular cómo se almacena allí el valor del precio.

359
00:29:45,865 --> 00:29:49,820
Así es como la divisa almacena el valor del precio.

360
00:29:50,630 --> 00:29:53,825
Por lo tanto, cuando obtenga el valor de retorno,

361
00:29:53,825 --> 00:29:59,370
debe interpretar esto apropiadamente en el lado del cliente lo que eso significa.

362
00:29:59,370 --> 00:30:08,510
Tenga en cuenta también que el ID se ha añadido a mi plato y para cada comentario en sí,

363
00:30:08,510 --> 00:30:11,445
porque cada uno de los comentarios es en sí mismo es un sub-documento.

364
00:30:11,445 --> 00:30:14,370
Tendrá UpdateDat y CreateDat agregados,

365
00:30:14,370 --> 00:30:21,115
y el ID de cada uno de los comentarios también agregado automáticamente por mi base de datos.

366
00:30:21,115 --> 00:30:23,080
Ahí lo tienes. Así que ahora,

367
00:30:23,080 --> 00:30:26,875
este plato se ha añadido a mi base de datos.

368
00:30:26,875 --> 00:30:29,589
Volvamos a realizar la operación GET,

369
00:30:29,589 --> 00:30:32,244
y obviamente en este punto,

370
00:30:32,244 --> 00:30:37,135
el servidor debe devolver ese plato en particular que se ha agregado.

371
00:30:37,135 --> 00:30:39,775
Por lo tanto, devolverá una variedad de platos aquí,

372
00:30:39,775 --> 00:30:42,190
por lo que como se puede ver, devuelve una variedad de platos.

373
00:30:42,190 --> 00:30:44,050
Por supuesto, esta matriz contiene solo un plato

374
00:30:44,050 --> 00:30:47,245
o ese plato en particular ha sido devuelto aquí.

375
00:30:47,245 --> 00:30:49,585
Hasta ahora, tan bien.

376
00:30:49,585 --> 00:30:54,895
Entonces, hagamos un PUT en los platos y veamos qué sucede.

377
00:30:54,895 --> 00:30:56,980
Cuando haces un PUT, obviamente, dice,

378
00:30:56,980 --> 00:31:02,255
«operación PUT no soportada en platos», como esperamos.

379
00:31:02,255 --> 00:31:03,770
Vamos a hacer un DELETE.

380
00:31:03,770 --> 00:31:05,575
Haciendo una operación DELETE,

381
00:31:05,575 --> 00:31:09,030
devuelve esta respuesta diciendo,

382
00:31:09,030 --> 00:31:10,890
«N es igual a uno», vale,

383
00:31:10,890 --> 00:31:13,570
uno significa que ha eliminado un plato.

384
00:31:13,570 --> 00:31:15,660
Vamos ahora de nuevo, realizar una operación GET,

385
00:31:15,660 --> 00:31:22,850
y luego verías que mis platos están vacíos como esperábamos.

386
00:31:22,980 --> 00:31:25,930
Por lo tanto, puede ver que las

387
00:31:25,930 --> 00:31:28,405
operaciones GET, PUT, POST y DELETE funcionan correctamente.

388
00:31:28,405 --> 00:31:31,225
Ahora, permítanme POST

389
00:31:31,225 --> 00:31:36,110
el plato nuevamente al servidor porque quiero tener un plato en el servidor.

390
00:31:36,270 --> 00:31:38,725
Entonces, déjame POST ese plato,

391
00:31:38,725 --> 00:31:41,425
y notarías que el ID ha cambiado ahora.

392
00:31:41,425 --> 00:31:44,110
Entonces, déjame seleccionar ese ID,

393
00:31:44,110 --> 00:31:50,630
y luego haremos un GET con el ID en su lugar.

394
00:31:51,990 --> 00:31:55,405
Cuando haces un GET con el ID en su lugar,

395
00:31:55,405 --> 00:32:02,300
ves que devuelve ese plato específico como lo esperas.

396
00:32:02,760 --> 00:32:07,630
Vayamos a la terminal y veamos qué

397
00:32:07,630 --> 00:32:12,125
se imprime en la terminal o en la ventana de comandos.

398
00:32:12,125 --> 00:32:15,300
Por lo tanto, yendo a la terminal o a su ventana de comandos,

399
00:32:15,300 --> 00:32:19,360
verá que está imprimiendo todas estas cosas en la ventana de comandos.

400
00:32:19,360 --> 00:32:21,540
Entonces, cuando hicimos la primera operación GET,

401
00:32:21,540 --> 00:32:22,640
dice, GET /dishes.

402
00:32:22,640 --> 00:32:24,375
Entonces, esto es de nuevo,

403
00:32:24,375 --> 00:32:28,155
Morgan haciendo este trabajo para usted, está imprimiendo,

404
00:32:28,155 --> 00:32:31,170
rastreando esta información y dice plato creado

405
00:32:31,170 --> 00:32:34,575
y luego esa información particular del plato se ha impreso,

406
00:32:34,575 --> 00:32:38,190
y luego dice POST /platos, GET /platos,

407
00:32:38,190 --> 00:32:41,130
y luego cuando hiciste un PUT devolvió un 403

408
00:32:41,130 --> 00:32:44,170
allí y de nuevo creaste platos y así sucesivamente.

409
00:32:44,170 --> 00:32:47,145
Por lo tanto, ve que su servidor realmente está haciendo todo el trabajo,

410
00:32:47,145 --> 00:32:53,110
y estas cosas se están insertando en su base de datos MongoDB como esperaba.

411
00:32:53,110 --> 00:32:58,540
Ahora, volviendo al Cartero,

412
00:32:58,540 --> 00:33:00,850
hagamos una POST de los platos.

413
00:33:00,850 --> 00:33:03,605
Ahora, esto no es compatible en el lado del servidor,

414
00:33:03,605 --> 00:33:04,750
por lo que su servidor debe decir,

415
00:33:04,750 --> 00:33:10,225
«La operación POST no es compatible con ese extremo particular», como es de esperar.

416
00:33:10,225 --> 00:33:13,070
Hagamos una operación PUT.

417
00:33:14,430 --> 00:33:17,190
Cuando haces una operación PUT,

418
00:33:17,190 --> 00:33:20,955
lo que voy a hacer en la operación PUT es que voy a

419
00:33:20,955 --> 00:33:26,860
reemplazar la etiqueta allí.

420
00:33:26,860 --> 00:33:29,550
Así que, en mi cuerpo del mensaje.

421
00:33:29,550 --> 00:33:34,570
Por lo tanto, recuerde que si miras el archivo DB.json,

422
00:33:34,570 --> 00:33:38,180
la etiqueta para eso sería nueva,

423
00:33:38,180 --> 00:33:51,160
y entonces voy a cambiar esa etiqueta a hot.

424
00:33:51,160 --> 00:33:53,040
Dado que esto necesita estar en Json,

425
00:33:53,040 --> 00:33:57,895
por lo que etiqueta también entre comillas Json label hot,

426
00:33:57,895 --> 00:34:02,810
y luego vamos a hacer un PUT en ese punto final en particular.

427
00:34:04,080 --> 00:34:07,615
La operación PUT se realizó correctamente,

428
00:34:07,615 --> 00:34:12,280
por lo que verá que cuando se realizó la operación PUT,

429
00:34:12,280 --> 00:34:19,150
entonces notará que la etiqueta ahora ha cambiado de nuevo a caliente aquí,

430
00:34:19,150 --> 00:34:22,630
y tenga en cuenta, en particular, el valor

431
00:34:22,630 --> 00:34:28,900
CreateDat y el valor UpdateDat.

432
00:34:28,900 --> 00:34:31,990
Por lo tanto, observe que este registro se creó

433
00:34:31,990 --> 00:34:36,970
en este momento y se actualizó un poco más tarde.

434
00:34:36,970 --> 00:34:40,000
Entonces, la actualización fue realizada por la operación PUT que acabo de

435
00:34:40,000 --> 00:34:43,450
realizar en ese plato en particular.

436
00:34:43,450 --> 00:34:46,240
Vamos a borrar el plato.

437
00:34:46,240 --> 00:34:49,795
Esto está permitido. Por lo tanto, eliminaremos el plato,

438
00:34:49,795 --> 00:34:54,100
y luego el plato se eliminará y se devolverá el valor.

439
00:34:54,100 --> 00:34:58,930
Ahora, si realiza una operación GET en

440
00:34:58,930 --> 00:35:04,615
el extremo de los platos, verá que esto devolverá un vacío.

441
00:35:04,615 --> 00:35:09,385
Por lo tanto, acabas de eliminar el plato de nuestra base de datos.

442
00:35:09,385 --> 00:35:14,095
Lo que voy a hacer es realizar

443
00:35:14,095 --> 00:35:20,630
una operación GET en un plato inexistente y ver qué sucede.

444
00:35:20,630 --> 00:35:23,905
Cuando realizo una operación GET en un plato inexistente,

445
00:35:23,905 --> 00:35:27,300
devuelve null porque ese plato no existe.

446
00:35:27,300 --> 00:35:31,570
Por lo tanto, devuelve un valor nulo que dice que el plato no existe.

447
00:35:31,570 --> 00:35:40,525
Ahora, permítanme realizar una operación GET en un no ObjectID y ver qué sucede.

448
00:35:40,525 --> 00:35:44,980
Regresa como ves.

449
00:35:44,980 --> 00:35:46,465
Déjame previsualizar eso.

450
00:35:46,465 --> 00:35:51,840
Por lo tanto, dice, «La conversión a ObjectID falló para el valor aquí en la ruta».

451
00:35:51,840 --> 00:35:53,840
Por lo tanto, obviamente, este no es

452
00:35:53,840 --> 00:35:57,565
un ObjectID válido, así que solo logré eliminar parte de él,

453
00:35:57,565 --> 00:36:02,050
y luego realizar la operación para que devuelva un error que dice,

454
00:36:02,050 --> 00:36:04,915
por lo que verá que hay 500 errores internos del servidor.

455
00:36:04,915 --> 00:36:09,505
El servidor no pudo manejar esto y luego devolver este valor aquí.

456
00:36:09,505 --> 00:36:11,925
Así que dice: «No,

457
00:36:11,925 --> 00:36:13,230
esto no está permitido».

458
00:36:13,230 --> 00:36:18,385
Entonces, porque eso no es un ObjectID válido.

459
00:36:18,385 --> 00:36:22,275
Por lo tanto, incluso los errores se manejan apropiadamente como se ve aquí.

460
00:36:22,275 --> 00:36:26,050
Entonces, permítanme de nuevo, haga una operación GET en los platos,

461
00:36:26,050 --> 00:36:27,975
y su servidor aún se está ejecutando,

462
00:36:27,975 --> 00:36:30,650
y devolverá un valor vacío aquí.

463
00:36:30,650 --> 00:36:34,465
Por lo tanto, hemos visto cómo modificando

464
00:36:34,465 --> 00:36:40,900
nuestro servidor API REST para poder interactuar con el servidor MongoDB.

465
00:36:40,900 --> 00:36:45,775
Ahora tenemos un servidor API REST completo que es capaz de almacenar,

466
00:36:45,775 --> 00:36:48,090
recuperar, y realizar varias operaciones

467
00:36:48,090 --> 00:36:51,220
en los datos que se almacenan en mi servidor MongoDB.

468
00:36:51,220 --> 00:36:54,535
Con esto, completamos este ejercicio.

469
00:36:54,535 --> 00:36:56,290
Por lo tanto, en este ejercicio,

470
00:36:56,290 --> 00:37:05,200
hemos visto cómo somos capaces de interactuar con nuestro servidor REST API,

471
00:37:05,200 --> 00:37:07,560
y a su vez, con el servidor MongoDB,

472
00:37:07,560 --> 00:37:12,400
y luego estamos aprovechando el servidor MongoDB para almacenar y recuperar datos del servidor.

473
00:37:12,400 --> 00:37:14,770
Puede interactuar desde

474
00:37:14,770 --> 00:37:20,225
nuestra aplicación Express con el servidor MongoDB usando Mongoose.

475
00:37:20,225 --> 00:37:24,700
Este es un buen momento para que realice una confirmación de GIT con el mensaje

476
00:37:24,700 --> 00:37:31,550
«Express REST API with Mangoose Part One».