1
00:00:03,710 --> 00:00:07,605
Agora que aprendemos sobre a População de Mangusto,

2
00:00:07,605 --> 00:00:14,040
e como ela nos permite preencher um documento com informações de outro documento.

3
00:00:14,040 --> 00:00:20,605
Neste exercício, vamos modificar o servidor expresso que temos trabalhado até agora.

4
00:00:20,605 --> 00:00:25,580
No esquema prato que definimos anteriormente, tivemos comentários.

5
00:00:25,580 --> 00:00:28,365
Para os comentários, tivemos o campo de autor

6
00:00:28,365 --> 00:00:31,490
que usamos para armazenar os detalhes sobre o autor.

7
00:00:31,490 --> 00:00:40,815
Neste exercício, vamos transformar o campo autor em uma referência a um documento de usuário,

8
00:00:40,815 --> 00:00:46,265
e vamos usar a população de Mangusto para preencher a informação

9
00:00:46,265 --> 00:00:50,330
no documento de pratos como e quando necessário,

10
00:00:50,330 --> 00:00:54,440
a fim de fornecer a informação ao cliente.

11
00:00:54,440 --> 00:00:59,960
Agora, o uso de população e Mangusto população deve ser feito

12
00:00:59,960 --> 00:01:05,550
judiciosamente de modo a não causar muita sobrecarga no lado do servidor.

13
00:01:05,550 --> 00:01:06,890
Agora, neste exercício,

14
00:01:06,890 --> 00:01:09,395
vamos usá-lo simplesmente para preencher as informações

15
00:01:09,395 --> 00:01:13,280
no campo autor de nossos comentários.

16
00:01:13,280 --> 00:01:18,660
Então, vamos prosseguir com o exercício para aprender como usamos a população de Mangusto.

17
00:01:18,660 --> 00:01:21,455
Para começar este exercício,

18
00:01:21,455 --> 00:01:25,315
vá para o projeto e abra o arquivo user.js.

19
00:01:25,315 --> 00:01:27,730
Então, no arquivo user.js,

20
00:01:27,730 --> 00:01:29,600
armazenamos o esquema do usuário.

21
00:01:29,600 --> 00:01:35,515
Vou modificar o esquema do usuário adicionando mais alguns campos lá.

22
00:01:35,515 --> 00:01:38,220
Um é o primeiro nome,

23
00:01:38,220 --> 00:01:40,070
que será

24
00:01:40,070 --> 00:01:48,115
do tipo string e

25
00:01:48,115 --> 00:01:52,025
o padrão seria uma string vazia.

26
00:01:52,025 --> 00:01:56,555
Então, o primeiro nome como o nome indica,

27
00:01:56,555 --> 00:02:03,630
armazena o primeiro nome para o usuário e, em seguida, teremos outro campo chamado sobrenome,

28
00:02:03,630 --> 00:02:06,540
que também é do mesmo tipo.

29
00:02:06,540 --> 00:02:13,540
Então, eu vou apenas copiar esses dois pedaços de informação e, em seguida, copiá-lo

30
00:02:13,540 --> 00:02:20,735
aqui e agora nosso documento de usuário irá conter,

31
00:02:20,735 --> 00:02:22,840
além do nome de usuário e senha,

32
00:02:22,840 --> 00:02:26,760
nome de usuário e silêncio e salt que vimos anteriormente,

33
00:02:26,760 --> 00:02:34,450
que é automaticamente adicionado pelo módulo local do passaporte Mangusto .

34
00:02:34,450 --> 00:02:39,840
Nós também teremos o primeiro nome e sobrenome para o usuário que está sendo definido aqui.

35
00:02:39,840 --> 00:02:43,505
Mais tarde veremos como inicializaríamos

36
00:02:43,505 --> 00:02:50,765
esses valores modificando o processo de registro do usuário.

37
00:02:50,765 --> 00:02:52,950
Agora, uma vez que tenhamos concluído

38
00:02:52,950 --> 00:02:56,599
isso, desta forma as informações do usuário

39
00:02:56,599 --> 00:03:00,880
podem simplesmente ser recuperadas pesquisando o documento do usuário aqui.

40
00:03:00,880 --> 00:03:05,200
Então, agora que temos as informações sobre o usuário no documento do usuário,

41
00:03:05,200 --> 00:03:08,560
indo para o esquema prato,

42
00:03:08,560 --> 00:03:11,015
então indo para o arquivo dishes.js.

43
00:03:11,015 --> 00:03:13,260
No esquema prato anteriormente,

44
00:03:13,260 --> 00:03:18,465
estávamos armazenando o autor do documento na forma de uma string aqui.

45
00:03:18,465 --> 00:03:22,700
Agora vamos aproveitar o fato de que

46
00:03:22,700 --> 00:03:27,425
temos o apoio da população de mangustos.

47
00:03:27,425 --> 00:03:33,740
Então eu vou transformar o campo de comentário de uma string em

48
00:03:33,740 --> 00:03:41,975
tipos de esquema mangusto ID de objeto.

49
00:03:41,975 --> 00:03:49,120
Então, por aqui, desculpe, campo errado.

50
00:03:49,120 --> 00:03:53,135
Eu queria transformar o campo autor em

51
00:03:53,135 --> 00:04:02,295
tipos de esquema mangusto ID de objeto.

52
00:04:02,295 --> 00:04:05,390
Então, o campo autor agora em vez de armazenar uma string,

53
00:04:05,390 --> 00:04:10,835
terá uma referência ao documento do usuário.

54
00:04:10,835 --> 00:04:14,105
Então, quando eu transformar o campo autor neste tipo,

