1
00:00:03,920 --> 00:00:09,645
Como entendemos a partir da palestra anterior nesta lição,

2
00:00:09,645 --> 00:00:12,585
nosso objetivo nesta lição é

3
00:00:12,585 --> 00:00:16,590
integrar o servidor REST API que já desenvolvemos,

4
00:00:16,590 --> 00:00:20,525
juntamente com o acesso ao banco de dados MongoDB.

5
00:00:20,525 --> 00:00:24,060
Então, vamos começar com o servidor REST API

6
00:00:24,060 --> 00:00:27,480
que construímos na primeira lição neste módulo,

7
00:00:27,480 --> 00:00:31,770
e depois aprendendo a interagir do

8
00:00:31,770 --> 00:00:37,220
nosso aplicativo de nó para o servidor MongoDB usando o Mongoose,

9
00:00:37,220 --> 00:00:43,865
vamos desenvolver nosso servidor REST API ainda mais para integrar

10
00:00:43,865 --> 00:00:50,749
todo o caminho entre a solicitação do cliente entrando no servidor,

11
00:00:50,749 --> 00:00:53,840
todo o caminho para a operação de banco de dados correspondente a ser executada,

12
00:00:53,840 --> 00:01:00,880
e, em seguida, construir e enviar de volta a resposta para esse cliente a partir do nosso site de servidor.

13
00:01:00,880 --> 00:01:04,125
Para começar, é claro, primeiro,

14
00:01:04,125 --> 00:01:08,300
vá para a pasta do servidor de confusão que já criamos

15
00:01:08,300 --> 00:01:15,215
no primeiro exercício deste módulo na lição REST API

16
00:01:15,215 --> 00:01:17,915
e, em seguida, na pasta de confusão,

17
00:01:17,915 --> 00:01:22,310
já construímos o servidor de API REST.

18
00:01:22,310 --> 00:01:26,630
Agora, o que estaríamos fazendo é pegar emprestado

19
00:01:26,630 --> 00:01:32,035
os modelos que desenvolvemos no exercício anterior,

20
00:01:32,035 --> 00:01:36,050
o arquivo dishes.js que desenvolvemos no exercício anterior,

21
00:01:36,050 --> 00:01:41,220
copiado para o projeto do servidor de confusão,

22
00:01:41,220 --> 00:01:44,430
e também instalar Bluebird Mongoose,

23
00:01:44,430 --> 00:01:51,225
e outro módulo chamado como Mangusto moeda, para o nosso projeto.

24
00:01:51,225 --> 00:01:54,275
Então, indo para a nossa pasta JS nó,

25
00:01:54,275 --> 00:01:57,050
vamos primeiro para a pasta nó Mangoose,

26
00:01:57,050 --> 00:02:01,970
e vemos que na subpasta modelos da pasta nó Mongoose,

27
00:02:01,970 --> 00:02:03,810
temos o arquivo dishes.js.

28
00:02:03,810 --> 00:02:07,354
Eu só vou copiar a pasta modelos,

29
00:02:07,354 --> 00:02:10,490
e então passar para a pasta do servidor de confusão,

30
00:02:10,490 --> 00:02:13,910
e então simplesmente perfurar a pasta modelos lá dentro.

31
00:02:13,910 --> 00:02:15,690
Então, uma vez que fazemos isso,

32
00:02:15,690 --> 00:02:22,540
então o arquivo dishes.js que contém o esquema e o modelo para o documento de pratos,

33
00:02:22,540 --> 00:02:28,155
são integrados em nosso servidor REST API.

34
00:02:28,155 --> 00:02:30,890
É claro que, para fazer uso disso,

35
00:02:30,890 --> 00:02:34,400
precisamos instalar o módulo do nó Mangusto,

36
00:02:34,400 --> 00:02:40,990
e um novo módulo de nó chamado como moeda Mangusto em nosso projeto.

37
00:02:40,990 --> 00:02:47,510
Então, indo para o terminal no projeto de servidor de confusão,

38
00:02:47,510 --> 00:02:52,640
certifique-se de que seu terminal ou a janela de comando está

39
00:02:52,640 --> 00:02:57,480
no projeto de servidor de confusão onde você desenvolver a API REST anteriormente,

40
00:02:57,480 --> 00:03:01,070
e neste projeto, vamos instalar.

41
00:03:01,070 --> 00:03:06,165
Então, vamos fazer npm instalar Mangusto,

42
00:03:06,165 --> 00:03:13,110
e então, um novo módulo de nó chamado como moeda Mangusto.

43
00:03:13,250 --> 00:03:16,630
O módulo de nó de moeda Mangusto,

44
00:03:16,630 --> 00:03:21,800
e visto em outro tipo de esquema para a nossa aplicação Mangusto, de

45
00:03:21,800 --> 00:03:23,770
modo que o próprio Mangusto,

46
00:03:23,770 --> 00:03:26,390
certamente já built-in tipos de esquema.

47
00:03:26,390 --> 00:03:29,505
Vimos o uso do número, a

48
00:03:29,505 --> 00:03:35,550
string e o booleano, e a matriz.

49
00:03:35,550 --> 00:03:39,760
Agora, a moeda Mangusto acrescenta suporte para moeda.

50
00:03:39,760 --> 00:03:42,385
Por que precisaríamos desse apoio monetário?

51
00:03:42,385 --> 00:03:49,040
Assim que o módulo de moeda Mangusto adiciona um novo tipo chamado como o tipo de moeda, o

52
00:03:49,040 --> 00:03:53,140
que nos permite armazenar um valor de moeda.

53
00:03:53,140 --> 00:03:56,650
Uma vez que o nosso prato vai conter um preço,

54
00:03:56,650 --> 00:04:00,760
é por isso que eu vou estar usando o módulo moeda Mangusto aqui.

55
00:04:00,760 --> 00:04:04,590
Agora, o exercício aqui,

56
00:04:04,590 --> 00:04:07,545
vamos ilustrar o uso do módulo moeda Mangusto,

57
00:04:07,545 --> 00:04:11,880
você pode ler mais detalhes sobre o módulo nó moeda Mangusto também,

58
00:04:11,880 --> 00:04:19,010
na documentação de que um link para o qual é fornecido nos recursos adicionais.

