Nós já tínhamos desenvolvido um servidor API REST completo
usando Express e MongoDB como parte deste curso.
Para que esse servidor possa se comunicar de forma significativa com nosso cliente,
faremos alguns pequenos ajustes para que ele
retorne o tipo certo de dados para que a
implementação de nosso cliente possa trabalhar de
forma mais eficiente com os dados retornados do nosso site de servidor.
Então, para fazer isso,
vamos trabalhar em alguns ajustes para o nosso site de servidor neste exercício.
Antes de iniciar este exercício,
estou assumindo que você não fez
a lição anterior sobre a integração do cliente angular e
do servidor porque você está fazendo essa lição vindo através da especialização React.
Então, as alterações que eu vou fazer no servidor assumirão que
a versão do servidor que você está modificando é antes da lição anterior.
No caso de você ter feito essa lição sobre cliente angular,
algumas das alterações que você fez para o seu servidor serão repetidas novamente
neste exercício para que você possa ignorar essa parte das alterações.
Vá ao nosso servidor no editor.
Antes de começar a trabalhar no servidor,
eu sugiro que você baixe todas as imagens que eu
forneci como um arquivo zip nos recursos de exercício chamados images.zip.
Descompacte o arquivo e, em seguida, obtenha todas as imagens de lá e, em seguida, copie essas imagens
para a pasta de imagens públicas em nosso servidor.
Então, você vê que aqui eu copiei todas as imagens para minha pasta de imagens públicas aqui
já porque nosso servidor é aquele que vai
servir todas essas imagens para nossa aplicação cliente.
Em seguida, vamos para o CORS e ajustamos a lista branca aqui.
Então, para o nosso aplicativo cliente React,
se começamos com o comando yarn start,
ele será executado no nome do seu computador:3001.
Então, qualquer pedido vindo de nossa localização para
o servidor levará isso como a origem lá.
Então é por isso que vou adicionar isso à minha lista branca para que
quaisquer problemas de CORS sejam resolvidos automaticamente.
Então, indo para o arquivo cors.js na minha lista branca aqui,
deixe-me adicionar no
nome do computador http://my: 3001 e esta é
a origem da qual meu cliente
será originando as solicitações que vêm para este servidor.
Assim, meu CORS não causaria problemas ao meu cliente.
Em seguida, precisamos atualizar algumas das rotas para
lidar com os parâmetros de consulta e também alguns pequenos outros ajustes.
Deixe-me começar com o arquivo promoRouter.js.
Isso é simples de ser atualizado.
Então, indo para o arquivo promoRouter.js,
no arquivo PromOrouter para a solicitação get que recebemos
aqui em vez de fazer promoções encontrar com um objeto JavaScript vazio,
aqui eu forneceria o req.query como o parâmetro para as promoções encontrar aqui, a
mesma coisa com o roteador líder também.
Então, deixe-me ir para o arquivo leaderRouter.js.
No roteador líder também,
aqui onde você encontra Leaders.Find com o objeto JavaScript vazio, em vez disso,
substitua isso com o req.query para que os parâmetros de consulta sejam passados.
Então, este é o lugar onde vamos passar no featured:true como o parâmetro de consulta aqui.
Agora, tendo ajustado esses dois,
vamos agora trabalhar no roteador prato.
Então, vá para o arquivo dishRouter.js,
mesmo no roteador prato também a mesma atualização aqui.
Então, vá para este dishes.Find no método get aqui,
altere isso para req.query.
Então, com isso, minha atualização do roteador prato foi concluída.
Então, agora atualizamos o roteador promocional, o líder
e o roteador prato,
então vamos passar para atualizar o roteador favorito.
Agora, você teria implementado o roteador favorito como parte de sua quarta tarefa.
Agora, no roteador favorito,
você verá que para o roteador favorito,
eu não estou mostrando a parte restante porque
você deveria ter feito como parte de sua tarefa.
Primeiro, deixe-me chamar sua atenção para o método get para o favoriteRouter.Route:DISHID.
Agora eu vou usar este método get para apenas verificar para garantir que
o prato específico com o Id prato já é um favorito para o usuário.
Então, em vez de simplesmente dizer getoperation.supported,
eu só vou alavancar a presença desta operação get e, em seguida, vamos dizer,
favorites.findone e vamos dizer usuário: req.user. _id.
Então, vamos encontrar os favoritos para esse usuário particular e, em seguida, vamos dizer, em seguida,
favoritos e pegar erro próximo.
Então, da mesma forma aqui, vamos adicionar no erro aqui, próximo erro aqui.
Então, dentro disso, então,
quando obtivermos os favoritos,
então vamos verificar se não favoritos.
Então, se não houver favoritos para
este usuário, então, obviamente, o prato que estamos verificando não existe,
então vamos retornar Res.StatusCode 200,
SetHeader, Content-Type,
application/json e então vamos retornar dizendo existe false.
O que estamos especificando aqui é que se eles obtêm é feito até este ponto final com um prato Id,
esta bandeira existe aqui será definido como verdadeiro se este prato é parte dos meus favoritos.
Se este prato não faz parte dos meus favoritos,
Eu vou definir lá existe bandeira para falso.
Então aqui, você vê que desde que eu não tenho nenhum favorito então
existe deve ser automaticamente falso neste ponto.
Então, vamos dizer que existe falso e, em seguida, vamos retornar os favoritos aqui.
Bem, obviamente, neste caso, os favoritos seriam nulos neste momento.
Caso contrário, então o que significa que os favoritos não é nulo,
então vamos dizer se favorites.dishes.indexOf.
Então, vamos procurar por Req.Params.Dishid.
Então, nós estamos indo para procurar esta matriz pratos favoritos para
ver se este prato existe lá e se ele não existe,
obviamente isso irá retornar um índice negativo aqui.
Nesse caso também,
retornarei exatamente o mesmo que aqui.
Então, se ele retorna um índice negativo então isso significa que
mesmo que este usuário em particular tem um conjunto de favoritos,
este prato específico não existe
na lista de seus favoritos, então é por isso que ele vai retornar existe falso aqui.
Agora, caso contrário, isso significa que o prato existe na lista de favoritos.
Então, neste caso,
eu retornarei o código de status 200 existe é verdadeiro.
Assim, quando o usuário executa uma operação get neste ponto final com
o /Favorites/DISHID onde o Id prato é fornecido
como o parâmetro aqui, como o parâmetro request aqui,
então vamos verificar se esse prato existe nos favoritos.
Se nenhum dos favoritos existe para este usuário, em seguida, vamos retornar um existe false.
Da mesma forma, se os favoritos existe, mas
esse prato particular não existe nos favoritos, então retornaremos falso,
caso contrário, retornaremos verdadeiro.
Então esta bandeira existe pode ser usado pelo meu cliente para verificar se este prato é
parte da lista de pratos favoritos para este usuário ou não.
Além disso, enquanto estamos em favoritos,
sempre que fizermos qualquer alteração nos favoritos,
queremos poder preencher as informações do usuário e pratos,
os favoritos, antes de voltarmos.
Por exemplo, no post que fazemos,
quando salvamos os favoritos, então, neste momento,
gostaríamos de primeiro fazer favoritos.
FindById, então porque acabamos de fazer as alterações vamos dizer favorite_id
e vamos preencher tanto o usuário e também
preencher os pratos nos favoritos.
Então, quando os favoritos forem retornados,
retornaremos esses favoritos em vez disso.
Então, deixe-me fazer essa mudança aqui.
Então, vamos cortar isso daqui e depois dentro do então,
vamos devolver os favoritos.
Depois de salvarmos os favoritos,
então vamos procurá-lo,
para o FavoriteByID e, em seguida, retornar
esse favorito aqui, então vamos dizer então retorno favorito e código de status.
Esta mudança que devemos fazer.
Se você já implementou isso em seus favoritos,
então você não precisa fazer essa alteração.
Mas o que estamos fazendo é sempre que fazemos alterações nos favoritos,
nós vamos preencher as informações do usuário e pratos e, em seguida, retornar esse valor
porque nosso cliente React espera que isso esteja lá.
Agora, o mesmo tipo de mudança,
vamos precisar fazer variável b, salvar as alterações.
Então, no post aqui,
vamos fazer uma alteração para isso,
então vamos dizer favorites.save e então vamos fazer favorites.findByID e fazer essa mudança.
Da mesma forma, sob o id
do prato, também no post,
você será da mesma forma, sempre que você fizer alterações nos favoritos,
primeiro procurará e depois preencherá o usuário e os pratos e depois devolvê-lo
e, em seguida, da mesma forma na outra parte.
Então, você deve ter implementado isso em sua quarta missão.
Então, faça esta alteração adicional onde você irá preencher
o usuário e pratos antes de retornar o valor.
Também com a exclusão,
faremos as mesmas alterações aqui.
Então, você percebe que na exclusão,
eu já fiz essa alteração aqui.
Então, depois de salvarmos as alterações nos favoritos,
procuraremos os favoritos e
retornaremos depois de preencher o usuário e os pratos e os favoritos.
Isto é o que o nosso cliente React espera que façamos.
Então, mesmo para a exclusão,
faremos as mesmas mudanças.
Agora, com isso, meu roteador favorito é atualizado
, então vamos avançar para atualizar users.js em seguida.
Finalmente, vamos atualizar o arquivo users.js.
Agora, no arquivo users.js, precisamos adicionar em
outro campo roteador.options aqui,
porque às vezes um pedido de postagem como você viu
com o login enviará as opções primeiro para verificar,
especialmente com carros, se a solicitação de postagem será permitida.
Então é por isso que vamos verificar o curso com opções aqui e, em seguida,
vamos simplesmente retornar
uma mensagem
de status de 200 em resposta a isso.
Para qualquer endpoint em usuários, se recebermos as opções,
simplesmente retornaremos um status 200 aqui.
Agora a função de login que tínhamos implementado anteriormente,
tínhamos simplesmente feito passport.authenticate
local aqui e o verificamos os valores restantes aqui.
Agora, este passport.authenticate local,
se o usuário não for autenticado,
ele simplesmente retorna um não autorizado na mensagem de resposta.
Agora isso pode não ser muito significativo para o lado do cliente exibir essas informações,
então é por isso que vamos aprimorar
esse método de pós-login do roteador para que a autenticação retorne informações mais significativas neste momento.
Então, para fazer isso,
não vamos estar fazendo o passaporte.autenticar aqui, em
vez disso vamos pegar.
Então, deixe-me remover isso de lá e então você verá
como eu vou atualizar o post do roteador aqui.
Então, vamos ver o curso com opções e, em seguida, vamos incluir o req,
res e em seguida aqui.
Dentro deste req, res e próximo aqui,
passport.authenticate chamará isso com local.
Agora, quando chamamos isso com local,
se ocorrer um erro de autenticação,
o passport.authenticate pode ser feito para retornar
o valor do erro e também ele irá retornar o usuário se
não houver erro e um terceiro parâmetro chamado info
que irá levar informações adicionais que podem ser analisadas de volta para o usuário.
Esse erro será retornado quando houver
um erro genuíno que ocorre no passport.authenticate.
Mas se as informações do usuário
são enviadas para o passport.authenticate, mas o usuário não existe,
então isso não é contado como um erro.
Em vez disso, ele será contado como o usuário não existe e
essa informação é analisada de volta no objeto info que entra.
Assim, o erro será retornado quando houver
um erro genuíno que ocorre durante o processo de autenticação,
mas as informações conterão informações se o usuário não existir.
Então, o passport.authenticate está passando de volta uma mensagem dizendo que
o usuário não existe ou que o nome de usuário
está incorreto ou a senha está incorreta e assim por diante.
Então, essa informação será passada na mensagem info.
Agora vamos ver como isso é útil para
nós quando olhamos para o lado do cliente um pouco mais tarde.
Então, nesta situação,
vamos lidar com isso da seguinte forma,
e não só que quando chamamos este passaporte.autenticar,
também precisamos passar em um req,
res, próximo como os três parâmetros para ele.
Então, esta é a estrutura quando você precisa chamar passport.authenticate e esperar que ele
passe de volta informações como esta como um método de retorno de chamada aqui,
então você também precisa fornecer este req, res, em
seguida também.
Agora, se isso ocorrer,
então vamos dizer se errar,
então, se houver um erro que ocorre,
vamos dizer retorno próximo
erro e, em seguida, deixar o manipulador de erros do nosso roteador expresso e cuidar disso.
Agora, vamos considerar outras situações, se não usuário.
Então, se chegamos a este ponto,
então isso significa que não foi um erro que ocorreu,
mas talvez o usuário não tenha sido encontrado.
Se o usuário não for encontrado,
então o usuário aqui será definido como null neste caso.
Então, nessa situação,
se o usuário não existir,
então precisamos ser capazes de passar informações de volta para o lado do servidor.
Então, o que vamos fazer é passar nesta informação neste formato.
Então, eu vou cortar isso daqui e
depois colá-lo aqui e então vamos editar isso.
Então, se o usuário é nulo,
então vamos enviar de volta um código de status como 401, o que significa
não autorizado e, em seguida, vamos enviar de volta informações sucesso falso,
e então não estaremos passando de volta o token,
vamos passar de volta a mensagem de status.
Então, aqui vamos dizer
'Login Inbem-sucedido' e, em seguida, a terceira informação,
vamos passar esta informação que o objeto que recebemos aqui como
a terceira parte na mensagem de resposta que enviamos de volta do nosso servidor aqui.
Assim, o sinalizador de sucesso será definido como false,
o status será definido Login Inbem-sucedido e
as informações de erro que são transmitidas nas informações serão passadas de volta.
Agora, observe que essa situação
ocorrerá se o nome de usuário e a senha estiverem incorretos
e, portanto, isso não é um erro no sentido do erro, mas
o fato de que a autenticação não conseguiu localizar o usuário ou a senha do usuário está incorreto.
Então, essa informação será codificada na informação que vem e assim eu vou
passar de volta como um erro para o lado do meu cliente.
A parte de outra forma
é tratada como Req.Login.
Então, se isso for bem sucedido,
o passport.authenticate vamos adicionar este método chamado req.Login para o usuário.
Então, neste ponto,
vamos simplesmente passar no objeto de usuário que obtivemos.
Então, aqui, se chegamos a este ponto,
então isso significa que o objeto de usuário não é nulo e também nenhum erro ocorreu,
então isso significa que o usuário pode ser conectado.
Então, vamos dizer err,
vamos tentar fazer login no usuário.
Então, vamos dizer se errar e
então vamos passar de volta o mesmo tipo de informação de erro que fizemos aqui.
Então, neste caso, se erro,
então vamos passar de volta um código de status como 401 e vamos dizer sucesso
é falso e status como Login mal sucedido,
e, em seguida, as informações de erro,
em vez da informação,
vamos passar em 'Não foi possível fazer login usuário”.
Então, essa é a mensagem que vamos passar aqui se o erro ocorrer.
Caso contrário, estaríamos aqui embaixo.
Então, neste ponto,
seríamos capazes de gerar o token.
Então, se chegamos até este ponto, isso
significa que o usuário logou com sucesso,
e assim podemos agora gerar o token.
Então, vamos gerar o token com base no ID do usuário
e, em seguida, vamos passar de volta o token de volta para o usuário.
Então, aqui, vamos dizer var token,
e então podemos dizer Res.StatusCode é 200 e, em seguida, res.json sucesso verdadeiro,
então, o que significa que o usuário logado com sucesso.
Então, o status seria login bem-sucedido.
Então, a terceira parte,
em vez do erro,
passarei o token de volta ao usuário.
Então, vamos dizer token,
este token que acabamos de obter mais cedo.
Então, esse token será passado como a propriedade token da mensagem de resposta.
Então, aqui, observe que o sucesso é definido como verdadeiro, então,
o que significa que o usuário logado com sucesso,
e assim o usuário pode prosseguir neste ponto.
Isso tem que ser feito dentro do Req.Login aqui.
Então, neste ponto,
vamos fechar o Req.Login.
Então, observe que isso está dentro deste Req.Login aqui.
Então, lá dentro, vamos passar esses três de volta.
Então, deixe-me apenas recuar essas três linhas.
Então, é assim que trataríamos o método de log do usuário.
Então, novamente, revisando esse código mais uma vez.
Então, vamos fazer postagem de roteador,
mas em vez de fazer autenticação de passaporte ali mesmo,
vamos dizer req, res
, em seguida, dentro aqui,
vamos fazer uma autenticação de passaporte para o local,
e este autenticado vai passar de volta.
Então, podemos fornecer uma função de retorno de chamada para isso,
e esta função de retorno de chamada retornará o erro,
o usuário, ou as informações aqui.
Então, se for um erro,
vamos apenas permitir que o manipulador de erros expresso para cuidar disso.
Se o usuário for nulo,
isso significa que o login do usuário não teve êxito,
e a razão para isso estará nas informações.
Então, isso irá passar de volta como o erro de informação na mensagem de resposta aqui.
Se chegarmos a este ponto,
o usuário é verificado com sucesso.
Então, então vamos fazer login no usuário.
Então, o passaporte autenticar,
vamos adicionar neste método chamado login para o req, a mensagem de solicitação.
Então, podemos chamar o login com o usuário.
Se isso retornar um erro,
então retornaremos o erro aqui adequadamente.
Caso contrário, teremos chegado ao ponto em que o usuário é autenticado com sucesso.
Então, podemos gerar o JSON Web Token aqui e, em seguida, retornar
o JSON Web Token para o usuário para confirmar que o usuário está logado com êxito.
Então, esse é o conjunto de passos que vamos usar aqui.
Agora, a razão pela qual eu faço uma maneira mais elaborada de lidar com isso é que
eu quero distinguir entre a situação em que um erro genuíno
ocorre durante o processo de autenticação em vez da
situação em que o nome de usuário é inválido ou a senha é inválida.
Então, esses dois casos serão tratados por esta situação,
onde a informação vai levar a informação de volta para nós.
Então, isso não é um erro per se,
mas é uma situação em que o usuário
não é um usuário válido ou a senha do usuário não é válida.
Então, é assim que vamos lidar com o processo de login do usuário.
Além disso, vou adicionar em
mais um método aqui chamado CheckJWTToken.
É bem possível que, enquanto o cliente efetuou login e obtenha o JSON Web Token,
algum tempo mais tarde, o JSON Web Token pode expirar.
Portanto, se o usuário tentar acessar do lado do cliente com um token expirado para o servidor
, o servidor não será capaz de autenticar o usuário.
Então, em intervalos periódicos,
podemos querer cruzar a verificação para ter certeza de que o JSON Web Token ainda é válido.
Então, essa é a razão pela qual eu estou incluindo este,
outro endpoint chamado CheckJWTToken.
Então, se você fizer um get para o CheckJWTToken
incluindo o token no cabeçalho de autorização,
então esta chamada retornará um verdadeiro ou falso
para indicar a você se o JSON Web Token ainda é válido ou não.
Se não for válido, o lado do cliente poderá iniciar outro login para que
o usuário obtenha um novo Token da Web JSON, se necessário.
Então, para fazer isso,
vamos dizer cors.corsWithOptions e req,
res aqui como esperado.
Aqui, vamos dizer
passaporte autenticar jwt
e sessão: false,
e isso iria retornar err, usuário, informações.
Então, lembre-se de como usamos o passaporte autenticar mais cedo.
Então, chamamos o JWT com sessão falsa aqui.
Então, mais cedo aqui, dizemos passaporte autenticar local.
Então, isso é para a autenticação local.
Então, isso é para a autenticação JSON Web Token.
Então, quando chamamos isso,
em seguida, uma vez que vai verificar o JSON Web Token, então vamos dizer,
se err retorno próximo err,
e, em seguida, deixar o manipulador de erro expresso cuidar dessa situação.
Então, vamos dizer, se não usuário,
se o usuário não existe, então da mesma forma.
Então, o que significa que se o objeto de usuário foi
encontrado a partir do JSON Web Token e depois carregado no req.user,
isso significa que o usuário é um usuário válido
e, portanto, pode ser permitido continuar.
Caso contrário, vamos dizer que o usuário não existe.
Então, precisamos informar que o JSON Web Token expirou.
Então, neste ponto,
vamos enviar uma res com
um código de status de 401.
Então, não autorizado, SetHeader, Content-Type,
application/json e, em seguida, vamos retornar res.
Res.json vai dizer status JWT
inválido e, em seguida,
vamos retornar um sinalizador chamado sucesso cai e, em seguida,
vamos retornar as informações que obtemos se o usuário
não é autenticado como o erro neste ponto.
Caso contrário, isso significa que chegamos a este ponto,
então o usuário é um usuário válido.
Então, neste caso,
deixe-me apenas copiar esse código aqui,
estaremos enviando um código de status de 200 e, em seguida, o res.json,
enviará JWT válido e bem sucedido sendo verdadeiro.
A terceira parte, enviaremos as informações do usuário.
Dessa forma, quando esse endpoint é chamado com o método get,
então isso verificará se o token é válido ou não.
Se o token for válido,
então você receberá esta resposta e da bandeira de sucesso na resposta,
você pode verificar se o jsonwebtoken é válido ou não.
Isso é útil no lado do cliente.
Agora, este passaporte autenticado aqui terá que ser fornecido
com req e res como os dois parâmetros aqui.
Então, é assim que chamamos o passaporte de autenticar.
Então, observe que sempre que você chamar
passaporte autenticar e esperar esta função de retorno de chamada aqui,
você precisa anexar a este ponto req.res para o passaporte autenticar na parte de trás aqui.
Em nosso servidor API descanso,
nós tínhamos implementado nossos comentários de tal forma que os comentários
formaram sub-documentos dentro do documento do dishe,
então eles compram cada prato fechado seu próprio conjunto de comentários.
Mas a forma como implementamos o nosso cliente React é
tal que os comentários são mantidos independentes dos pratos,
e os próprios comentários carregaram o ID do prato correspondente.
Agora, essas são duas maneiras diferentes de
implementar o lado do servidor, bem como o lado do cliente.
Na aplicação Angular que estamos implementados em nossa especialização Angular,
usamos o método de subdocumento para
lidar com comentários em nosso aplicativo de cliente Angular.
Assim, o servidor API restante foi
implementado de tal forma que era mais adequado para o cliente Angular.
Mas para os clientes React desde que mantivemos os comentários independentes dos pratos,
e, em seguida, usar o ID prato dentro do comentário,
então precisamos reestruturar o nosso servidor API resto,
por isso é que temos um ponto final de comentário separado independente do endpoint pratos.
Então, precisamos reestruturar nosso código no servidor
para introduzir o endpoint da API REST /comments nesta fase.
Então, para fazer isso,
vamos em frente e implementar um novo modelo chamado como comment.js.
Então, indo para os modelos,
deixe-me implementar um novo arquivo chamado comments.js.
No arquivo comments.js,
vamos mover o CommentSchema do
arquivo dishes.js para o arquivo comments.js e, em seguida, removê-lo completamente do arquivo dishes.js.
Mas antes de fazer isso,
precisamos copiar o mangusto e o esquema a partir daqui,
então deixe-me apenas copiar isso de dishes.js para comment.js.
Depois disso, indo para dishes.js,
deixe-me cortar este CommentSchema completamente para fora daqui,
porque vamos ter isso separadamente no modelo de comentários aqui.
Então, vamos mover isso para o modelo de comentários e, em seguida, colá-lo aqui.
Mas é claro que este não é o completo,
vamos estar atualizando o CommentSchema um pouco.
Mas antes de fazer isso,
volte para o arquivo dishes.js e no arquivo de pratos,
removeremos os comentários do DisHessChema,
porque vamos armazenar o conteúdo separadamente dos
pratos nesta versão do nosso servidor.
Então, é assim que vamos atualizar o modelo de pratos aqui.
Então, removemos os comentários completamente do modelo de pratos aqui.
Indo para o modelo de comentários,
então agora vemos que temos o CommentSchema implementado aqui.
Mas, além disso, no CommentsSchema,
agora precisamos apontar explicitamente para
o prato específico para o qual este comentário é o comentário correspondente.
Agora, aqui é onde
nossa população de mangustos e
a forma como armazenamos os objetos IDs vem em nosso resgate.
Então, vamos atualizar o CommentSchema dizendo que teremos a classificação,
o comentário e o autor aqui.
Além do autor,
vamos introduzir mais um campo chamado como o prato aqui que é
do tipo: Mongoose.Schema types.ObjectID,
e assim isso vai se referir ao prato aqui.
Então, este seria um objeto de referência para o modelo de prato aqui,
e assim com esta modificação agora
nossos comentários irão conter o campo de classificação, o campo de comentário,
o autor que é novamente uma referência ao usuário correspondente,
e então o campo de prato que é uma referência ao correspondente prato aqui.
Então, o que significa que agora precisamos
preencher os comentários com o autor e o campo do prato.
Uma vez que tenhamos concluído isso,
então vamos dizer var Comentários
mongoose.model e vamos chamar isso de '
Comentário', e então isso usa o CommentSchema que acabamos de definir aqui,
e então precisamos exportar isso a partir daqui,
o comments.model a partir daqui.
Então, agora que introduzimos os comments.model,
então vamos em frente e, em seguida, introduzir um novo roteador chamado como CommentRouter.
Então, para introduzir o roteador de comentários,
vamos para as rotas aqui
e, em seguida, criar um novo arquivo chamado commentRouter.js.
No commentRouter.js, deixe-me copiar algumas coisas
do DishRouter.
Então, vamos ter esses comentários aqui,
então deixe-me copiar sobre essas coisas do e também,
enquanto eu estou nele deixe-me apenas copiar estes também até esse ponto,
e então eu vou atualizar isso um pouco mais tarde.
Então, indo para o CommentRouter,
precisamos de todas essas partes,
então vamos dizer Com, Express, BodyParser, mangusto
, autenticar, cors, e então
estaremos importando comentários de modelos/comentários.
Em seguida, vamos chamar isso como o CommentRouter que é um Express.Router aqui.
Então vamos dizer CommentRouter usar BodyParser,
e então isso agora se tornaria rota CommentRouter.
Agora, precisamos entrar no DisishRouter e, em seguida,
remover todas as partes que se referem aos comentários aqui.
Então, deixe-me apenas cortar esta parte e, em seguida, vamos reutilizar estes para o nosso CommentRouter.
Então, tudo isso não é mais necessário no DishRouter.
Então, eu vou remover tudo isso do DishRouter aqui,
então deixe-me cortá-los,
tudo relacionado à rota de comentários do DishRouter,
então vamos para o CommentRouter,
e então deixe-me ir em frente e colar isso no lugar aqui,
então vamos editar isso aqui.
Então, depois disso, precisamos exportar o CommentRouter.
Então, vai exportar o CommentRouter para nós.
Mas, claro, esse código não é completamente preciso.
Então, precisamos ir em frente e corrigir este código aqui.
Então, para este código,
agora percebemos que esta não é a rota DishRouter,
em vez disso, deve ser
o endpoint /porque
vamos montar isso no ponto de extremidade /comments aqui.
Então, vamos dizer CommentRouter
e, em seguida, as opções CorsWithOptions (req,
res) que permanece como tal lá,
e, em seguida, o get cors.cors e, em seguida, req.res,
e, em seguida, este se tornará comentários.
FindByID, req.
Então, isso seria comments.Find
e req.query aqui.
Então, quando os comentários são encontrados
, então, neste ponto,
vamos preencher o autor,
já tem lá, preencher aqui.
Então, eu vou apenas remover esses comentários.autor, e então,
vamos simplesmente preencher o autor aqui.
Então, isso nos daria comentários aqui.
Então, vamos dizer, isso pode ser simplificado significativamente.
Então, o erro de captura está lá de qualquer maneira.
Então, quando o comentário chegar, ele simplesmente retornará.
Desculpe, deveria ser.
Então, se para o get,
quando recebemos os comentários,
comments.Find req.query, .populate autor aqui,
e então, vamos dizer, .then comentários,
e então, vamos dizer, res.StatusCode 200,
SetHeader e, em seguida, retornaremos os comentários daqui,
res.json comentários daqui.
Agora, eu não estou preenchendo os pratos aqui porque eu não preciso explicitamente
dos pratos da maneira que eu uso esta informação no meu cliente reagir.
Eu só preciso do ID do prato,
e o ID do prato já está presente lá,
e isso é bom o suficiente para eu usar esses dados no meu cliente reagir.
Então, eu vou deixá-lo como tal lá.
Eu só vou preencher
as informações do autor lá porque precisamos da informação completa do autor
sempre que renderizamos um item de comentário em nosso cliente reagir.
Então, o get será atualizado assim aqui.
Para o post corsWithOptions,
diremos, Authenticate.VerifyUser req, res, próximo.
Obviamente, para que um comentário seja postado,
você precisa que o autor seja um usuário logado válido.
Só então, você permitirá que o usuário publique um comentário.
Em seguida, o comentário em si vem no corpo da mensagem de solicitação de entrada.
Então, primeiro, vamos verificar o corpo
para ter certeza de que o comentário está incluído no corpo aqui.
Então, aqui, eu vou remover todas essas partes, e então,
simplificá-lo ainda mais, e então,
vamos implementar isso corretamente lá.
Então, neste ponto, vamos dizer,
se req.body não
é igual a null, então o que significa que há um comentário que está fechado dentro do corpo.
Então, deixe-me cortar isso e mover isso para a parte if aqui,
e então, vamos editar isso aqui.
Então, se o corpo não existir,
então causaremos um erro.
Então, vamos dizer, err novo erro,
Comentário não encontrado no corpo da solicitação.
Então, vamos levantar esse erro aqui.
O status do erro é 404.
Então, vamos dizer, retornar o próximo erro.
Então, vamos lidar com a parte de erro aqui se o corpo
não contém as informações de comentários apropriadas.
Se contiver, então, é claro,
o que faremos a seguir é,
vamos dizer, req.body.author é req.user.
A razão pela qual estamos fazendo isso é que nós lembramos que se ele
é um usuário registrado e o usuário fez login,
então o req.user conterá as informações do usuário.
Então, eu só preciso do ID do usuário conectado no momento.
Então, vamos dizer, req.user. _id e, em seguida,
definiremos o req.body.author para req.user. _id.
Agora, o usuário de verificação irá garantir automaticamente que, se você aterrissar neste ponto,
então você obviamente teria um usuário que fez login corretamente.
Caso contrário, isso já teria causado o problema.
Então, quando você chegar a este ponto,
você teria um usuário válido que já fez login no sistema lá dentro.
Então, é aqui que você seria capaz agora.
Então, o que estamos fazendo é que o campo autor,
estamos explicitamente configurando-o na ID do usuário aqui para que
o req.body contenha as partes restantes do comentário.
Então, como você percebe, o comentário contém a classificação,
o comentário em si, e o autor, e os campos de prato.
Então, as partes restantes devem ter sido preenchidas pelo usuário.
A classificação, o comentário
e as informações do prato já devem ser preenchidas
no corpo da mensagem de solicitação recebida.
A parte do autor é deixada não preenchida lá,
que vamos inserir explicitamente neste ponto no corpo aqui.
Então, agora, o req.body conterá toda a informação do comentário.
Então, neste ponto,
em vez de fazer isso, vamos dizer, comentários.Criar.
Usando o req.body, vamos criar os comentários aqui.
Então, isso retornará
o comentário correspondente ao comentário que acabamos de inserir aqui.
Agora, uma vez que o comentário retornou,
então devemos fazer comments.findByID.
Agora, a razão pela qual precisamos fazer isso é porque precisamos
preencher as informações do autor aqui.
Então, vamos dizer, comentários FindByID. _id
e, em seguida, preencheremos as informações do autor no próprio comentário.
Então, vamos dizer, depois comentar.
Agora, obviamente, aqui, você descobriria que o comentário
existirá porque nós acabamos de inserir esse comentário no lugar lá.
Então, aqui, vamos simplesmente retornar, Res.StatusCode é 200,
Res.SetHeader é Content-Type, application/json.
O comentário em si dirá, res.json, e então,
retornará o comentário neste ponto.
Então, esta é a maneira que vamos lidar com a inserção de
um novo comentário no lado do nosso cliente aqui.
Para o put, como você percebe,
você não será capaz de fazer um put sobre os pontos finais /comments/.
Então, vamos dizer, operação PUT não suportada em /comments/ ponto final.
Esse é o ponto. Essa é a mensagem que você retornará.
Então, StatusCode é 403
e, em seguida, operação PUT não suportada em /comments/.
Agora, quando fazemos uma exclusão,
deixe-me apenas cortar isso a partir daqui, e então, vamos dizer,
comentários.Remover.
escrito vazio. Então, quando você faz uma exclusão no ponto final de comentários barra,
você removerá todos os comentários do seu sistema.
Então, esta é uma operação muito perigosa, e assim,
você não deve estar fazendo isso normalmente.
Então, só permitiremos que o administrador execute tal operação.
Então, removeremos todos os comentários de lá.
Então, quando você receber a resposta,
então vamos dizer Res.StatusCode 200.
Então, deixe-me copiar estas partes aqui,
e depois vir e colá-las aqui.
Então, vamos dizer, comentários.remover.
Em seguida, resposta Res.StatusCode 200 aplicação json e, em seguida, res.json (resposta) aqui.
Então, é assim que lidamos com a exclusão.
Excluir operação no ponto de extremidade de comentários de barra.
Agora, a próxima rota é o roteador de comentários.
Então, aqui vamos dizer commentRouter.route e
o ponto final aqui seria a barra commentId.
Então, aqui as opções permanecerão como tal.
Em seguida, para entrar no roteador atual,
para o get vamos dizer, comments.findById (req.params.
Este seria CommentID.
Então, uma vez que encontramos o comentário específico,
então vamos preencher apenas o autor de lá.
Então, uma vez que você preencher o autor,
então vamos dizer, em seguida, comentar.
Agora, toda essa parte é desnecessária aqui,
então eu vou deletar a parte.
Esta também não é a coisa apropriada aqui.
Então, deixe-me renomear código.
Então, vamos dizer para o get comments.findById,
em seguida, preencher o autor,
em seguida, comentar, res.statusCode é 200, setHeader.
Então o resto é JSON.
Vamos simplesmente retornar os comentários aqui.
Então, nós estaremos retornando o comentário neste ponto, res.json (comentário).
Você encontrará o comentário específico
e, em seguida, retornará esse comentário para a postagem.
Para a pós-operação, como você percebe,
a pós-operação não é
permitida nos comentários ComentID.
Então, essa é a mensagem que vamos enviar,
operação POST não suportada em comentários barra ComentID.
Então, essa é a mensagem que diremos para o posto.
Agora, para o put, vamos dizer comments.Find where Id (req.params.commentId).
Então, vamos encontrar o comentário lá,
e há comentário, então para o colocar.
Então, vamos encontrar o comentário lá,
e então vamos dizer para os comentários.
Então, se encontrarmos o comentário,
se o comentário não for nulo,
então também vamos verificar se comment.author.
Caso contrário, comment.arthur é igual a (req.user. _id).
Então, estamos verificando para garantir que
o comments.author é o mesmo que o usuário atual.
Somente o usuário atual que está conectado - se o usuário for o mesmo que o autor dos comentários
, o usuário terá permissão para atualizar.
Então, essa é a primeira coisa que vamos verificar.
Então, comentários e comentários.author.equal para rec.user. _id.
Se não, então você dirá que não está autorizado a atualizar este comentário.
Como você vê o.403
e, em seguida, retornar o próximo erro aqui.
Então, vamos criar o erro lá.
Então, depois disso, então diremos
req.body.author, req.user. _id.
Isso é importante.
Agora, esses dois não são necessários aqui,
porque estamos salvando diretamente o comentário.
Em seguida, pílulas, vamos dizer comentários.findByidAndUpdate,
e req.params.commentid.
Então, vamos encontrar esse comentário específico,
porque já foi fornecido o ID do comentário.
Então, vamos fazer comentários findById req.params.commentId.
Então vamos dizer então (comentário).
Quando você fornecer o req.params.commentId,
teremos que fornecer explicitamente o segundo parâmetro,
que é o que queremos alterar.
Então, vamos dizer $set: req.body.
Então, o segundo parâmetro, essencialmente,
informa qual parte você está mudando.
Agora, uma vez que nos foi fornecido o corpo contendo o comentário atualizado,
nós vamos apenas atualizar o comentário inteiro em si.
Então a outra parte que pediremos é nova: verdadeira.
Então, isso garantirá que o comentário atualizado será retornado
no den desta chamada para o comments.findByidAndUpdate.
Então, vamos dizer então comentários.
Quando esse comentário é retornado,
então vamos dizer comments.findById (comment. _id).
Em seguida, preencha o autor lá.
Vamos preencher o autor lá,
e então vamos dizer então comentar.
Então, você vê que vamos obter o comentário e, em seguida, retornar o comentário neste ponto.
Então, é assim que vamos atualizar o comentário.
Então, esta é a situação em que o comentário não é nulo.
Então, esta declaração se para o comentário não é nula.
Então, o outro se parte,
agora isso não é aplicável,
então vamos dizer mais, erro.
O erro neste caso.
Então, se o comentário é nulo,
isso significa que não encontramos o comentário lá,
então você não pode modificar um comentário inexistente.
Então, vamos dizer err,
novo comentário de erro req.params.commentId não encontrado e, em seguida, vamos retornar o erro.
Então, é assim que vamos lidar com a parte put do nosso comentário aqui,
e, finalmente, a exclusão.
Para excluir, novamente teremos que primeiro encontrar
comments.findById (req.params.commentId)
e depois comentar.
Então, vamos procurar o comentário.
Então, vamos primeiro verificar se o comentário não é igual a null.
É importante verificar aqui.
Em seguida, a próxima parte que vamos verificar é se o comment.author é igual a req.user. _id.
Nós certificamo-nos de que este usuário que está tentando excluir
este comentário é exatamente o mesmo usuário que inseriu o comentário em primeiro lugar.
Caso contrário, então, se esta for a situação,
então você verá 'Você não está autorizado a excluir este comentário! '
E, em seguida, retornar o status lá.
Em seguida, abaixo aqui,
vamos dizer comments.findByIdandRemove aqui.
Então, vamos dizer comments.findByIdandRemove (req.params.commentId),
então vamos obter alguma resposta do comentário.
Então, neste ponto,
vamos simplesmente dizer, Res.StatusCode.
Então, vamos dizer comments.findByIdandRemove, em seguida, resposta.
Se ele for removido corretamente,
diremos 200 e, em seguida, res.json
resposta aqui e também vamos pegar o erro neste ponto.
Então, deixe-me copiar isso aqui e então incluiremos a captura do erro neste momento.
Então, essa é a primeira coisa que vamos verificar.
Vamos garantir que o comentário não é igual a null.
Caso contrário, então esta é a outra parte.
Então, esta é a parte mais do if else erro
novo comentário req.params.commentId não encontrado e, em seguida,
404 e enviar a parte else para nós e, em seguida, a parte então irá lidar adequadamente.
Então, essas são as alterações que fazemos para o roteador de comentários aqui.
Então, estamos lidando com o get put post e excluir para
os comentários de barra e pontos comentários barra barra impacto ComentID.
Então, uma vez que
tenhamos concluído isso, então precisamos incluir isso no arquivo app.js.
Então, vamos para o arquivo app.js e, em seguida, vamos dizer
var CommentRouter
exigem roteiras/CommentRouter.
Então, temos o roteador comentário aqui e, em seguida, vamos
descer para o arquivo app.js abaixo aqui e
, em seguida, vamos dizer app.use
barra comentários, CommentRouter aqui.
É isso. Então agora,
meu roteador de comentários está pronto.
Então, vamos em frente e salvar todas as alterações.
Em seguida, o nosso servidor é agora atualizado
a fim de lidar com todos os pedidos de nossos clientes React aqui.
Agora, se você quiser fazer a maneira alternativa, isto é,
você tem seus comentários como sub-documentos do seu prato e, em seguida, você quer lidar com isso,
então você vai precisar atualizar o cliente React
para poder usar os comentários de dentro de cada prato adequadamente.
Isso será deixado como um exercício para você.
Pense em como você iria projetar seu cliente reagir de tal forma que ele
funciona muito bem com a versão anterior
do servidor que tinha os comentários como sub-documentos de seus próprios pratos.
Agora, isso vai ser uma maneira interessante de implementá-lo.
Claro, é um pouco mais complicado do que a forma como
implementamos o cliente React onde mantemos os comentários independentes
dos pratos, mas então o trabalho adicional é então da responsabilidade
do lado do cliente, porque você precisa selecionar
os comentários apropriados quando estiver mostrando um prato específico.
Você precisa selecionar os comentários de todos os comentários aqui.
Então, esse é um trabalho adicional que o nosso cliente React faz devido
ao fato de que separamos os comentários dos próprios pratos.
Da mesma forma, se você pode redesenhar seu cliente angular para ser capaz de
lidar com a situação em que os comentários são mantidos independentemente de seus pratos.
Agora, então estes são todos os exercícios que você pode fazer para ver como você pode
estender seus aplicativos cliente para lidar com qualquer tipo de servidor,
os dois tipos diferentes de servidores lá.
Então, com isso, concluímos a atualização para o nosso servidor aqui.
Então, com isso, atualizamos tudo no lado do servidor.
Então, vamos salvar todas as alterações no lado do servidor.
Então, agora, nosso servidor está pronto para lidar com as solicitações recebidas do nosso cliente React.
Com isso, completamos este exercício.
Neste exercício, preparamos nosso servidor expresso
para lidar com solicitações recebidas de nosso cliente React.
No próximo exercício, vamos olhar para reagir cliente com mais detalhes para
entender como ele está se comunicando com este servidor extra.
Este é um bom momento para você fazer
uma cobertura git com a mensagem integrando cliente e servidor.