55
00:04:14,105 --> 00:04:20,180
então a segunda propriedade que eu defini aqui será uma referência,

56
00:04:20,180 --> 00:04:25,229
que seria uma referência ao modelo do usuário.

57
00:04:25,229 --> 00:04:27,980
Então, desta forma, vamos agora estar

58
00:04:27,980 --> 00:04:31,370
conectando este campo de autor e este campo de autor

59
00:04:31,370 --> 00:04:37,585
simplesmente armazenará uma referência ao ID do documento do usuário,

60
00:04:37,585 --> 00:04:43,790
em vez de armazenar os detalhes sobre o autor na forma de um nome.

61
00:04:43,790 --> 00:04:45,100
Agora, quando fazemos isso,

62
00:04:45,100 --> 00:04:48,350
podemos usar mangusto para preencher

63
00:04:48,350 --> 00:04:53,115
esta informação em nosso documento pratos sempre que necessário.

64
00:04:53,115 --> 00:04:58,595
Então, com esta modificação para o esquema de pratos, no arquivo dishes.js,

65
00:04:58,595 --> 00:05:05,910
vamos agora atualizar o roteador prato para usar a população de mangusto.

66
00:05:05,910 --> 00:05:09,030
Então, indo para dishRouter.js.

67
00:05:09,030 --> 00:05:16,120
No roteador prato, lembre-se que quando estávamos recebendo um prato aqui,

68
00:05:16,120 --> 00:05:19,470
agora quando você começa o prato aqui,

69
00:05:19,470 --> 00:05:23,820
dizemos pratos encontrar então.

70
00:05:23,820 --> 00:05:26,610
Então, nesse ponto,

71
00:05:26,610 --> 00:05:36,005
vamos dizer pratos encontrar e vamos dizer depois disso, povoar.

72
00:05:36,005 --> 00:05:41,924
Então, estamos usando o apoio da população em mangusto

73
00:05:41,924 --> 00:05:48,165
e vamos dizer preencher comentários autor.

74
00:05:48,165 --> 00:05:49,740
Então, afirmando isso,

75
00:05:49,740 --> 00:05:51,060
estamos dizendo que quando

76
00:05:51,060 --> 00:05:58,750
o documento de pratos foi construído para enviar de volta a resposta para o usuário,

77
00:05:58,750 --> 00:06:05,810
vamos preencher o campo de autor lá dentro a partir do documento de usuário lá dentro.

78
00:06:05,810 --> 00:06:09,095
Então, esta chamada para o preenchimento irá garantir que

79
00:06:09,095 --> 00:06:14,665
o outro campo será preenchido com as informações conforme necessário.

80
00:06:14,665 --> 00:06:18,565
Da mesma forma, indo para o ID prato aqui,

81
00:06:18,565 --> 00:06:21,660
mesmo no ID do prato, mesma coisa.

82
00:06:21,660 --> 00:06:31,680
Vamos dizer preencher e comentários autor adicionado

83
00:06:31,680 --> 00:06:37,320
nos pratos encontrar por id

84
00:06:37,320 --> 00:06:43,395
no get do endpoint /dish ID.

85
00:06:43,395 --> 00:06:54,350
Da mesma forma, nos comentários também quando

86
00:06:54,520 --> 00:07:02,370
recuperamos o prato, vamos dizer preencher comentários autor aqui e a

87
00:07:02,370 --> 00:07:09,900
mesma coisa também no roteador prato,

88
00:07:09,900 --> 00:07:13,695
comentários ID prato, ID comentário também.

89
00:07:13,695 --> 00:07:16,530
Quanto maior a preencher esta informação lá.

90
00:07:16,530 --> 00:07:22,620
Agora, é claro, o que isso significa é que quando você está postando o prato,

91
00:07:22,620 --> 00:07:30,090
mais cedo você está incluindo as informações do autor no corpo da mensagem.

92
00:07:30,090 --> 00:07:35,120
Então, agora aqui quando tentamos empurrar o comentário para que,

93
00:07:35,120 --> 00:07:41,370
então este post corresponde ao campo de comentários ID prato.

94
00:07:41,370 --> 00:07:46,280
Então, é assim que estávamos postando um comentário para um prato específico.

95
00:07:46,280 --> 00:07:48,570
Então, agora neste post,

96
00:07:48,570 --> 00:07:53,890
já que não estamos armazenando mais as informações sobre o autor,

97
00:07:53,890 --> 00:08:02,400
então o que precisamos fazer é quando empurrar o item para o campo de autor lá.

98
00:08:02,400 --> 00:08:06,720
Então, aqui quando você está preenchendo a informação no prato,

99
00:08:06,720 --> 00:08:10,680
nós vamos ter primeiro -

100
00:08:12,010 --> 00:08:16,430
Lembre-se que o corpo contém o comentário já,

101
00:08:16,430 --> 00:08:21,505
mas a propriedade do autor não estará lá no corpo da mensagem no livro,

102
00:08:21,505 --> 00:08:26,020
mas dependendo de qual usuário está postando esta informação,

103
00:08:26,020 --> 00:08:29,250
podemos preencha imediatamente o campo de autor.

104
00:08:29,250 --> 00:08:32,535
Agora, como sabemos qual usuário está postando essa informação?

105
00:08:32,535 --> 00:08:38,165
O fato de termos feito o usuário de verificação aqui para a postagem,

106
00:08:38,165 --> 00:08:42,115
significa que um usuário específico está postando essas informações,

107
00:08:42,115 --> 00:08:44,250
e fazendo o usuário de verificação,