59
00:04:19,010 --> 00:04:22,489
Então, agora que instalamos esses módulos de nó,

60
00:04:22,489 --> 00:04:24,890
moeda Mangusto e Mangusto,

61
00:04:24,890 --> 00:04:33,920
vamos para o nosso aplicativo e configurá-lo para se comunicar com o servidor MongoDB.

62
00:04:33,920 --> 00:04:37,570
Agora, certifique-se de que o seu servidor MongoDB está ativo e em execução.

63
00:04:37,570 --> 00:04:40,070
Então, aqui, você vê que

64
00:04:40,070 --> 00:04:44,730
meu servidor MongoDB está sendo executado em outra guia de terminal no meu computador.

65
00:04:44,730 --> 00:04:46,670
Se você estiver executando em um computador Windows,

66
00:04:46,670 --> 00:04:54,005
verifique se ele está sendo executado em outra janela de comando do computador Windows.

67
00:04:54,005 --> 00:04:58,525
Indo para o nosso aplicativo no editor,

68
00:04:58,525 --> 00:05:01,685
primeiro começaremos com o arquivo app.js.

69
00:05:01,685 --> 00:05:03,460
Agora, no arquivo app.js,

70
00:05:03,460 --> 00:05:07,590
é aqui que construímos nossa aplicação expressa anteriormente.

71
00:05:07,590 --> 00:05:12,935
Mas agora, essa negação extra não está conectada ao servidor MongoDB back-end.

72
00:05:12,935 --> 00:05:18,085
Vamos fazer uso do módulo Mangusto,

73
00:05:18,085 --> 00:05:20,430
para estabelecer a conexão com o servidor.

74
00:05:20,430 --> 00:05:22,385
Então, entrando aqui,

75
00:05:22,385 --> 00:05:29,540
eu vou adicionar no requer o módulo Mangusto aqui.

76
00:05:29,540 --> 00:05:35,850
Então, diremos, “Const Mangusto requer Mangusto.”

77
00:05:38,120 --> 00:05:43,280
E então também, uma vez que copiamos sobre a pasta models,

78
00:05:43,280 --> 00:05:46,520
que contém o arquivo de pratos,

79
00:05:46,520 --> 00:05:51,220
que declara o esquema de pratos e o modelo.

80
00:05:51,220 --> 00:05:56,645
Então, deixe-me importar os pratos.

81
00:05:56,645 --> 00:06:04,930
Então, vamos dizer, “requisito.Slash modelos pratos.”

82
00:06:04,930 --> 00:06:07,640
Então, uma vez que tenhamos concluído isso, agora é claro,

83
00:06:07,640 --> 00:06:11,000
precisamos estabelecer a conexão com o servidor.

84
00:06:11,000 --> 00:06:13,560
Então, configurar

85
00:06:14,120 --> 00:06:24,960
URL mongodb// localhost7017/confusão,

86
00:06:27,340 --> 00:06:31,150
assim como fizemos com o exercício Mangusto,

87
00:06:31,150 --> 00:06:33,140
e então vamos dizer,

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

89
00:06:44,040 --> 00:06:51,450
Então, este é exatamente o mesmo código que usamos no exercício anterior.

90
00:06:51,450 --> 00:06:53,640
Então, vamos estabelecer a conexão.

91
00:06:53,640 --> 00:07:01,695
Então, vamos dizer, “conectar” e, em seguida, vamos dizer,

92
00:07:01,695 --> 00:07:11,610
“DB fazer it console log”.

93
00:07:11,610 --> 00:07:19,030
Dizendo: “Conectado corretamente ao servidor.”

94
00:07:21,020 --> 00:07:26,260
E nós também vamos lidar com o erro aqui.

95
00:07:33,980 --> 00:07:40,855
Vamos simplesmente fazer um registro do console do erro aqui, é isso.

96
00:07:40,855 --> 00:07:49,110
Isso estabelecerá a conexão com o servidor do nosso arquivo app.js.

97
00:07:49,110 --> 00:07:52,375
Então, uma vez que estabelecemos a conexão com o servidor,

98
00:07:52,375 --> 00:07:58,615
então, vamos abrir o arquivo dishes.js de nossos modelos.

99
00:07:58,615 --> 00:08:00,995
Agora, no arquivo dishes.js,

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

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

102
00:08:11,760 --> 00:08:18,990
Então, vamos dizer, “Exigir moeda Mangusto”, e dizer,

103
00:08:18,990 --> 00:08:26,500
“Carregue o tipo e Mangusto.”

104
00:08:26,500 --> 00:08:32,670
Então, o que isso vai fazer é carregar este novo tipo de moeda em Mangusto.

105
00:08:32,670 --> 00:08:39,970
Depois disso, podemos dizer const,

106
00:08:39,970 --> 00:08:48,705
moeda tipos Mangusto moeda.

107
00:08:48,705 --> 00:08:51,720
É isso. Então, este novo tipo,

108
00:08:51,720 --> 00:08:57,880
o tipo de moeda é adicionado em Mangusto e que irá adicionar em um novo tipo chamado

109
00:08:57,880 --> 00:09:00,160
moeda e então eu vou declarar

110
00:09:00,160 --> 00:09:04,840
esta moeda constante como a moeda de tipos do Mangusto.

111
00:09:04,840 --> 00:09:11,630
Para que eu possa fazer uso disso na definição do esquema na minha aplicação.

112
00:09:11,630 --> 00:09:14,270
Agora, neste caso,

113
00:09:14,270 --> 00:09:17,970
o esquema comum permanecerá exatamente o mesmo de antes, mas

114
00:09:17,970 --> 00:09:24,060
o esquema prato como você lembra do arquivo db.json.

115
00:09:24,060 --> 00:09:28,050
Quando você olha para a estrutura de um documento prato,

116
00:09:28,050 --> 00:09:35,630
você vê que o documento prato contém nome e imagem que como você vê aqui é uma string,

117
00:09:35,630 --> 00:09:38,570
uma categoria, um rótulo,

118
00:09:38,570 --> 00:09:42,555
um preço, que é um tipo de string aqui.

119
00:09:42,555 --> 00:09:46,865
Mas vamos declarar isso como um tipo de moeda,

120
00:09:46,865 --> 00:09:51,495
um recurso que como você espera é uma variável booleana,

