Agora que aprendemos sobre a População de Mangusto,
e como ela nos permite preencher um documento com informações de outro documento.
Neste exercício, vamos modificar o servidor expresso que temos trabalhado até agora.
No esquema prato que definimos anteriormente, tivemos comentários.
Para os comentários, tivemos o campo de autor
que usamos para armazenar os detalhes sobre o autor.
Neste exercício, vamos transformar o campo autor em uma referência a um documento de usuário,
e vamos usar a população de Mangusto para preencher a informação
no documento de pratos como e quando necessário,
a fim de fornecer a informação ao cliente.
Agora, o uso de população e Mangusto população deve ser feito
judiciosamente de modo a não causar muita sobrecarga no lado do servidor.
Agora, neste exercício,
vamos usá-lo simplesmente para preencher as informações
no campo autor de nossos comentários.
Então, vamos prosseguir com o exercício para aprender como usamos a população de Mangusto.
Para começar este exercício,
vá para o projeto e abra o arquivo user.js.
Então, no arquivo user.js,
armazenamos o esquema do usuário.
Vou modificar o esquema do usuário adicionando mais alguns campos lá.
Um é o primeiro nome,
que será
do tipo string e
o padrão seria uma string vazia.
Então, o primeiro nome como o nome indica,
armazena o primeiro nome para o usuário e, em seguida, teremos outro campo chamado sobrenome,
que também é do mesmo tipo.
Então, eu vou apenas copiar esses dois pedaços de informação e, em seguida, copiá-lo
aqui e agora nosso documento de usuário irá conter,
além do nome de usuário e senha,
nome de usuário e silêncio e salt que vimos anteriormente,
que é automaticamente adicionado pelo módulo local do passaporte Mangusto .
Nós também teremos o primeiro nome e sobrenome para o usuário que está sendo definido aqui.
Mais tarde veremos como inicializaríamos
esses valores modificando o processo de registro do usuário.
Agora, uma vez que tenhamos concluído
isso, desta forma as informações do usuário
podem simplesmente ser recuperadas pesquisando o documento do usuário aqui.
Então, agora que temos as informações sobre o usuário no documento do usuário,
indo para o esquema prato,
então indo para o arquivo dishes.js.
No esquema prato anteriormente,
estávamos armazenando o autor do documento na forma de uma string aqui.
Agora vamos aproveitar o fato de que
temos o apoio da população de mangustos.
Então eu vou transformar o campo de comentário de uma string em
tipos de esquema mangusto ID de objeto.
Então, por aqui, desculpe, campo errado.
Eu queria transformar o campo autor em
tipos de esquema mangusto ID de objeto.
Então, o campo autor agora em vez de armazenar uma string,
terá uma referência ao documento do usuário.
Então, quando eu transformar o campo autor neste tipo,
então a segunda propriedade que eu defini aqui será uma referência,
que seria uma referência ao modelo do usuário.
Então, desta forma, vamos agora estar
conectando este campo de autor e este campo de autor
simplesmente armazenará uma referência ao ID do documento do usuário,
em vez de armazenar os detalhes sobre o autor na forma de um nome.
Agora, quando fazemos isso,
podemos usar mangusto para preencher
esta informação em nosso documento pratos sempre que necessário.
Então, com esta modificação para o esquema de pratos, no arquivo dishes.js,
vamos agora atualizar o roteador prato para usar a população de mangusto.
Então, indo para dishRouter.js.
No roteador prato, lembre-se que quando estávamos recebendo um prato aqui,
agora quando você começa o prato aqui,
dizemos pratos encontrar então.
Então, nesse ponto,
vamos dizer pratos encontrar e vamos dizer depois disso, povoar.
Então, estamos usando o apoio da população em mangusto
e vamos dizer preencher comentários autor.
Então, afirmando isso,
estamos dizendo que quando
o documento de pratos foi construído para enviar de volta a resposta para o usuário,
vamos preencher o campo de autor lá dentro a partir do documento de usuário lá dentro.
Então, esta chamada para o preenchimento irá garantir que
o outro campo será preenchido com as informações conforme necessário.
Da mesma forma, indo para o ID prato aqui,
mesmo no ID do prato, mesma coisa.
Vamos dizer preencher e comentários autor adicionado
nos pratos encontrar por id
no get do endpoint /dish ID.
Da mesma forma, nos comentários também quando
recuperamos o prato, vamos dizer preencher comentários autor aqui e a
mesma coisa também no roteador prato,
comentários ID prato, ID comentário também.
Quanto maior a preencher esta informação lá.
Agora, é claro, o que isso significa é que quando você está postando o prato,
mais cedo você está incluindo as informações do autor no corpo da mensagem.
Então, agora aqui quando tentamos empurrar o comentário para que,
então este post corresponde ao campo de comentários ID prato.
Então, é assim que estávamos postando um comentário para um prato específico.
Então, agora neste post,
já que não estamos armazenando mais as informações sobre o autor,
então o que precisamos fazer é quando empurrar o item para o campo de autor lá.
Então, aqui quando você está preenchendo a informação no prato,
nós vamos ter primeiro -
Lembre-se que o corpo contém o comentário já,
mas a propriedade do autor não estará lá no corpo da mensagem no livro,
mas dependendo de qual usuário está postando esta informação,
podemos preencha imediatamente o campo de autor.
Agora, como sabemos qual usuário está postando essa informação?
O fato de termos feito o usuário de verificação aqui para a postagem,
significa que um usuário específico está postando essas informações,
e fazendo o usuário de verificação,
nós já teríamos carregado no req.user no objeto de solicitação.
No objeto de solicitação,
podemos entrar e dizer usuário naufrágio
e, em seguida, sublinhar ID aqui.
Então, mais uma vez, permitam-me reiterar este ponto,
como é que estamos a obter as informações do autor aqui?
Agora, lembre-se que atualizamos o esquema de pratos,
para que o campo autor no comentário simplesmente armazene
o ID do objeto referente ao usuário que está postando este comentário.
Agora, como sabemos qual usuário está postando esse comentário?
Agora, novamente, para reiterar este ponto,
lembre-se que quando verificamos o usuário aqui chamando autenticar verificar usuário,
o passaporte autorizado JWT teria carregado
as informações do usuário no corpo da solicitação na forma de req.user.
Então, esse usuário conterá o ID
do usuário específico que está realmente postando este comentário.
Então, já verificamos a autenticidade do usuário,
e assim o ID do usuário pode simplesmente ser obtido dizendo req.user.
_ID, e o ID desse usuário,
eu atribuirei isso ao campo autor fora do comentário.
Agora, quando o comentário entrar,
o comentário no corpo da mensagem de solicitação
conterá apenas o campo de classificação e o campo de comentário.
Agora nós não queremos enviar explicitamente o campo autor do lado do cliente,
em vez disso, que deve ser inserido automaticamente
no lado do servidor com base na autenticidade
do usuário Esse é o ponto que eu estava
reiterando nesta modificação que eu fiz aqui.
Então, essas informações dos usuários são automaticamente obtidas do req.user que é
carregado no corpo da mensagem de solicitação pelo usuário autenticar verificar,
que usará a autenticação do Passport com a estratégia JWT lá.
Além disso, agora, quando recebemos o prato atualizado aqui,
precisamos preencher as informações do autor no prato.
Então, neste ponto,
quando recebemos o prato aqui,
vamos então procurar os pratos aqui.
Então, vamos dizer dishes.findById
e, em seguida, fornecer o ID do prato como o parâmetro aqui,
então vamos dizer encontrar por ID,
ID do prato, e, em seguida,
precisamos preencher o autor comentários aqui,
e então vamos dizer, em seguida, prato.
Lá dentro, nós vamos estar enviando esta informação prato de volta para o usuário aqui.
Então, deixe-me cortar isso e colar isso aqui.
Então, esta modificação é necessária porque agora eu preciso preencher
as informações do autor de volta para
o comentário antes que eu possa enviar o atual de volta para o usuário.
Então, esta é a modificação adicional que precisamos
fazer quando usamos a população de Mangusto aqui.
Da mesma forma, agora indo para o put,
quando modificamos um comentário específico com o ID de comentário,
então este é sob a ID prato comentários parte ID comentário.
Então, quando fazemos a colocar aqui,
então primeiro encontramos os pratos encontrar por id req params prato ID,
em seguida, no prato.
Então, a primeira coisa que verificamos é garantir que, se o prato não é nulo,
e o prato comentários ID não é nulo,
então verificamos para ter certeza de que o comentário está realmente presente no prato,
e então, quando o prato em si é devolvido,
então precisamos procurar novamente
o prato porque precisamos preencher o autor comentários no prato.
Então aqui, vamos dizer dishes.findByID (ID do prato),
a razão pela qual precisamos fazer mais uma pesquisa é porque
precisamos preencher os comments.author aqui,
então essa é a única razão pela qual precisamos fazer mais uma pesquisa aqui.
Então, quando recebemos o prato aqui,
obviamente, porque acabamos de atualizar o prato para que a informação do prato deve ser
encontrada no banco de dados, de
modo que deve funcionar bem e, em seguida, dentro vai dizer
código de status de risco 200 res definir cabeçalho conteúdo tipo aplicativo json,
e, em seguida, retornar o prato aqui,
e então vamos lidar com o erro aqui,
e depois os outros se os pratos
agora e também os outros erros que configuramos anteriormente,
eles serão tratados como de costume aqui.
Então, estas são as mudanças adicionais que precisamos ter certeza quando você atualizar o prato,
quando você está enviando de volta o comentário atualizado ou prato atualizado,
então vamos preencher o comentário no prato aqui.
Da mesma forma, indo para o delete aqui,
e depois do delete o comentário,
novamente vamos ser buscar o prato e preencher as informações do autor.
Então, deixe-me apenas copiar esta parte,
e então nós estaremos fazendo exatamente a mesma coisa aqui,
então vamos dizer prato salvar,
então nós vamos estar, em seguida, verificando dish.findById (autor do prato),
e então vamos preencher o autor comentários,
e então vamos dizer (então) prato,
e então res.StatusCode, e assim por diante,
e o tratamento de erros restantes como antes aqui.
Então, com esta modificação para o roteador prato,
agora o último ponto que precisamos considerar é o fato de que no arquivo user.js,
agora adicionamos em campos,
o primeiro nome e sobrenome campo que por padrão será strings vazias.
Assim, quando o usuário está se registrando,
devemos permitir que o usuário forneça o nome e
sobrenome no processo de registro.
Agora, onde isso acontece?
Isso ocorre no usuário.js.
Então, indo para usuários users.js,
quando o usuário postar na barra de inscrição,
anteriormente estávamos apenas postando o nome de usuário e senha.
Além desses dois,
no objeto json que incluímos no corpo da mensagem de solicitação chegando,
a mensagem de solicitação de post vindo do lado do cliente,
também podemos incluir o nome e sobrenome para o usuário.
Então, quando o nome e sobrenome do usuário estão incluídos,
então o que eu vou fazer aqui?
Então, lembre-se de que quando você diz user.register neste momento as informações do usuário entram,
e então você enviou o nome de usuário aqui,
e você também atribuiu a senha aqui que será
transformada em hash e sal pelo passaporte mangusto local.
Agora, se não houver nenhum erro, isso significa que o registro do usuário foi bem sucedido,
e então neste ponto o que vamos fazer é dizer se req.body.
Primeiro nome. Então, o que significa que o corpo da mensagem de solicitação de entrada,
se ele contém o primeiro nome,
então vamos dizer user.firstname é igual a req.body.firstname.
Da mesma forma, para o sobrenome também.
Então, neste ponto,
teríamos o usuário disponível aqui.
Veja o usuário está chegando como o segundo parâmetro para esta função de retorno de chamada aqui.
Então, estamos configurando o primeiro nome alterando
a propriedade primeiro nome dentro do documento do usuário aqui dizendo, req.body.firstname.
Se ele existir, então vamos definir o primeiro nome do usuário para isso.
Da mesma forma, se o nome req.body.last estiver disponível,
então também atualizaremos o sobrenome do usuário como req.body.lastname.
E uma vez que tenhamos feito essas duas alterações para o primeiro nome e o sobrenome,
então precisamos salvar a modificação que fizemos para o usuário.
Então, acabamos de atualizar o usuário.
Então, vamos dizer user.save então isso
retornará o erro ou o usuário.
Então, se a modificação foi salva corretamente,
então ele retornará o erro,
caso contrário ele retornará o valor do usuário e este passaporte autenticar
faremos isso dentro deste usuário aqui.
Então, vamos dizer, user.save (err, usuário).
E então também precisamos cruzar a verificação para ter certeza de que,
se houver um erro ao salvar as alterações para o usuário,
então vamos dizer res código de status 500,
então deixe-me copiar isso de lá.
Então, vamos dizer res código de status 500,
res definir cabeçalho conteúdo tipo aplicativo json e res.jason aqui.
Então, e voltaremos a este ponto.
Se não houver nenhum erro,
então, é claro, você autenticar o usuário chamando
passaporte autenticar com o local para garantir que
o registro do usuário foi bem sucedido e isso deve ser
feito corretamente e quando caso você retornará esta mensagem de volta para o lado do cliente.
Precisamos fechar este user.save aqui.
Portanto, certifique-se de que você fechar este ponto de extremidade corretamente.
Então, user.save está fechado aqui, e é isso.
Estas são as alterações que precisamos fazer para o usuário.
Assim, depois que o usuário é registrado com o nome de usuário fornecido e a senha fornecida,
depois que o usuário é registrado com sucesso,
então vamos definir o primeiro nome e sobrenome campo
do documento do usuário usando esses dois aqui.
Queremos ter certeza de que o usuário está
registrado com sucesso antes de enviarmos o nome e sobrenome para isso.
Então, é por isso que estamos realizando esta operação depois que o usuário
é registrado com sucesso. É isso.
Vamos salvar as alterações e ir e verificar o servidor.
Depois de salvar as alterações,
vamos agora para o terminal e,
em seguida, antes de iniciar o servidor,
deixe-me primeiro verificar meu MongoDB e excluir o usuário que temos registrado anteriormente.
Então, vamos dizer usar confusão e, em seguida, vamos dizer db.usersfind.
Então, sabemos que esse usuário em particular foi registrado anteriormente,
mas quando registramos esse usuário,
não registramos o nome e sobrenome para o usuário.
Então, eu vou excluir este usuário e, em seguida, re- registrar o usuário.
Então, para fazer isso usando a ondulação Mongo, eu vou dizer usuários do banco de dados soltar,
e então vamos dizer usuários do banco de dados encontrar,
e que deve retornar um vazio.
Nenhum usuário registrado lá e então vamos sair da ondulação Mongo.
E assim, uma vez que tenhamos removido esse usuário registrado,
então, deixe-me iniciar meu servidor.
E uma vez que o servidor está funcionando,
vamos para o Postman e, em seguida, registrar
um novo usuário junto com o nome e sobrenome do usuário.
Em seguida, eles vão fazer login como esse usuário e, em seguida, vamos olhar para como
a população Mangusto nos ajuda a preencher as informações sobre
o usuário automaticamente no documento lá.
Agora indo para o Postman,
deixe-me fazer uma inscrição de um novo usuário.
Então, eu estou fazendo um post localhost: 3000 usuários se inscrevem.
No corpo da mensagem,
tínhamos o nome de usuário e a senha já lá dentro.
Deixe-me adicionar dois campos adicionais:
primeiro nome, sobrenome.
Em seguida, registre esse usuário.
Então, uma vez que eu registrar o usuário,
você pode ver que o registro foi bem sucedido.
Agora, deixe-me fazer login como este usuário.
Então, para fazer login como o usuário,
deixe-me fazer uma postagem e cruzar verificação para ter certeza.
Então, eu estou fazendo uma postagem para usuários login.
Deixe-me cruzar a verificação e eu vejo que o nome de usuário e senha estão corretamente digitados lá.
Então, quando eu entrar,
eu deveria estar logado com sucesso e eu deveria ser capaz de obter esse token lá.
Porque este token é essencial para que possamos adicionar em um prato ao nosso site de servidor.
Então, depois de obter o token,
copie este token string e salve-o porque você precisará que
no cabeçalho de autorização para o post
colocar e excluir operações que você vai executar mais tarde.
Então deixe-me copiar essa ficha.
Agora, normalmente a maneira que eu manteria esses tokens é,
que eu vou apenas abrir um documento de texto e, em seguida, copiá-lo e colá-lo no documento de texto.
Para que, para pedidos de carteiro subseqüentes,
eu possa simplesmente copiar esta string e, em seguida, colá-la
no cabeçalho de autorização, se necessário.
Então, deixe-me copiar esse token e aqui eu tenho um documento de texto aberto aqui.
Então, eu vou colar essa string neste documento de texto.
Então, aqui temos o token que obtivemos.
Vamos agora postar um prato para o nosso servidor.
Voltando para o carteiro,
deixe-me postar um prato no servidor.
Então, este é o lugar onde eu vou escolher o post aqui.
Dentro aqui, Eu tenho a informação prato que eu tinha usado anteriormente, mas para os comentários
, agora, lembrar que antes tínhamos campo autor que estava armazenando uma string.
Então, todos esses comentários não são válidos.
Então, eu vou excluir todos esses comentários da submissão porque,
agora, esperamos que o usuário poste comentários por conta própria.
Quando o usuário postar comentários,
adicionaremos automaticamente o ID do usuário no campo autor dos comentários.
Então, deixe-me postar este prato aqui.
Indo para o cabeçalho,
no cabeçalho de autorização, eu vou dizer,
portador e, em seguida, colar o token e, em seguida, enviar.
Eu deveria fazer um post sobre isso.
Então, eu vou dizer post e assim quando eu postar agora,
você vê que este prato foi postado no lado do servidor,
e com a matriz de comentários sendo vazio neste momento.
Então, depois que eu postar este prato,
deixe-me copiar o ID deste prato.
Então, deixe-me copiar este ID para o prato porque eu vou
precisar que para postar comentários para este prato.
Então, indo para o meu editor de texto,
eu vou salvar esse ID do prato aqui.
Agora, é claro, uma vez que você construir o lado do
seu cliente, seu cliente terá automaticamente todas essas informações.
Então, seu cliente será capaz de enviar automaticamente o token e assim por diante.
Então, você não precisa fazer essa coisa de cortar e colar, mas com o carteiro,
esta é a única maneira de adicionar qualquer informação aos nossos pedidos de carteiro,
que vão do carteiro para o servidor.
Agora, a fim de nos convencer de que este prato realmente existe,
deixe-me fazer um get no hostcolonial local:3000/pratos.
Quando eu faço um get, você pode realmente ver que
este prato particular existe no lado do servidor.
Então, vamos agora tentar postar um comentário.
Então, para postar um comentário,
vamos fazer um post e vamos dizer,
localhost: 3000/pratos, barra e o ID do prato que
eu acabei de copiar, e barra comentários.
Quando você postar nos comentários,
você precisa ter certeza de que no corpo vamos adicionar no comentário aqui.
Então, um comentário típico contém
uma classificação de digamos
cinco e, em seguida, comentário.
Então, deixe-me digitar um comentário aleatório,
só para demonstrar a vocês.
Então, isso deve estar no corpo do post para os comentários e no cabeçalho,
devemos adicionar o cabeçalho de autorização.
Então, para o cabeçalho de autorização, vamos dizer, portador.
Preciso colar o token aqui,
colando o valor do token que salvei anteriormente.
Vamos agora postar este comentário.
Então, quando o comentário é postado,
vamos olhar para o valor retornado aqui.
Então, à medida que você navega para baixo,
você pode ver que o prato ao qual o comentário foi adicionado, foi retornado.
Observe que a informação prato está lá, mas note em particular,
o que está contido no comentário que foi postado aqui.
Então, como você pode ver, você já sabe que os
campos atualizados e criados são adicionados automaticamente pelo mangusto.
A classificação e o comentário que enviamos estão
lá, mas observe como o campo de autor
agora contém o ID correspondente ao usuário.
Agora, como vimos no código como as informações do campo do autor são adicionadas, agora,
se você fizer um get sobre os pratos,
você vai notar que este campo de autor será
automaticamente preenchido pelas informações dos usuários aqui.
Então, vamos agora fazer um get no localhost: 3000/pratos.
Então, quando agora fazemos um get sobre este ponto,
agora você vai notar que nos pratos aqui,
bem ali, a informação sobre o prato já está
presente, mas note como o comentário é agora construído.
O comentário agora contém,
os campos de comentário de classificação como vimos anteriormente,
o atualizado e criado em,
mas observe o que aconteceu com o campo autor aqui.
Então, quando você faz uma solicitação get porque fizemos um preenchimento no
lado do servidor quando a operação get é invocada,
o populate preencheu automaticamente
as informações do autor na posição no campo autor aqui.
Então, lá, você pode ver que a partir do autor,
agora você pode procurar o sobrenome e
as informações do primeiro nome automaticamente no campo do autor.
Então, se você precisa construir um comentário,
agora você tem a classificação,
o comentário e também o nome e sobrenome
do autor automaticamente incluídos neste documento.
Além disso, o nome de usuário também está incluído neste documento.
Então, é assim que você pode adicionar informações de outro documento e preencher
um segundo documento com essas informações antes de responder de volta do site do servidor.
Então, este é o uso da população de mangusto e como
podemos preencher automaticamente informações em um documento de mangusto.
Com isso, completamos este exercício.
Neste exercício, vimos o uso da população de mangusto e também vimos
como podemos preencher informações de um documento para outro documento.
Em que, quando modificamos o servidor para fazer a população para as solicitações,
mangusto irá automaticamente cuidar de preencher esta informação para nós.
Tudo o que precisamos fazer,
é armazenar a referência ao outro documento na forma do ID do objeto,
no documento no qual você deseja preencher essas informações.
Com isso, completamos este exercício.
Este é um bom momento para você fazer um compromisso com a mensagem, população de mangusto.