108
00:08:44,250 --> 00:08:50,415
nós já teríamos carregado no req.user no objeto de solicitação.

109
00:08:50,415 --> 00:08:51,925
No objeto de solicitação,

110
00:08:51,925 --> 00:08:55,565
podemos entrar e dizer usuário naufrágio

111
00:08:55,565 --> 00:08:59,010
e, em seguida, sublinhar ID aqui.

112
00:08:59,010 --> 00:09:01,910
Então, mais uma vez, permitam-me reiterar este ponto,

113
00:09:01,910 --> 00:09:05,760
como é que estamos a obter as informações do autor aqui?

114
00:09:05,760 --> 00:09:10,470
Agora, lembre-se que atualizamos o esquema de pratos,

115
00:09:10,470 --> 00:09:13,875
para que o campo autor no comentário simplesmente armazene

116
00:09:13,875 --> 00:09:20,915
o ID do objeto referente ao usuário que está postando este comentário.

117
00:09:20,915 --> 00:09:24,450
Agora, como sabemos qual usuário está postando esse comentário?

118
00:09:24,450 --> 00:09:27,085
Agora, novamente, para reiterar este ponto,

119
00:09:27,085 --> 00:09:31,825
lembre-se que quando verificamos o usuário aqui chamando autenticar verificar usuário,

120
00:09:31,825 --> 00:09:37,590
o passaporte autorizado JWT teria carregado

121
00:09:37,590 --> 00:09:45,120
as informações do usuário no corpo da solicitação na forma de req.user.

122
00:09:45,120 --> 00:09:48,470
Então, esse usuário conterá o ID

123
00:09:48,470 --> 00:09:52,520
do usuário específico que está realmente postando este comentário.

124
00:09:52,520 --> 00:09:55,730
Então, já verificamos a autenticidade do usuário,

125
00:09:55,730 --> 00:10:01,400
e assim o ID do usuário pode simplesmente ser obtido dizendo req.user.

126
00:10:01,400 --> 00:10:04,400
_ID, e o ID desse usuário,

127
00:10:04,400 --> 00:10:09,380
eu atribuirei isso ao campo autor fora do comentário.

128
00:10:09,380 --> 00:10:10,990
Agora, quando o comentário entrar,

129
00:10:10,990 --> 00:10:13,880
o comentário no corpo da mensagem de solicitação

130
00:10:13,880 --> 00:10:17,355
conterá apenas o campo de classificação e o campo de comentário.

131
00:10:17,355 --> 00:10:23,425
Agora nós não queremos enviar explicitamente o campo autor do lado do cliente,

132
00:10:23,425 --> 00:10:26,090
em vez disso, que deve ser inserido automaticamente

133
00:10:26,090 --> 00:10:28,990
no lado do servidor com base na autenticidade

134
00:10:28,990 --> 00:10:32,180
do usuário Esse é o ponto que eu estava

135
00:10:32,180 --> 00:10:36,830
reiterando nesta modificação que eu fiz aqui.

136
00:10:36,830 --> 00:10:43,400
Então, essas informações dos usuários são automaticamente obtidas do req.user que é

137
00:10:43,400 --> 00:10:50,200
carregado no corpo da mensagem de solicitação pelo usuário autenticar verificar,

138
00:10:50,200 --> 00:10:55,250
que usará a autenticação do Passport com a estratégia JWT lá.

139
00:10:55,250 --> 00:10:59,795
Além disso, agora, quando recebemos o prato atualizado aqui,

140
00:10:59,795 --> 00:11:03,695
precisamos preencher as informações do autor no prato.

141
00:11:03,695 --> 00:11:05,500
Então, neste ponto,

142
00:11:05,500 --> 00:11:08,675
quando recebemos o prato aqui,

143
00:11:08,675 --> 00:11:15,370
vamos então procurar os pratos aqui.

144
00:11:15,370 --> 00:11:20,150
Então, vamos dizer dishes.findById

145
00:11:21,000 --> 00:11:28,090
e, em seguida, fornecer o ID do prato como o parâmetro aqui,

146
00:11:28,090 --> 00:11:30,190
então vamos dizer encontrar por ID,

147
00:11:30,190 --> 00:11:33,175
ID do prato, e, em seguida,

148
00:11:33,175 --> 00:11:43,405
precisamos preencher o autor comentários aqui,

149
00:11:43,405 --> 00:11:55,600
e então vamos dizer, em seguida, prato.

150
00:11:55,600 --> 00:12:04,370
Lá dentro, nós vamos estar enviando esta informação prato de volta para o usuário aqui.

151
00:12:04,370 --> 00:12:07,260
Então, deixe-me cortar isso e colar isso aqui.

152
00:12:07,260 --> 00:12:12,670
Então, esta modificação é necessária porque agora eu preciso preencher

153
00:12:12,670 --> 00:12:15,190
as informações do autor de volta para

154
00:12:15,190 --> 00:12:18,760
o comentário antes que eu possa enviar o atual de volta para o usuário.

155
00:12:18,760 --> 00:12:22,220
Então, esta é a modificação adicional que precisamos

156
00:12:22,220 --> 00:12:26,105
fazer quando usamos a população de Mangusto aqui.

157
00:12:26,105 --> 00:12:29,950
Da mesma forma, agora indo para o put,

158
00:12:29,950 --> 00:12:34,450
quando modificamos um comentário específico com o ID de comentário,

159
00:12:34,450 --> 00:12:40,830
então este é sob a ID prato comentários parte ID comentário.

160
00:12:40,830 --> 00:12:42,890
Então, quando fazemos a colocar aqui,