121
00:09:51,495 --> 00:09:55,015
e uma descrição que é uma string e, em seguida, comentários

122
00:09:55,015 --> 00:09:59,755
que não é nada mais que uma matriz de comentários tipo.

123
00:09:59,755 --> 00:10:05,790
Agora, então o que vamos fazer agora é estender o esquema prato para

124
00:10:05,790 --> 00:10:12,865
suportar todas essas várias propriedades ou vários campos no meu documento json.

125
00:10:12,865 --> 00:10:15,225
Então já temos o nome.

126
00:10:15,225 --> 00:10:18,505
Então, já temos a descrição no lugar.

127
00:10:18,505 --> 00:10:23,730
Então precisamos adicionar nos próximos poucos já temos os comentários, a

128
00:10:23,730 --> 00:10:27,185
matriz de comentários do tipo de esquema de comentário lá.

129
00:10:27,185 --> 00:10:30,075
Então, vamos adicionar nos próximos.

130
00:10:30,075 --> 00:10:34,150
Então, o próximo que vamos adicionar em é o tipo de imagem,

131
00:10:34,150 --> 00:10:37,640
que seria

132
00:10:37,640 --> 00:10:44,300
do tipo string e

133
00:10:44,300 --> 00:10:49,140
vamos dizer true obrigatório.

134
00:10:49,200 --> 00:10:52,240
Então isso adiciona o tipo de imagem.

135
00:10:52,240 --> 00:11:00,460
O próximo que eu adicionarei é categoria,

136
00:11:00,460 --> 00:11:03,865
que também é o tipo de string.

137
00:11:03,865 --> 00:11:07,990
O próximo é label,

138
00:11:07,990 --> 00:11:10,720
que também é este tipo de string.

139
00:11:10,720 --> 00:11:14,560
Como todos estes são do mesmo tipo e necessários,

140
00:11:14,560 --> 00:11:16,625
estou apenas copiando-os aqui.

141
00:11:16,625 --> 00:11:18,464
Em seguida, para o rótulo,

142
00:11:18,464 --> 00:11:21,275
eu diria que isso não é necessário, mas

143
00:11:21,275 --> 00:11:26,945
em vez disso eu também posso especificar um valor padrão se eu quiser.

144
00:11:26,945 --> 00:11:29,465
Então eu posso especificar um valor padrão como esse.

145
00:11:29,465 --> 00:11:31,965
O valor padrão é uma string vazia.

146
00:11:31,965 --> 00:11:37,245
Então, se eu não especificar obrigatório, eu posso simplesmente especificar um valor padrão aqui.

147
00:11:37,245 --> 00:11:46,300
Agora, além disso, o próximo campo que vou introduzir é o campo de preço.

148
00:11:47,070 --> 00:11:53,575
O campo de preço declararei o tipo como moeda.

149
00:11:53,575 --> 00:11:57,085
Lembre-se que nós tínhamos declarado o tipo de moeda anteriormente

150
00:11:57,085 --> 00:12:00,380
aqui, primeiro exigindo

151
00:12:00,380 --> 00:12:03,960
o módulo de moeda Mangusto e, em seguida, declarando o tipo de moeda.

152
00:12:03,960 --> 00:12:09,435
Então, é assim que você usaria o tipo de moeda em nosso aplicativo.

153
00:12:09,435 --> 00:12:16,170
Então, vamos dizer tipo de preço moeda e

154
00:12:16,170 --> 00:12:24,610
obrigatório é verdadeiro e, em seguida, eu também posso especificar o valor mínimo que seria zero.

155
00:12:24,610 --> 00:12:29,590
Em seguida,

156
00:12:29,590 --> 00:12:35,830
o próximo campo é o campo em destaque que seria do tipo booleano,

157
00:12:35,830 --> 00:12:40,900
eo valor padrão será false.

158
00:12:40,900 --> 00:12:43,625
Então, se meu documento está faltando isso,

159
00:12:43,625 --> 00:12:47,940
então o valor padrão será adicionado ao documento aqui.

160
00:12:47,940 --> 00:12:50,470
Então note que eu agora expandi

161
00:12:50,470 --> 00:12:56,825
o esquema prato adicionando no tipo de imagem, a categoria,

162
00:12:56,825 --> 00:13:01,710
o rótulo, o preço e o recurso para combinar com

163
00:13:01,710 --> 00:13:07,925
a estrutura do exemplo de documento prato que eu acabei de mostrar anteriormente.

164
00:13:07,925 --> 00:13:13,795
Então, agora, meu esquema de pratos está tudo pronto para ser usado.

165
00:13:13,795 --> 00:13:20,185
Então, vamos agora começar a trabalhar no meu roteador.

166
00:13:20,185 --> 00:13:21,915
Então, onde está o roteador?

167
00:13:21,915 --> 00:13:29,530
Você se lembra de que o roteador que suporta os pontos finais da API REST para os pratos de barra,

168
00:13:29,530 --> 00:13:32,110
ponto final da API REST e pratos de

169
00:13:32,110 --> 00:13:35,170
barra, ponto final de ID de prato barra está no roteador prato.

170
00:13:35,170 --> 00:13:41,295
Então, vamos para o prato router.jsfile e, em seguida, vamos estender o arquivo router.js prato.

171
00:13:41,295 --> 00:13:46,735
Então, no roteador prato junto com Express e BodyParser,

172
00:13:46,735 --> 00:13:55,310
vou agora incluir Mangusto.

173
00:13:56,640 --> 00:14:03,370
Então vamos dizer exigir Mangusto e

174
00:14:03,370 --> 00:14:10,944
, em seguida, vamos exigir modelo de pratos.

175
00:14:10,944 --> 00:14:12,400
Onde está o modelo de pratos?

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

177
00:14:20,080 --> 00:14:22,405
Então está lá dentro.

178
00:14:22,405 --> 00:14:24,470
Então, observe que estamos na pasta do roteador,

179
00:14:24,470 --> 00:14:27,610
então você precisa subir um nível e, em seguida, entrar na

180
00:14:27,610 --> 00:14:31,460
pasta do modelo e, em seguida, o arquivo dishes.js está bem ali.