161
00:12:42,890 --> 00:12:49,230
então primeiro encontramos os pratos encontrar por id req params prato ID,

162
00:12:49,230 --> 00:12:50,840
em seguida, no prato.

163
00:12:50,840 --> 00:12:57,160
Então, a primeira coisa que verificamos é garantir que, se o prato não é nulo,

164
00:12:57,160 --> 00:13:01,430
e o prato comentários ID não é nulo,

165
00:13:01,430 --> 00:13:08,665
então verificamos para ter certeza de que o comentário está realmente presente no prato,

166
00:13:08,665 --> 00:13:12,320
e então, quando o prato em si é devolvido,

167
00:13:12,320 --> 00:13:16,385
então precisamos procurar novamente

168
00:13:16,385 --> 00:13:21,230
o prato porque precisamos preencher o autor comentários no prato.

169
00:13:21,230 --> 00:13:27,950
Então aqui, vamos dizer dishes.findByID (ID do prato),

170
00:13:31,750 --> 00:13:36,880
a razão pela qual precisamos fazer mais uma pesquisa é porque

171
00:13:36,880 --> 00:13:42,240
precisamos preencher os comments.author aqui,

172
00:13:42,240 --> 00:13:46,355
então essa é a única razão pela qual precisamos fazer mais uma pesquisa aqui.

173
00:13:46,355 --> 00:13:50,720
Então, quando recebemos o prato aqui,

174
00:13:52,260 --> 00:13:57,700
obviamente, porque acabamos de atualizar o prato para que a informação do prato deve ser

175
00:13:57,700 --> 00:14:03,640
encontrada no banco de dados, de

176
00:14:03,640 --> 00:14:07,490
modo que deve funcionar bem e, em seguida, dentro vai dizer

177
00:14:07,490 --> 00:14:12,215
código de status de risco 200 res definir cabeçalho conteúdo tipo aplicativo json,

178
00:14:12,215 --> 00:14:14,960
e, em seguida, retornar o prato aqui,

179
00:14:14,960 --> 00:14:16,740
e então vamos lidar com o erro aqui,

180
00:14:16,740 --> 00:14:19,630
e depois os outros se os pratos

181
00:14:19,630 --> 00:14:24,095
agora e também os outros erros que configuramos anteriormente,

182
00:14:24,095 --> 00:14:27,050
eles serão tratados como de costume aqui.

183
00:14:27,050 --> 00:14:32,790
Então, estas são as mudanças adicionais que precisamos ter certeza quando você atualizar o prato,

184
00:14:32,790 --> 00:14:39,175
quando você está enviando de volta o comentário atualizado ou prato atualizado,

185
00:14:39,175 --> 00:14:44,485
então vamos preencher o comentário no prato aqui.

186
00:14:44,485 --> 00:14:48,160
Da mesma forma, indo para o delete aqui,

187
00:14:48,160 --> 00:14:50,575
e depois do delete o comentário,

188
00:14:50,575 --> 00:14:59,310
novamente vamos ser buscar o prato e preencher as informações do autor.

189
00:14:59,310 --> 00:15:01,275
Então, deixe-me apenas copiar esta parte,

190
00:15:01,275 --> 00:15:04,130
e então nós estaremos fazendo exatamente a mesma coisa aqui,

191
00:15:04,130 --> 00:15:06,770
então vamos dizer prato salvar,

192
00:15:06,770 --> 00:15:16,210
então nós vamos estar, em seguida, verificando dish.findById (autor do prato),

193
00:15:16,210 --> 00:15:19,760
e então vamos preencher o autor comentários,

194
00:15:19,760 --> 00:15:21,925
e então vamos dizer (então) prato,

195
00:15:21,925 --> 00:15:24,920
e então res.StatusCode, e assim por diante,

196
00:15:24,920 --> 00:15:29,350
e o tratamento de erros restantes como antes aqui.

197
00:15:29,350 --> 00:15:33,040
Então, com esta modificação para o roteador prato,

198
00:15:33,040 --> 00:15:41,420
agora o último ponto que precisamos considerar é o fato de que no arquivo user.js,

199
00:15:41,420 --> 00:15:43,740
agora adicionamos em campos,

200
00:15:43,740 --> 00:15:49,050
o primeiro nome e sobrenome campo que por padrão será strings vazias.

201
00:15:49,050 --> 00:15:51,880
Assim, quando o usuário está se registrando,

202
00:15:51,880 --> 00:15:54,670
devemos permitir que o usuário forneça o nome e

203
00:15:54,670 --> 00:15:58,040
sobrenome no processo de registro.

204
00:15:58,040 --> 00:16:00,040
Agora, onde isso acontece?

205
00:16:00,040 --> 00:16:03,025
Isso ocorre no usuário.js.

206
00:16:03,025 --> 00:16:05,390
Então, indo para usuários users.js,

207
00:16:05,390 --> 00:16:09,885
quando o usuário postar na barra de inscrição,

208
00:16:09,885 --> 00:16:13,050
anteriormente estávamos apenas postando o nome de usuário e senha.

209
00:16:13,050 --> 00:16:15,105
Além desses dois,

210
00:16:15,105 --> 00:16:21,785
no objeto json que incluímos no corpo da mensagem de solicitação chegando,

211
00:16:21,785 --> 00:16:25,530
a mensagem de solicitação de post vindo do lado do cliente,

212
00:16:25,530 --> 00:16:29,590
também podemos incluir o nome e sobrenome para o usuário.

213
00:16:29,590 --> 00:16:33,740
Então, quando o nome e sobrenome do usuário estão incluídos,

214
00:16:33,740 --> 00:16:35,590
então o que eu vou fazer aqui?

215
00:16:35,590 --> 00:16:42,450
Então, lembre-se de que quando você diz user.register neste momento as informações do usuário entram,

216
00:16:42,450 --> 00:16:45,785
e então você enviou o nome de usuário aqui,

217
00:16:45,785 --> 00:16:49,460
e você também atribuiu a senha aqui que será

218
00:16:49,460 --> 00:16:53,380
transformada em hash e sal pelo passaporte mangusto local.

219
00:16:53,380 --> 00:17:00,000
Agora, se não houver nenhum erro, isso significa que o registro do usuário foi bem sucedido,

220
00:17:00,000 --> 00:17:08,740
e então neste ponto o que vamos fazer é dizer se req.body.

221
00:17:08,740 --> 00:17:13,420
Primeiro nome. Então, o que significa que o corpo da mensagem de solicitação de entrada,

222
00:17:13,420 --> 00:17:16,345
se ele contém o primeiro nome,

223
00:17:16,345 --> 00:17:24,770
então vamos dizer user.firstname é igual a req.body.firstname.

224
00:17:26,160 --> 00:17:29,675
Da mesma forma, para o sobrenome também.

225
00:17:29,675 --> 00:17:32,040
Então, neste ponto,

226
00:17:32,040 --> 00:17:34,780
teríamos o usuário disponível aqui.

227
00:17:34,780 --> 00:17:40,125
Veja o usuário está chegando como o segundo parâmetro para esta função de retorno de chamada aqui.

228
00:17:40,125 --> 00:17:43,455
Então, estamos configurando o primeiro nome alterando

229
00:17:43,455 --> 00:17:51,490
a propriedade primeiro nome dentro do documento do usuário aqui dizendo, req.body.firstname.

230
00:17:51,490 --> 00:17:55,395
Se ele existir, então vamos definir o primeiro nome do usuário para isso.

231
00:17:55,395 --> 00:18:03,220
Da mesma forma, se o nome req.body.last estiver disponível,

232
00:18:03,220 --> 00:18:09,630
então também atualizaremos o sobrenome do usuário como req.body.lastname.

233
00:18:09,770 --> 00:18:16,650
E uma vez que tenhamos feito essas duas alterações para o primeiro nome e o sobrenome,

234
00:18:16,650 --> 00:18:23,160
então precisamos salvar a modificação que fizemos para o usuário.

235
00:18:23,160 --> 00:18:25,030
Então, acabamos de atualizar o usuário.

236
00:18:25,030 --> 00:18:30,550
Então, vamos dizer user.save então isso

237
00:18:30,550 --> 00:18:37,190
retornará o erro ou o usuário.

238
00:18:37,190 --> 00:18:41,025
Então, se a modificação foi salva corretamente,

239
00:18:41,025 --> 00:18:43,765
então ele retornará o erro,

240
00:18:43,765 --> 00:18:49,380
caso contrário ele retornará o valor do usuário e este passaporte autenticar

241
00:18:49,380 --> 00:18:55,710
faremos isso dentro deste usuário aqui.

242
00:18:55,710 --> 00:19:00,505
Então, vamos dizer, user.save (err, usuário).

243
00:19:00,505 --> 00:19:04,740
E então também precisamos cruzar a verificação para ter certeza de que,

244
00:19:04,740 --> 00:19:10,660
se houver um erro ao salvar as alterações para o usuário,

245
00:19:10,660 --> 00:19:15,180
então vamos dizer res código de status 500,

246
00:19:15,180 --> 00:19:18,485
então deixe-me copiar isso de lá.

247
00:19:18,485 --> 00:19:23,275
Então, vamos dizer res código de status 500,

248
00:19:23,275 --> 00:19:30,220
res definir cabeçalho conteúdo tipo aplicativo json e res.jason aqui.

249
00:19:30,220 --> 00:19:35,995
Então, e voltaremos a este ponto.

250
00:19:35,995 --> 00:19:37,960
Se não houver nenhum erro,

251
00:19:37,960 --> 00:19:40,480
então, é claro, você autenticar o usuário chamando

252
00:19:40,480 --> 00:19:43,550
passaporte autenticar com o local para garantir que

253
00:19:43,550 --> 00:19:48,835
o registro do usuário foi bem sucedido e isso deve ser

254
00:19:48,835 --> 00:19:56,390
feito corretamente e quando caso você retornará esta mensagem de volta para o lado do cliente.

255
00:19:56,390 --> 00:20:03,215
Precisamos fechar este user.save aqui.

256
00:20:03,215 --> 00:20:07,520
Portanto, certifique-se de que você fechar este ponto de extremidade corretamente.

257
00:20:07,520 --> 00:20:11,005
Então, user.save está fechado aqui, e é isso.

258
00:20:11,005 --> 00:20:14,730
Estas são as alterações que precisamos fazer para o usuário.

259
00:20:14,730 --> 00:20:21,740
Assim, depois que o usuário é registrado com o nome de usuário fornecido e a senha fornecida,

260
00:20:21,740 --> 00:20:24,940
depois que o usuário é registrado com sucesso,

261
00:20:24,940 --> 00:20:28,235
então vamos definir o primeiro nome e sobrenome campo

262
00:20:28,235 --> 00:20:32,925
do documento do usuário usando esses dois aqui.

263
00:20:32,925 --> 00:20:35,900
Queremos ter certeza de que o usuário está

264
00:20:35,900 --> 00:20:39,160
registrado com sucesso antes de enviarmos o nome e sobrenome para isso.