181
00:14:31,460 --> 00:14:34,010
Portanto, é isso que importamos aqui.

182
00:14:34,010 --> 00:14:41,039
Então, agora, eu posso atualizar meu roteador prato para ser capaz de interagir

183
00:14:41,039 --> 00:14:46,330
com o servidor Mongoose usando o

184
00:14:46,330 --> 00:14:52,175
Mongoose e nós já importamos o modelo de pratos para o meu roteador prato.

185
00:14:52,175 --> 00:14:57,720
Então, é hora de eu ir e atualizar todos os métodos aqui.

186
00:14:57,720 --> 00:14:59,465
Então, para o roteador prato,

187
00:14:59,465 --> 00:15:03,665
a barra que significa que a barra pratos endpoint.

188
00:15:03,665 --> 00:15:07,880
Vou remover tudo isso daqui, em vez disso,

189
00:15:07,880 --> 00:15:12,040
vou declarar explicitamente todos os vários pontos finais.

190
00:15:12,040 --> 00:15:16,995
Para obter post colocar e excluir eu vou lidar com cada um deles de forma independente.

191
00:15:16,995 --> 00:15:19,135
Então, no método get,

192
00:15:19,135 --> 00:15:24,360
eu vou cortar isso fora e, em seguida, no método get, o que eu preciso fazer?

193
00:15:24,360 --> 00:15:32,760
Lembre-se que tínhamos definido método de Mangusto que nos permite encontrar todos os pratos.

194
00:15:32,760 --> 00:15:36,365
Então, quando você faz uma operação get no ponto final pratos barra,

195
00:15:36,365 --> 00:15:39,600
você está esperando que todos os pratos para ser devolvido

196
00:15:39,600 --> 00:15:44,005
ao cliente em resposta ao pedido get.

197
00:15:44,005 --> 00:15:49,890
Então, eu vou para a louça e, em seguida, executar a operação de busca.

198
00:15:49,890 --> 00:15:53,040
Então agora você vê que a partir do meu servidor Express,

199
00:15:53,040 --> 00:15:58,585
eu estou acessando meu MongoDB.

200
00:15:58,585 --> 00:16:06,520
Então, vai fazer um achado e no achado eu vou agora lidar com o pedido.

201
00:16:06,520 --> 00:16:08,310
Então eu posso dizer pratos encontrar, uma

202
00:16:08,310 --> 00:16:13,885
vez que vai retornar uma promessa,

203
00:16:13,885 --> 00:16:16,765
então eu posso lidar com isso aqui dentro.

204
00:16:16,765 --> 00:16:24,520
Então, eu vou dizer prato e assim se a promessa resolver corretamente,

205
00:16:24,520 --> 00:16:33,529
eu vou obtê-lo no então e então eu vou dizer prato e então vamos lidar com o

206
00:16:33,960 --> 00:16:41,125
código de status res é 200 e, em seguida, vamos dizer

207
00:16:41,125 --> 00:16:48,920
res definir tipo de conteúdo de cabeçalho.

208
00:16:53,100 --> 00:16:57,830
Uma vez que vamos estar retornando o valor como um json,

209
00:16:57,830 --> 00:17:00,770
então vamos definir isso para aplicativo json.

210
00:17:00,770 --> 00:17:03,580
Ok, isso vai devolver uma variedade de pratos.

211
00:17:03,580 --> 00:17:07,955
Então eu posso simplesmente dizer pratos e então vamos dizer res.json.

212
00:17:07,955 --> 00:17:12,650
Então o res.json tomará como uma entrada na string json

213
00:17:12,650 --> 00:17:17,680
e, em seguida, enviá-lo de volta para o meu cliente.

214
00:17:17,680 --> 00:17:21,785
Então, quando você chamar res.json e fornecer o valor e, em seguida, ele vai simplesmente

215
00:17:21,785 --> 00:17:27,650
pegar o parâmetro que você dá aqui e, em seguida, enviá-lo de volta como uma resposta json.

216
00:17:27,650 --> 00:17:30,365
Ele vai colocar esses pratos no corpo da

217
00:17:30,365 --> 00:17:33,835
mensagem de resposta e, em seguida, enviá-lo de volta para o servidor.

218
00:17:33,835 --> 00:17:39,560
Agora, podemos lidar com o erro

219
00:17:39,560 --> 00:17:47,370
aqui dizendo o próximo erro.

220
00:17:48,100 --> 00:17:59,140
Também podemos fazer um erro de captura apenas por uma questão de completa.

221
00:17:59,140 --> 00:18:03,290
Vou colocar ambos no lugar, para

222
00:18:03,290 --> 00:18:05,960
que ambos sejam tratados como tal.

223
00:18:05,960 --> 00:18:08,305
Então, se um erro é retornado,

224
00:18:08,305 --> 00:18:11,740
então isso vai simplesmente passar o erro para

225
00:18:11,740 --> 00:18:15,260
o manipulador de erros geral para o meu aplicativo

226
00:18:15,260 --> 00:18:18,985
e o deixar que se preocupar sobre como lidar com o erro.

227
00:18:18,985 --> 00:18:21,490
Então vamos enviá-lo para isso.

228
00:18:21,490 --> 00:18:28,610
Então você vê como eu estou usando a operação de busca e, em seguida, realizando a solicitação aqui.

229
00:18:28,610 --> 00:18:30,595
Agora, para o post,

230
00:18:30,595 --> 00:18:32,904
como você já teria esperado,

231
00:18:32,904 --> 00:18:37,100
eu vou fazer pratos.create

232
00:18:38,790 --> 00:18:43,425
porque nós vamos estar criando um novo prato aqui.

233
00:18:43,425 --> 00:18:47,195
Então, lembre-se que já são vistos os pratos criar o

234
00:18:47,195 --> 00:18:52,400
uso do método anteriormente e lembre-se que o analisador de corpo

235
00:18:52,400 --> 00:18:56,950
já teria analisado o que está no corpo da mensagem e carregado

236
00:18:56,950 --> 00:19:01,510
na propriedade body da solicitação.

237
00:19:01,510 --> 00:19:08,650
Então, eu só vou pegar o corpo da solicitação e, em seguida, analisá-lo em como um parâmetro para o meu

238
00:19:08,650 --> 00:19:16,120
dishes.create método e lidar com o valor de retorno.