265
00:20:39,160 --> 00:20:42,540
Então, é por isso que estamos realizando esta operação depois que o usuário

266
00:20:42,540 --> 00:20:46,360
é registrado com sucesso. É isso.

267
00:20:46,360 --> 00:20:53,785
Vamos salvar as alterações e ir e verificar o servidor.

268
00:20:53,785 --> 00:20:56,185
Depois de salvar as alterações,

269
00:20:56,185 --> 00:20:59,980
vamos agora para o terminal e,

270
00:20:59,980 --> 00:21:06,925
em seguida, antes de iniciar o servidor,

271
00:21:06,925 --> 00:21:16,690
deixe-me primeiro verificar meu MongoDB e excluir o usuário que temos registrado anteriormente.

272
00:21:16,690 --> 00:21:25,640
Então, vamos dizer usar confusão e, em seguida, vamos dizer db.usersfind.

273
00:21:25,650 --> 00:21:30,690
Então, sabemos que esse usuário em particular foi registrado anteriormente,

274
00:21:30,690 --> 00:21:32,580
mas quando registramos esse usuário,

275
00:21:32,580 --> 00:21:35,700
não registramos o nome e sobrenome para o usuário.

276
00:21:35,700 --> 00:21:39,155
Então, eu vou excluir este usuário e, em seguida, re- registrar o usuário.

277
00:21:39,155 --> 00:21:48,370
Então, para fazer isso usando a ondulação Mongo, eu vou dizer usuários do banco de dados soltar,

278
00:21:48,370 --> 00:21:52,220
e então vamos dizer usuários do banco de dados encontrar,

279
00:21:52,220 --> 00:21:54,620
e que deve retornar um vazio.

280
00:21:54,620 --> 00:22:01,685
Nenhum usuário registrado lá e então vamos sair da ondulação Mongo.

281
00:22:01,685 --> 00:22:05,285
E assim, uma vez que tenhamos removido esse usuário registrado,

282
00:22:05,285 --> 00:22:08,760
então, deixe-me iniciar meu servidor.

283
00:22:09,490 --> 00:22:12,275
E uma vez que o servidor está funcionando,

284
00:22:12,275 --> 00:22:16,240
vamos para o Postman e, em seguida, registrar

285
00:22:16,240 --> 00:22:20,930
um novo usuário junto com o nome e sobrenome do usuário.

286
00:22:20,930 --> 00:22:26,845
Em seguida, eles vão fazer login como esse usuário e, em seguida, vamos olhar para como

287
00:22:26,845 --> 00:22:31,650
a população Mangusto nos ajuda a preencher as informações sobre

288
00:22:31,650 --> 00:22:37,000
o usuário automaticamente no documento lá.

289
00:22:37,000 --> 00:22:40,029
Agora indo para o Postman,

290
00:22:40,029 --> 00:22:42,660
deixe-me fazer uma inscrição de um novo usuário.

291
00:22:42,660 --> 00:22:48,310
Então, eu estou fazendo um post localhost: 3000 usuários se inscrevem.

292
00:22:48,310 --> 00:22:50,715
No corpo da mensagem,

293
00:22:50,715 --> 00:22:54,910
tínhamos o nome de usuário e a senha já lá dentro.

294
00:22:54,910 --> 00:22:59,199
Deixe-me adicionar dois campos adicionais:

295
00:22:59,199 --> 00:23:09,350
primeiro nome, sobrenome.

296
00:23:14,880 --> 00:23:18,530
Em seguida, registre esse usuário.

297
00:23:20,850 --> 00:23:23,680
Então, uma vez que eu registrar o usuário,

298
00:23:23,680 --> 00:23:26,350
você pode ver que o registro foi bem sucedido.

299
00:23:26,350 --> 00:23:29,810
Agora, deixe-me fazer login como este usuário.

300
00:23:29,820 --> 00:23:32,640
Então, para fazer login como o usuário,

301
00:23:32,640 --> 00:23:37,620
deixe-me fazer uma postagem e cruzar verificação para ter certeza.

302
00:23:37,620 --> 00:23:40,475
Então, eu estou fazendo uma postagem para usuários login.

303
00:23:40,475 --> 00:23:45,725
Deixe-me cruzar a verificação e eu vejo que o nome de usuário e senha estão corretamente digitados lá.

304
00:23:45,725 --> 00:23:47,775
Então, quando eu entrar,

305
00:23:47,775 --> 00:23:53,165
eu deveria estar logado com sucesso e eu deveria ser capaz de obter esse token lá.

306
00:23:53,165 --> 00:24:02,660
Porque este token é essencial para que possamos adicionar em um prato ao nosso site de servidor.

307
00:24:02,660 --> 00:24:05,915
Então, depois de obter o token,

308
00:24:05,915 --> 00:24:10,250
copie este token string e salve-o porque você precisará que

309
00:24:10,250 --> 00:24:13,220
no cabeçalho de autorização para o post

310
00:24:13,220 --> 00:24:16,910
colocar e excluir operações que você vai executar mais tarde.

311
00:24:16,910 --> 00:24:20,540
Então deixe-me copiar essa ficha.

312
00:24:20,540 --> 00:24:23,890
Agora, normalmente a maneira que eu manteria esses tokens é,

313
00:24:23,890 --> 00:24:28,400
que eu vou apenas abrir um documento de texto e, em seguida, copiá-lo e colá-lo no documento de texto.

314
00:24:28,400 --> 00:24:31,190
Para que, para pedidos de carteiro subseqüentes,

315
00:24:31,190 --> 00:24:34,230
eu possa simplesmente copiar esta string e, em seguida, colá-la

316
00:24:34,230 --> 00:24:37,770
no cabeçalho de autorização, se necessário.

317
00:24:37,770 --> 00:24:44,070
Então, deixe-me copiar esse token e aqui eu tenho um documento de texto aberto aqui.

318
00:24:44,070 --> 00:24:50,815
Então, eu vou colar essa string neste documento de texto.

319
00:24:50,815 --> 00:24:57,170
Então, aqui temos o token que obtivemos.

320
00:24:57,170 --> 00:25:03,120
Vamos agora postar um prato para o nosso servidor.

321
00:25:03,120 --> 00:25:05,135
Voltando para o carteiro,

322
00:25:05,135 --> 00:25:07,535
deixe-me postar um prato no servidor.

323
00:25:07,535 --> 00:25:12,690
Então, este é o lugar onde eu vou escolher o post aqui.

324
00:25:12,690 --> 00:25:21,334
Dentro aqui, Eu tenho a informação prato que eu tinha usado anteriormente, mas para os comentários

325
00:25:21,334 --> 00:25:25,345
, agora, lembrar que antes tínhamos campo autor que estava armazenando uma string.

326
00:25:25,345 --> 00:25:28,770
Então, todos esses comentários não são válidos.

327
00:25:28,770 --> 00:25:35,110
Então, eu vou excluir todos esses comentários da submissão porque,

328
00:25:35,110 --> 00:25:42,570
agora, esperamos que o usuário poste comentários por conta própria.

329
00:25:42,570 --> 00:25:44,460
Quando o usuário postar comentários,

330
00:25:44,460 --> 00:25:52,155
adicionaremos automaticamente o ID do usuário no campo autor dos comentários.

331
00:25:52,155 --> 00:25:55,390
Então, deixe-me postar este prato aqui.

332
00:25:55,390 --> 00:25:57,325
Indo para o cabeçalho,

333
00:25:57,325 --> 00:26:01,550
no cabeçalho de autorização, eu vou dizer,

334
00:26:02,310 --> 00:26:12,785
portador e, em seguida, colar o token e, em seguida, enviar.

335
00:26:12,785 --> 00:26:17,055
Eu deveria fazer um post sobre isso.

336
00:26:17,055 --> 00:26:21,950
Então, eu vou dizer post e assim quando eu postar agora,

337
00:26:21,950 --> 00:26:26,785
você vê que este prato foi postado no lado do servidor,

338
00:26:26,785 --> 00:26:31,340
e com a matriz de comentários sendo vazio neste momento.

339
00:26:31,340 --> 00:26:34,450
Então, depois que eu postar este prato,

340
00:26:34,450 --> 00:26:37,660
deixe-me copiar o ID deste prato.

341
00:26:37,660 --> 00:26:40,835
Então, deixe-me copiar este ID para o prato porque eu vou

342
00:26:40,835 --> 00:26:44,735
precisar que para postar comentários para este prato.

343
00:26:44,735 --> 00:26:47,075
Então, indo para o meu editor de texto,

344
00:26:47,075 --> 00:26:51,485
eu vou salvar esse ID do prato aqui.

345
00:26:51,485 --> 00:26:54,550
Agora, é claro, uma vez que você construir o lado do

346
00:26:54,550 --> 00:26:57,770
seu cliente, seu cliente terá automaticamente todas essas informações.

347
00:26:57,770 --> 00:27:02,565
Então, seu cliente será capaz de enviar automaticamente o token e assim por diante.

348
00:27:02,565 --> 00:27:06,385
Então, você não precisa fazer essa coisa de cortar e colar, mas com o carteiro,

349
00:27:06,385 --> 00:27:11,750
esta é a única maneira de adicionar qualquer informação aos nossos pedidos de carteiro,

350
00:27:11,750 --> 00:27:17,185
que vão do carteiro para o servidor.

351
00:27:17,185 --> 00:27:22,090
Agora, a fim de nos convencer de que este prato realmente existe,

352
00:27:22,090 --> 00:27:26,310
deixe-me fazer um get no hostcolonial local:3000/pratos.

353
00:27:26,570 --> 00:27:30,750
Quando eu faço um get, você pode realmente ver que

354
00:27:30,750 --> 00:27:34,175
este prato particular existe no lado do servidor.

355
00:27:34,175 --> 00:27:37,600
Então, vamos agora tentar postar um comentário.

356
00:27:37,600 --> 00:27:39,515
Então, para postar um comentário,

357
00:27:39,515 --> 00:27:45,550
vamos fazer um post e vamos dizer,

358
00:27:49,940 --> 00:27:54,950
localhost: 3000/pratos, barra e o ID do prato que

359
00:27:54,950 --> 00:27:59,910
eu acabei de copiar, e barra comentários.

360
00:27:59,910 --> 00:28:03,090
Quando você postar nos comentários,

361
00:28:03,090 --> 00:28:11,285
você precisa ter certeza de que no corpo vamos adicionar no comentário aqui.

362
00:28:11,285 --> 00:28:13,605
Então, um comentário típico contém

363
00:28:13,605 --> 00:28:20,555
uma classificação de digamos

364
00:28:20,555 --> 00:28:26,140
cinco e, em seguida, comentário.

365
00:28:29,030 --> 00:28:33,535
Então, deixe-me digitar um comentário aleatório,

366
00:28:33,535 --> 00:28:34,915
só para demonstrar a vocês.

367
00:28:34,915 --> 00:28:41,085
Então, isso deve estar no corpo do post para os comentários e no cabeçalho,

368
00:28:41,085 --> 00:28:44,665
devemos adicionar o cabeçalho de autorização.