239
00:19:16,120 --> 00:19:21,325
Então, vamos dizer então e isso iria retornar

240
00:19:21,325 --> 00:19:26,755
um prato e nós vamos lidar com isso aqui.

241
00:19:26,755 --> 00:19:35,220
Então, vamos dizer se os pratos retornam corretamente e se os pratos postados corretamente, dirá res.

242
00:19:36,060 --> 00:19:43,045
Ok vamos fazer um console.log para nosso próprio uso.

243
00:19:43,045 --> 00:19:52,330
No lado do servidor, faremos um prato console.log dizendo “Dish Created” aqui.

244
00:19:52,330 --> 00:20:02,125
Vamos registrar esse prato para o console e então vamos dizer esses dois códigos de status de descanso.

245
00:20:02,125 --> 00:20:09,820
Vamos apenas copiar esse código e depois colá-lo lá e, neste caso,

246
00:20:09,820 --> 00:20:12,445
estamos devolvendo o prato aqui.

247
00:20:12,445 --> 00:20:16,480
O prato que entrou como um parâmetro aqui e, em seguida, deixar

248
00:20:16,480 --> 00:20:22,825
o cliente lidar com esse valor no lado do cliente,

249
00:20:22,825 --> 00:20:24,985
o que for devolvido no prato.

250
00:20:24,985 --> 00:20:27,745
Agora, também eles vão adicionar

251
00:20:27,745 --> 00:20:41,770
aqui e depois a captura.

252
00:20:41,770 --> 00:20:44,860
Então é assim que lidamos com o correio.

253
00:20:44,860 --> 00:20:47,830
Para o PUT, porque PUT não é permitido,

254
00:20:47,830 --> 00:20:50,365
então vamos deixá-lo como tal.

255
00:20:50,365 --> 00:20:54,250
Para DELETE, vamos estar excluindo todos os pratos.

256
00:20:54,250 --> 00:21:02,240
Então vamos dizer, “Pratos. Remova.”

257
00:21:03,990 --> 00:21:08,185
Esta é essencialmente uma operação perigosa.

258
00:21:08,185 --> 00:21:11,080
Então você está removendo todos os pratos

259
00:21:11,080 --> 00:21:18,610
do servidor e então vamos dizer,

260
00:21:18,610 --> 00:21:25,600
“pratos.Remova então” eo “então” vai ter alguma resposta.

261
00:21:25,600 --> 00:21:32,200
Então, vamos apenas dizer, “resp aqui” e a maneira como lidamos com

262
00:21:32,200 --> 00:21:40,550
essa resposta é simplesmente pegar esse valor e, em seguida, devolvê-lo ao cliente.

263
00:21:40,620 --> 00:21:48,550
Então, vamos dizer, “Res.StatusCode 200 content type application json” e,

264
00:21:48,550 --> 00:21:56,660
em seguida, vamos simplesmente enviar a resposta de volta para o cliente e vamos lidar com o erro

265
00:22:06,000 --> 00:22:08,830
exatamente como fizemos anteriormente.

266
00:22:08,830 --> 00:22:10,390
Essa é a operação DELETE.

267
00:22:10,390 --> 00:22:14,110
Então você vê que agora estamos fazendo a

268
00:22:14,110 --> 00:22:17,545
operação GET, POST, PUT e DELETE.

269
00:22:17,545 --> 00:22:26,425
Agora vamos continuar o mesmo com o ponto final /DISHID.

270
00:22:26,425 --> 00:22:28,270
Então, neste caso,

271
00:22:28,270 --> 00:22:34,040
estamos especificamente motivo recebendo um prato específico.

272
00:22:34,040 --> 00:22:39,480
Nós vamos estar retornando esse valor prato específico.

273
00:22:39,480 --> 00:22:41,445
Então, no GET,

274
00:22:41,445 --> 00:22:51,275
o que fazemos é dizer “dishes.findByID.

275
00:22:51,275 --> 00:22:57,965
Então, o FindByID é um método que está disponível a partir de mongo, bem como o driver MongoDB.

276
00:22:57,965 --> 00:23:02,020
Então vamos dizer,” req.params.dishid.”

277
00:23:03,600 --> 00:23:11,030
Lembre-se que já sabemos que o ID do prato está presente na propriedade params.

278
00:23:11,030 --> 00:23:14,140
Você já aprendeu sobre isso antes.

279
00:23:14,140 --> 00:23:20,260
Então eu vou dizer, “findById (req.params.dishid)” e

280
00:23:20,260 --> 00:23:24,565
, em seguida, e o outro.

281
00:23:24,565 --> 00:23:30,520
Então eu vou apenas copiar isso, então, e então, de

282
00:23:30,520 --> 00:23:38,170
lá e, em seguida, descer para o DishRouter e

283
00:23:38,170 --> 00:23:46,150
, em seguida, simplesmente colar isso aqui.

284
00:23:46,150 --> 00:23:49,190
Então vamos dizer, "Res.statusCode200

285
00:23:49,440 --> 00:23:55,585
aplicativo json.res.jsondish e, em seguida, o tratamento de erros.

286
00:23:55,585 --> 00:24:05,350
Para o POST, obviamente não vamos lidar com o post para um endpoint /DISHID.

287
00:24:05,350 --> 00:24:07,635
Então vamos deixá-la como tal.

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

289
00:24:12,740 --> 00:24:17,975
um prato específico que é identificado pelo seu ID prato.

290
00:24:17,975 --> 00:24:25,270
Então é aqui que vamos usar dishes.FindbyidandUpdate.

291
00:24:25,270 --> 00:24:27,690
Então este é o método que vamos usar,

292
00:24:27,690 --> 00:24:35,539
findByidAndUpDate e isso leva como o primeiro parâmetro

293
00:24:37,410 --> 00:24:44,410
req.params.dishid e o segundo valor é

294
00:24:44,410 --> 00:24:53,290
o conjunto e a atualização

295
00:24:53,290 --> 00:24:55,150
estará no corpo da mensagem.

296
00:24:55,150 --> 00:24:57,580
Então eu só vou recuperar isso

297
00:24:57,580 --> 00:25:05,410
do corpo de requisição e, em seguida, também a outra bandeira que eu vou ter.