369
00:28:44,665 --> 00:28:50,525
Então, para o cabeçalho de autorização, vamos dizer, portador.

370
00:28:50,525 --> 00:28:54,875
Preciso colar o token aqui,

371
00:28:54,875 --> 00:28:59,065
colando o valor do token que salvei anteriormente.

372
00:28:59,065 --> 00:29:02,575
Vamos agora postar este comentário.

373
00:29:02,575 --> 00:29:05,265
Então, quando o comentário é postado,

374
00:29:05,265 --> 00:29:07,705
vamos olhar para o valor retornado aqui.

375
00:29:07,705 --> 00:29:09,510
Então, à medida que você navega para baixo,

376
00:29:09,510 --> 00:29:14,975
você pode ver que o prato ao qual o comentário foi adicionado, foi retornado.

377
00:29:14,975 --> 00:29:19,300
Observe que a informação prato está lá, mas note em particular,

378
00:29:19,300 --> 00:29:22,620
o que está contido no comentário que foi postado aqui.

379
00:29:22,620 --> 00:29:25,740
Então, como você pode ver, você já sabe que os

380
00:29:25,740 --> 00:29:29,050
campos atualizados e criados são adicionados automaticamente pelo mangusto.

381
00:29:29,050 --> 00:29:31,900
A classificação e o comentário que enviamos estão

382
00:29:31,900 --> 00:29:34,780
lá, mas observe como o campo de autor

383
00:29:34,780 --> 00:29:40,675
agora contém o ID correspondente ao usuário.

384
00:29:40,675 --> 00:29:47,190
Agora, como vimos no código como as informações do campo do autor são adicionadas, agora,

385
00:29:47,190 --> 00:29:49,965
se você fizer um get sobre os pratos,

386
00:29:49,965 --> 00:29:52,900
você vai notar que este campo de autor será

387
00:29:52,900 --> 00:29:56,890
automaticamente preenchido pelas informações dos usuários aqui.

388
00:29:56,890 --> 00:30:02,180
Então, vamos agora fazer um get no localhost: 3000/pratos.

389
00:30:02,300 --> 00:30:06,820
Então, quando agora fazemos um get sobre este ponto,

390
00:30:06,820 --> 00:30:12,215
agora você vai notar que nos pratos aqui,

391
00:30:12,215 --> 00:30:15,460
bem ali, a informação sobre o prato já está

392
00:30:15,460 --> 00:30:20,110
presente, mas note como o comentário é agora construído.

393
00:30:20,110 --> 00:30:23,500
O comentário agora contém,

394
00:30:23,500 --> 00:30:27,240
os campos de comentário de classificação como vimos anteriormente,

395
00:30:27,240 --> 00:30:28,780
o atualizado e criado em,

396
00:30:28,780 --> 00:30:32,910
mas observe o que aconteceu com o campo autor aqui.

397
00:30:32,910 --> 00:30:36,890
Então, quando você faz uma solicitação get porque fizemos um preenchimento no

398
00:30:36,890 --> 00:30:42,230
lado do servidor quando a operação get é invocada,

399
00:30:42,230 --> 00:30:45,750
o populate preencheu automaticamente

400
00:30:45,750 --> 00:30:51,390
as informações do autor na posição no campo autor aqui.

401
00:30:51,390 --> 00:30:54,215
Então, lá, você pode ver que a partir do autor,

402
00:30:54,215 --> 00:30:56,260
agora você pode procurar o sobrenome e

403
00:30:56,260 --> 00:30:58,970
as informações do primeiro nome automaticamente no campo do autor.

404
00:30:58,970 --> 00:31:01,645
Então, se você precisa construir um comentário,

405
00:31:01,645 --> 00:31:04,050
agora você tem a classificação,

406
00:31:04,050 --> 00:31:08,210
o comentário e também o nome e sobrenome

407
00:31:08,210 --> 00:31:12,485
do autor automaticamente incluídos neste documento.

408
00:31:12,485 --> 00:31:15,645
Além disso, o nome de usuário também está incluído neste documento.

409
00:31:15,645 --> 00:31:21,495
Então, é assim que você pode adicionar informações de outro documento e preencher

410
00:31:21,495 --> 00:31:27,905
um segundo documento com essas informações antes de responder de volta do site do servidor.

411
00:31:27,905 --> 00:31:32,315
Então, este é o uso da população de mangusto e como

412
00:31:32,315 --> 00:31:37,580
podemos preencher automaticamente informações em um documento de mangusto.

413
00:31:37,580 --> 00:31:41,280
Com isso, completamos este exercício.

414
00:31:41,280 --> 00:31:46,075
Neste exercício, vimos o uso da população de mangusto e também vimos

415
00:31:46,075 --> 00:31:51,785
como podemos preencher informações de um documento para outro documento.

416
00:31:51,785 --> 00:31:57,340
Em que, quando modificamos o servidor para fazer a população para as solicitações,

417
00:31:57,340 --> 00:32:02,200
mangusto irá automaticamente cuidar de preencher esta informação para nós.

418
00:32:02,200 --> 00:32:04,190
Tudo o que precisamos fazer,

419
00:32:04,190 --> 00:32:10,900
é armazenar a referência ao outro documento na forma do ID do objeto,

420
00:32:10,900 --> 00:32:16,240
no documento no qual você deseja preencher essas informações.

421
00:32:16,240 --> 00:32:18,965
Com isso, completamos este exercício.

422
00:32:18,965 --> 00:32:25,230
Este é um bom momento para você fazer um compromisso com a mensagem, população de mangusto.