298
00:25:05,410 --> 00:25:10,840
Então vai dizer, “new: true”, para que este método findById retorne

299
00:25:10,840 --> 00:25:18,730
o prato atualizado como uma string json na resposta.

300
00:25:18,730 --> 00:25:23,650
Então é isso que eu vou estar recebendo aqui e, em seguida, quando esse valor entrar,

301
00:25:23,650 --> 00:25:26,230
eu vou apenas pegar o prato e, em

302
00:25:26,230 --> 00:25:39,040
seguida, simplesmente retornar o prato para o lado do cliente.

303
00:25:39,040 --> 00:25:47,095
Então eu vou dizer res.jason (prato) e, em seguida, vamos lidar com o erro correspondentemente.

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

305
00:25:49,090 --> 00:25:50,695
Para o DELETE novamente,

306
00:25:50,695 --> 00:25:54,880
o método correspondente que vamos estar

307
00:25:54,880 --> 00:26:01,165
usando é o método do Mongo chamado findByIdAndRemove.

308
00:26:01,165 --> 00:26:03,760
Então você pode ver que temos este método chamado

309
00:26:03,760 --> 00:26:08,080
findByIdandRemove e este findByIdandRemove,

310
00:26:08,080 --> 00:26:18,355
vai tomar Req.params.Dishid porque esse é o prato que estamos tentando remover.

311
00:26:18,355 --> 00:26:20,970
Então, quando isso é excluído,

312
00:26:20,970 --> 00:26:23,940
assim como nós lidamos com isso aqui,

313
00:26:23,940 --> 00:26:30,830
então eu vou apenas copiar este código do dishes.Remove.

314
00:26:30,830 --> 00:26:34,350
É a mesma coisa que eu vou fazer aqui também.

315
00:26:34,350 --> 00:26:38,750
Então, FindByIdandRemove e qualquer resposta

316
00:26:38,750 --> 00:26:41,970
que eu receba, vou devolvê-la ao meu cliente.

317
00:26:41,970 --> 00:26:45,490
Com isso, atualizamos o DisishRouter.

318
00:26:45,490 --> 00:26:49,960
Vamos salvar todas as alterações que fizemos

319
00:26:49,960 --> 00:26:57,185
até agora e, em seguida, vamos e iniciar o nosso servidor e, em seguida, ver o que ele faz.

320
00:26:57,185 --> 00:27:01,370
Então, indo para o terminal ou a janela de comando, inicie o servidor.

321
00:27:01,370 --> 00:27:06,045
Então eu vou dizer “npm start” e o servidor agora está funcionando.

322
00:27:06,045 --> 00:27:12,030
Vamos usar o carteiro para nos comunicar com este servidor.

323
00:27:12,030 --> 00:27:15,700
Então vamos ao carteiro e, em seguida, executar certas operações.

324
00:27:15,700 --> 00:27:19,030
Então aqui você vê meu carteiro correndo aqui.

325
00:27:19,030 --> 00:27:26,450
Então deixe-me fazer uma operação GET no localhost: 3000/pratos.

326
00:27:28,300 --> 00:27:31,875
Então, quando você faz uma operação GET como você vê,

327
00:27:31,875 --> 00:27:33,205
ele retornará uma string vazia.

328
00:27:33,205 --> 00:27:36,715
Meu banco de dados agora está vazio, então eu não tenho nada lá.

329
00:27:36,715 --> 00:27:40,205
Então eu só vou ser devolvido uma string vazia.

330
00:27:40,205 --> 00:27:45,600
Vamos postar um prato.

331
00:27:46,020 --> 00:27:48,340
Então, quando você postar um prato,

332
00:27:48,340 --> 00:27:50,254
obviamente no corpo,

333
00:27:50,254 --> 00:27:58,175
você estará encerrando um prato e o corpo será definido para ser o tipo json aplicação.

334
00:27:58,175 --> 00:28:00,785
Agora, para postar um prato,

335
00:28:00,785 --> 00:28:06,770
eu já lhe dei o arquivo db.json nos recursos de exercício.

336
00:28:06,770 --> 00:28:10,880
Então, basta abrir o arquivo db.json e, em seguida, copiar o primeiro prato de

337
00:28:10,880 --> 00:28:15,390
lá e, em seguida, vamos colá-lo aqui e, em seguida, postar esse prato.

338
00:28:15,390 --> 00:28:18,735
Então, deixe-me ir ao arquivo db.jason.

339
00:28:18,735 --> 00:28:21,550
Deixe-me copiar o primeiro prato daqui.

340
00:28:21,550 --> 00:28:22,810
Então eu estou indo apenas para copiar

341
00:28:22,810 --> 00:28:32,765
todo o prato todo o caminho até lá e então eu vou postar este prato.

342
00:28:32,765 --> 00:28:36,610
Isso contém muitos dos campos que já temos aqui.

343
00:28:36,610 --> 00:28:39,895
Vamos postar este prato no servidor e ver o que acontece.

344
00:28:39,895 --> 00:28:44,605
Então, voltando para o carteiro.

345
00:28:44,605 --> 00:28:47,620
Aqui, nos dados do formulário,

346
00:28:47,620 --> 00:28:51,535
no corpo, deixe-me colar o prato no lugar.

347
00:28:51,535 --> 00:28:54,760
Então, temos os detalhes completos do prato lá.

348
00:28:54,760 --> 00:28:58,010
Vamos POST este prato para o servidor.

349
00:28:58,320 --> 00:29:01,780
Então, uma vez que o prato é postado para o servidor,

350
00:29:01,780 --> 00:29:06,580
você vê que o carteiro tem,

351
00:29:06,580 --> 00:29:09,700
deixe-me apenas encolher isso,

352
00:29:09,700 --> 00:29:18,370
e então você vê na parte inferior que este prato em particular foi postado para o banco de dados,

353
00:29:18,370 --> 00:29:20,290
para o banco de dados MongoDB pelo meu servidor.

354
00:29:20,290 --> 00:29:23,560
Então, você vê que o valor retornado

355
00:29:23,560 --> 00:29:30,760
aqui mostra quando o prato foi inserido nesse servidor.

356
00:29:30,760 --> 00:29:35,020
Então, você tem o CreateDAT e UpdateDAT adicionado lá.

357
00:29:35,020 --> 00:29:39,880
Você vê que os campos restantes estão todos armazenados lá.

358
00:29:39,880 --> 00:29:45,865
Observe particularmente como o valor do preço está sendo armazenado lá.

359
00:29:45,865 --> 00:29:49,820
É assim que a moeda armazena o valor do preço.

360
00:29:50,630 --> 00:29:53,825
Então, quando você obtém o valor de retorno,

361
00:29:53,825 --> 00:29:59,370
você precisa interpretar isso adequadamente no lado do seu cliente o que isso significa.

362
00:29:59,370 --> 00:30:08,510
Note também que o ID foi adicionado ao meu prato e para cada comentário em si,

363
00:30:08,510 --> 00:30:11,445
porque cada um dos comentários é em si é um subdocumento.

364
00:30:11,445 --> 00:30:14,370
Você terá o UpdateDAT e CreateDAT adicionados,

365
00:30:14,370 --> 00:30:21,115
e o ID de cada um dos comentários também adicionado lá automaticamente pelo meu banco de dados.

366
00:30:21,115 --> 00:30:23,080
Lá vai você. Então, agora,

367
00:30:23,080 --> 00:30:26,875
este prato foi adicionado ao meu banco de dados.

368
00:30:26,875 --> 00:30:29,589
Vamos novamente executar a operação GET,

369
00:30:29,589 --> 00:30:32,244
e, obviamente, neste ponto,

370
00:30:32,244 --> 00:30:37,135
o servidor deve retornar esse prato particular que foi adicionado em.

371
00:30:37,135 --> 00:30:39,775
Então, ele irá retornar uma variedade de pratos aqui,

372
00:30:39,775 --> 00:30:42,190
então, como você pode ver, ele retorna uma variedade de pratos.

373
00:30:42,190 --> 00:30:44,050
Claro, esta matriz contém apenas um prato

374
00:30:44,050 --> 00:30:47,245
ou aquele prato em particular foi devolvido aqui.

375
00:30:47,245 --> 00:30:49,585
Até agora, tudo bem.

376
00:30:49,585 --> 00:30:54,895
Então, vamos fazer um PUT na louça e ver o que acontece.

377
00:30:54,895 --> 00:30:56,980
Quando você faz um PUT, obviamente, ele diz,

378
00:30:56,980 --> 00:31:02,255
“operação PUT não suportado em pratos”, como esperamos.

379
00:31:02,255 --> 00:31:03,770
Vamos fazer um DELETE.

380
00:31:03,770 --> 00:31:05,575
Fazendo uma operação DELETE,

381
00:31:05,575 --> 00:31:09,030
ele retorna esta resposta dizendo,

382
00:31:09,030 --> 00:31:10,890
“N é igual a um”, ok,

383
00:31:10,890 --> 00:31:13,570
um que significa que ele excluiu um prato.

384
00:31:13,570 --> 00:31:15,660
Vamos agora novamente, executar uma operação GET,

385
00:31:15,660 --> 00:31:22,850
e então você veria que meus pratos estão vazios como esperávamos.

386
00:31:22,980 --> 00:31:25,930
Então, você vê que as

387
00:31:25,930 --> 00:31:28,405
operações GET, PUT, POST e DELETE estão funcionando corretamente.

388
00:31:28,405 --> 00:31:31,225
Agora, deixe-me POST o prato novamente

389
00:31:31,225 --> 00:31:36,110
para o servidor porque eu quero ter um prato no servidor.

390
00:31:36,270 --> 00:31:38,725
Então, deixe-me POST esse prato,

391
00:31:38,725 --> 00:31:41,425
e você notaria que o ID mudou agora.

392
00:31:41,425 --> 00:31:44,110
Então, deixe-me selecionar esse ID,

393
00:31:44,110 --> 00:31:50,630
e então vamos fazer um GET com o ID no lugar.

394
00:31:51,990 --> 00:31:55,405
Quando você faz um GET com o ID no lugar,

395
00:31:55,405 --> 00:32:02,300
você vê que ele retorna aquele prato específico como você espera.

396
00:32:02,760 --> 00:32:07,630
Vamos ao terminal e ver o que está

397
00:32:07,630 --> 00:32:12,125
sendo impresso no terminal ou na janela de comando.

398
00:32:12,125 --> 00:32:15,300
Então, indo para o terminal ou sua janela de comando,

399
00:32:15,300 --> 00:32:19,360
você vê que ele está imprimindo todas essas coisas na janela de comando.

400
00:32:19,360 --> 00:32:21,540
Então, quando fizemos a primeira operação GET,

401
00:32:21,540 --> 00:32:22,640
ele diz, GET /pratos.

402
00:32:22,640 --> 00:32:24,375
Então, isso é novamente,

403
00:32:24,375 --> 00:32:28,155
Morgan fazendo este trabalho para você, ele está imprimindo,

404
00:32:28,155 --> 00:32:31,170
rastreando esta informação e ele diz prato criado

405
00:32:31,170 --> 00:32:34,575
e, em seguida, essa informação prato particular foi impresso,

406
00:32:34,575 --> 00:32:38,190
e então ele diz POST /pratos, GET /pratos,

407
00:32:38,190 --> 00:32:41,130
e então quando você fez um PUT retornou um 403

408
00:32:41,130 --> 00:32:44,170
lá e você novamente criou pratos e assim por diante.

409
00:32:44,170 --> 00:32:47,145
Então, você vê que seu servidor está realmente fazendo todo o trabalho,

410
00:32:47,145 --> 00:32:53,110
e essas coisas estão sendo inseridas em seu banco de dados MongoDB como você esperava.

411
00:32:53,110 --> 00:32:58,540
Agora, voltando para o carteiro,

412
00:32:58,540 --> 00:33:00,850
vamos fazer um POST sobre os pratos.

413
00:33:00,850 --> 00:33:03,605
Agora, isso não é suportado no lado do servidor,

414
00:33:03,605 --> 00:33:04,750
então seu servidor deve dizer,

415
00:33:04,750 --> 00:33:10,225
“A operação POST não é suportada nesse endpoint específico”, como você pode esperar.

416
00:33:10,225 --> 00:33:13,070
Vamos fazer uma operação PUT.

417
00:33:14,430 --> 00:33:17,190
Quando você faz uma operação PUT,

418
00:33:17,190 --> 00:33:20,955
o que eu vou fazer na operação PUT é que eu vou estar

419
00:33:20,955 --> 00:33:26,860
substituindo o rótulo lá dentro.

420
00:33:26,860 --> 00:33:29,550
Então, no meu corpo da mensagem.

421
00:33:29,550 --> 00:33:34,570
Então, lembre-se que se você olhar para o arquivo db.json,

422
00:33:34,570 --> 00:33:38,180
o rótulo para isso seria novo,

423
00:33:38,180 --> 00:33:51,160
e então eu vou mudar esse rótulo para quente.

424
00:33:51,160 --> 00:33:53,040
Uma vez que isso precisa ser em Json,

425
00:33:53,040 --> 00:33:57,895
então rótulo também entre aspas Json rótulo quente,

426
00:33:57,895 --> 00:34:02,810
e, em seguida, vamos fazer um PUT up em que endpoint particular.

427
00:34:04,080 --> 00:34:07,615
A operação PUT foi bem-sucedida,

428
00:34:07,615 --> 00:34:12,280
e assim você vê que quando a operação PUT foi concluída,

429
00:34:12,280 --> 00:34:19,150
então você notaria que o rótulo agora mudou de novo para quente aqui,

430
00:34:19,150 --> 00:34:22,630
e observe em particular, o valor

431
00:34:22,630 --> 00:34:28,900
CreateDat e o valor UpdateDat.

432
00:34:28,900 --> 00:34:31,990
Então, observe que esse registro foi criado

433
00:34:31,990 --> 00:34:36,970
neste momento e foi atualizado um pouco mais tarde.

434
00:34:36,970 --> 00:34:40,000
Então, a atualização foi feita pela operação PUT que eu acabei de

435
00:34:40,000 --> 00:34:43,450
executar naquele prato particular.

436
00:34:43,450 --> 00:34:46,240
Vamos apagar o prato.

437
00:34:46,240 --> 00:34:49,795
Isto é permitido. Então, vamos excluir o prato,

438
00:34:49,795 --> 00:34:54,100
e então o prato será excluído e o valor será retornado.

439
00:34:54,100 --> 00:34:58,930
Agora, se você fizer uma operação GET

440
00:34:58,930 --> 00:35:04,615
no ponto final de pratos, você verá que isso retornará um vazio.

441
00:35:04,615 --> 00:35:09,385
Então, você acabou de excluir o prato do nosso banco de dados.

442
00:35:09,385 --> 00:35:14,095
O que eu vou fazer é executar

443
00:35:14,095 --> 00:35:20,630
uma operação GET em um prato inexistente e ver o que acontece.

444
00:35:20,630 --> 00:35:23,905
Quando eu executar uma operação GET em prato inexistente,

445
00:35:23,905 --> 00:35:27,300
ele retorna null porque esse prato não existe.

446
00:35:27,300 --> 00:35:31,570
Então, ele retorna um valor nulo dizendo que o prato não existe.

447
00:35:31,570 --> 00:35:40,525
Agora, deixe-me executar uma operação GET em um não-ObjectID e ver o que acontece.

448
00:35:40,525 --> 00:35:44,980
Ele retorna como você vê.

449
00:35:44,980 --> 00:35:46,465
Deixe-me antever isso.

450
00:35:46,465 --> 00:35:51,840
Então, ele diz, “Transmitir para ObjectID falhou para valor aqui no caminho.”

451
00:35:51,840 --> 00:35:53,840
Então, eu vou ser obviamente este não é

452
00:35:53,840 --> 00:35:57,565
um ObjectID válido então eu apenas consegui excluir parte dele,

453
00:35:57,565 --> 00:36:02,050
e então executar a operação para que ele retorna um erro dizendo,

454
00:36:02,050 --> 00:36:04,915
então você vê que há 500 erro interno servidor.

455
00:36:04,915 --> 00:36:09,505
O servidor não foi capaz de lidar com isso e, em seguida, retornar este valor aqui.

456
00:36:09,505 --> 00:36:11,925
Então, ele diz: “Não,

457
00:36:11,925 --> 00:36:13,230
isso não é permitido.”

458
00:36:13,230 --> 00:36:18,385
Então, porque isso não é um ObjectID válido.

459
00:36:18,385 --> 00:36:22,275
Assim, mesmo os erros são tratados adequadamente como você vê aqui.

460
00:36:22,275 --> 00:36:26,050
Então, deixe-me novamente, fazer uma operação GET nos pratos,

461
00:36:26,050 --> 00:36:27,975
e seu servidor ainda está em execução,

462
00:36:27,975 --> 00:36:30,650
e ele retornará um valor vazio aqui.

463
00:36:30,650 --> 00:36:34,465
Então, vimos como modificando

464
00:36:34,465 --> 00:36:40,900
nosso servidor REST API para ser capaz de interagir com o servidor MongoDB.

465
00:36:40,900 --> 00:36:45,775
Agora temos um servidor API REST completo que é capaz de armazenar,

466
00:36:45,775 --> 00:36:48,090
e recuperar, e executar várias operações

467
00:36:48,090 --> 00:36:51,220
sobre os dados que são armazenados no meu servidor MongoDB.

468
00:36:51,220 --> 00:36:54,535
Com isso, completamos este exercício.

469
00:36:54,535 --> 00:36:56,290
Então, neste exercício,

470
00:36:56,290 --> 00:37:05,200
vimos como somos capazes de interagir com o nosso servidor de API REST,

471
00:37:05,200 --> 00:37:07,560
e por sua vez, com o servidor MongoDB,

472
00:37:07,560 --> 00:37:12,400
e então estamos aproveitando o servidor MongoDB para armazenar e recuperar dados do servidor.

473
00:37:12,400 --> 00:37:14,770
Você é capaz de interagir do

474
00:37:14,770 --> 00:37:20,225
nosso aplicativo Express com o servidor MongoDB usando Mangusto.

475
00:37:20,225 --> 00:37:24,700
Este é um bom momento para você fazer um commit GIT com a mensagem,

476
00:37:24,700 --> 00:37:31,550
“Express REST API com Mangusto Parte Um”.