Como entendemos a partir da palestra anterior nesta lição,
nosso objetivo nesta lição é
integrar o servidor REST API que já desenvolvemos,
juntamente com o acesso ao banco de dados MongoDB.
Então, vamos começar com o servidor REST API
que construímos na primeira lição neste módulo,
e depois aprendendo a interagir do
nosso aplicativo de nó para o servidor MongoDB usando o Mongoose,
vamos desenvolver nosso servidor REST API ainda mais para integrar
todo o caminho entre a solicitação do cliente entrando no servidor,
todo o caminho para a operação de banco de dados correspondente a ser executada,
e, em seguida, construir e enviar de volta a resposta para esse cliente a partir do nosso site de servidor.
Para começar, é claro, primeiro,
vá para a pasta do servidor de confusão que já criamos
no primeiro exercício deste módulo na lição REST API
e, em seguida, na pasta de confusão,
já construímos o servidor de API REST.
Agora, o que estaríamos fazendo é pegar emprestado
os modelos que desenvolvemos no exercício anterior,
o arquivo dishes.js que desenvolvemos no exercício anterior,
copiado para o projeto do servidor de confusão,
e também instalar Bluebird Mongoose,
e outro módulo chamado como Mangusto moeda, para o nosso projeto.
Então, indo para a nossa pasta JS nó,
vamos primeiro para a pasta nó Mangoose,
e vemos que na subpasta modelos da pasta nó Mongoose,
temos o arquivo dishes.js.
Eu só vou copiar a pasta modelos,
e então passar para a pasta do servidor de confusão,
e então simplesmente perfurar a pasta modelos lá dentro.
Então, uma vez que fazemos isso,
então o arquivo dishes.js que contém o esquema e o modelo para o documento de pratos,
são integrados em nosso servidor REST API.
É claro que, para fazer uso disso,
precisamos instalar o módulo do nó Mangusto,
e um novo módulo de nó chamado como moeda Mangusto em nosso projeto.
Então, indo para o terminal no projeto de servidor de confusão,
certifique-se de que seu terminal ou a janela de comando está
no projeto de servidor de confusão onde você desenvolver a API REST anteriormente,
e neste projeto, vamos instalar.
Então, vamos fazer npm instalar Mangusto,
e então, um novo módulo de nó chamado como moeda Mangusto.
O módulo de nó de moeda Mangusto,
e visto em outro tipo de esquema para a nossa aplicação Mangusto, de
modo que o próprio Mangusto,
certamente já built-in tipos de esquema.
Vimos o uso do número, a
string e o booleano, e a matriz.
Agora, a moeda Mangusto acrescenta suporte para moeda.
Por que precisaríamos desse apoio monetário?
Assim que o módulo de moeda Mangusto adiciona um novo tipo chamado como o tipo de moeda, o
que nos permite armazenar um valor de moeda.
Uma vez que o nosso prato vai conter um preço,
é por isso que eu vou estar usando o módulo moeda Mangusto aqui.
Agora, o exercício aqui,
vamos ilustrar o uso do módulo moeda Mangusto,
você pode ler mais detalhes sobre o módulo nó moeda Mangusto também,
na documentação de que um link para o qual é fornecido nos recursos adicionais.
Então, agora que instalamos esses módulos de nó,
moeda Mangusto e Mangusto,
vamos para o nosso aplicativo e configurá-lo para se comunicar com o servidor MongoDB.
Agora, certifique-se de que o seu servidor MongoDB está ativo e em execução.
Então, aqui, você vê que
meu servidor MongoDB está sendo executado em outra guia de terminal no meu computador.
Se você estiver executando em um computador Windows,
verifique se ele está sendo executado em outra janela de comando do computador Windows.
Indo para o nosso aplicativo no editor,
primeiro começaremos com o arquivo app.js.
Agora, no arquivo app.js,
é aqui que construímos nossa aplicação expressa anteriormente.
Mas agora, essa negação extra não está conectada ao servidor MongoDB back-end.
Vamos fazer uso do módulo Mangusto,
para estabelecer a conexão com o servidor.
Então, entrando aqui,
eu vou adicionar no requer o módulo Mangusto aqui.
Então, diremos, “Const Mangusto requer Mangusto.”
E então também, uma vez que copiamos sobre a pasta models,
que contém o arquivo de pratos,
que declara o esquema de pratos e o modelo.
Então, deixe-me importar os pratos.
Então, vamos dizer, “requisito.Slash modelos pratos.”
Então, uma vez que tenhamos concluído isso, agora é claro,
precisamos estabelecer a conexão com o servidor.
Então, configurar
URL mongodb// localhost7017/confusão,
assim como fizemos com o exercício Mangusto,
e então vamos dizer,
“Const connect, Mongo connect URL”.
Então, este é exatamente o mesmo código que usamos no exercício anterior.
Então, vamos estabelecer a conexão.
Então, vamos dizer, “conectar” e, em seguida, vamos dizer,
“DB fazer it console log”.
Dizendo: “Conectado corretamente ao servidor.”
E nós também vamos lidar com o erro aqui.
Vamos simplesmente fazer um registro do console do erro aqui, é isso.
Isso estabelecerá a conexão com o servidor do nosso arquivo app.js.
Então, uma vez que estabelecemos a conexão com o servidor,
então, vamos abrir o arquivo dishes.js de nossos modelos.
Agora, no arquivo dishes.js,
para fazer uso
do módulo nó que acabamos de instalar.
Então, vamos dizer, “Exigir moeda Mangusto”, e dizer,
“Carregue o tipo e Mangusto.”
Então, o que isso vai fazer é carregar este novo tipo de moeda em Mangusto.
Depois disso, podemos dizer const,
moeda tipos Mangusto moeda.
É isso. Então, este novo tipo,
o tipo de moeda é adicionado em Mangusto e que irá adicionar em um novo tipo chamado
moeda e então eu vou declarar
esta moeda constante como a moeda de tipos do Mangusto.
Para que eu possa fazer uso disso na definição do esquema na minha aplicação.
Agora, neste caso,
o esquema comum permanecerá exatamente o mesmo de antes, mas
o esquema prato como você lembra do arquivo db.json.
Quando você olha para a estrutura de um documento prato,
você vê que o documento prato contém nome e imagem que como você vê aqui é uma string,
uma categoria, um rótulo,
um preço, que é um tipo de string aqui.
Mas vamos declarar isso como um tipo de moeda,
um recurso que como você espera é uma variável booleana,
e uma descrição que é uma string e, em seguida, comentários
que não é nada mais que uma matriz de comentários tipo.
Agora, então o que vamos fazer agora é estender o esquema prato para
suportar todas essas várias propriedades ou vários campos no meu documento json.
Então já temos o nome.
Então, já temos a descrição no lugar.
Então precisamos adicionar nos próximos poucos já temos os comentários, a
matriz de comentários do tipo de esquema de comentário lá.
Então, vamos adicionar nos próximos.
Então, o próximo que vamos adicionar em é o tipo de imagem,
que seria
do tipo string e
vamos dizer true obrigatório.
Então isso adiciona o tipo de imagem.
O próximo que eu adicionarei é categoria,
que também é o tipo de string.
O próximo é label,
que também é este tipo de string.
Como todos estes são do mesmo tipo e necessários,
estou apenas copiando-os aqui.
Em seguida, para o rótulo,
eu diria que isso não é necessário, mas
em vez disso eu também posso especificar um valor padrão se eu quiser.
Então eu posso especificar um valor padrão como esse.
O valor padrão é uma string vazia.
Então, se eu não especificar obrigatório, eu posso simplesmente especificar um valor padrão aqui.
Agora, além disso, o próximo campo que vou introduzir é o campo de preço.
O campo de preço declararei o tipo como moeda.
Lembre-se que nós tínhamos declarado o tipo de moeda anteriormente
aqui, primeiro exigindo
o módulo de moeda Mangusto e, em seguida, declarando o tipo de moeda.
Então, é assim que você usaria o tipo de moeda em nosso aplicativo.
Então, vamos dizer tipo de preço moeda e
obrigatório é verdadeiro e, em seguida, eu também posso especificar o valor mínimo que seria zero.
Em seguida,
o próximo campo é o campo em destaque que seria do tipo booleano,
eo valor padrão será false.
Então, se meu documento está faltando isso,
então o valor padrão será adicionado ao documento aqui.
Então note que eu agora expandi
o esquema prato adicionando no tipo de imagem, a categoria,
o rótulo, o preço e o recurso para combinar com
a estrutura do exemplo de documento prato que eu acabei de mostrar anteriormente.
Então, agora, meu esquema de pratos está tudo pronto para ser usado.
Então, vamos agora começar a trabalhar no meu roteador.
Então, onde está o roteador?
Você se lembra de que o roteador que suporta os pontos finais da API REST para os pratos de barra,
ponto final da API REST e pratos de
barra, ponto final de ID de prato barra está no roteador prato.
Então, vamos para o prato router.jsfile e, em seguida, vamos estender o arquivo router.js prato.
Então, no roteador prato junto com Express e BodyParser,
vou agora incluir Mangusto.
Então vamos dizer exigir Mangusto e
, em seguida, vamos exigir modelo de pratos.
Onde está o modelo de pratos?
Está dentro. /modelos/pratos.
Então está lá dentro.
Então, observe que estamos na pasta do roteador,
então você precisa subir um nível e, em seguida, entrar na
pasta do modelo e, em seguida, o arquivo dishes.js está bem ali.
Portanto, é isso que importamos aqui.
Então, agora, eu posso atualizar meu roteador prato para ser capaz de interagir
com o servidor Mongoose usando o
Mongoose e nós já importamos o modelo de pratos para o meu roteador prato.
Então, é hora de eu ir e atualizar todos os métodos aqui.
Então, para o roteador prato,
a barra que significa que a barra pratos endpoint.
Vou remover tudo isso daqui, em vez disso,
vou declarar explicitamente todos os vários pontos finais.
Para obter post colocar e excluir eu vou lidar com cada um deles de forma independente.
Então, no método get,
eu vou cortar isso fora e, em seguida, no método get, o que eu preciso fazer?
Lembre-se que tínhamos definido método de Mangusto que nos permite encontrar todos os pratos.
Então, quando você faz uma operação get no ponto final pratos barra,
você está esperando que todos os pratos para ser devolvido
ao cliente em resposta ao pedido get.
Então, eu vou para a louça e, em seguida, executar a operação de busca.
Então agora você vê que a partir do meu servidor Express,
eu estou acessando meu MongoDB.
Então, vai fazer um achado e no achado eu vou agora lidar com o pedido.
Então eu posso dizer pratos encontrar, uma
vez que vai retornar uma promessa,
então eu posso lidar com isso aqui dentro.
Então, eu vou dizer prato e assim se a promessa resolver corretamente,
eu vou obtê-lo no então e então eu vou dizer prato e então vamos lidar com o
código de status res é 200 e, em seguida, vamos dizer
res definir tipo de conteúdo de cabeçalho.
Uma vez que vamos estar retornando o valor como um json,
então vamos definir isso para aplicativo json.
Ok, isso vai devolver uma variedade de pratos.
Então eu posso simplesmente dizer pratos e então vamos dizer res.json.
Então o res.json tomará como uma entrada na string json
e, em seguida, enviá-lo de volta para o meu cliente.
Então, quando você chamar res.json e fornecer o valor e, em seguida, ele vai simplesmente
pegar o parâmetro que você dá aqui e, em seguida, enviá-lo de volta como uma resposta json.
Ele vai colocar esses pratos no corpo da
mensagem de resposta e, em seguida, enviá-lo de volta para o servidor.
Agora, podemos lidar com o erro
aqui dizendo o próximo erro.
Também podemos fazer um erro de captura apenas por uma questão de completa.
Vou colocar ambos no lugar, para
que ambos sejam tratados como tal.
Então, se um erro é retornado,
então isso vai simplesmente passar o erro para
o manipulador de erros geral para o meu aplicativo
e o deixar que se preocupar sobre como lidar com o erro.
Então vamos enviá-lo para isso.
Então você vê como eu estou usando a operação de busca e, em seguida, realizando a solicitação aqui.
Agora, para o post,
como você já teria esperado,
eu vou fazer pratos.create
porque nós vamos estar criando um novo prato aqui.
Então, lembre-se que já são vistos os pratos criar o
uso do método anteriormente e lembre-se que o analisador de corpo
já teria analisado o que está no corpo da mensagem e carregado
na propriedade body da solicitação.
Então, eu só vou pegar o corpo da solicitação e, em seguida, analisá-lo em como um parâmetro para o meu
dishes.create método e lidar com o valor de retorno.
Então, vamos dizer então e isso iria retornar
um prato e nós vamos lidar com isso aqui.
Então, vamos dizer se os pratos retornam corretamente e se os pratos postados corretamente, dirá res.
Ok vamos fazer um console.log para nosso próprio uso.
No lado do servidor, faremos um prato console.log dizendo “Dish Created” aqui.
Vamos registrar esse prato para o console e então vamos dizer esses dois códigos de status de descanso.
Vamos apenas copiar esse código e depois colá-lo lá e, neste caso,
estamos devolvendo o prato aqui.
O prato que entrou como um parâmetro aqui e, em seguida, deixar
o cliente lidar com esse valor no lado do cliente,
o que for devolvido no prato.
Agora, também eles vão adicionar
aqui e depois a captura.
Então é assim que lidamos com o correio.
Para o PUT, porque PUT não é permitido,
então vamos deixá-lo como tal.
Para DELETE, vamos estar excluindo todos os pratos.
Então vamos dizer, “Pratos. Remova.”
Esta é essencialmente uma operação perigosa.
Então você está removendo todos os pratos
do servidor e então vamos dizer,
“pratos.Remova então” eo “então” vai ter alguma resposta.
Então, vamos apenas dizer, “resp aqui” e a maneira como lidamos com
essa resposta é simplesmente pegar esse valor e, em seguida, devolvê-lo ao cliente.
Então, vamos dizer, “Res.StatusCode 200 content type application json” e,
em seguida, vamos simplesmente enviar a resposta de volta para o cliente e vamos lidar com o erro
exatamente como fizemos anteriormente.
Essa é a operação DELETE.
Então você vê que agora estamos fazendo a
operação GET, POST, PUT e DELETE.
Agora vamos continuar o mesmo com o ponto final /DISHID.
Então, neste caso,
estamos especificamente motivo recebendo um prato específico.
Nós vamos estar retornando esse valor prato específico.
Então, no GET,
o que fazemos é dizer “dishes.findByID.
Então, o FindByID é um método que está disponível a partir de mongo, bem como o driver MongoDB.
Então vamos dizer,” req.params.dishid.”
Lembre-se que já sabemos que o ID do prato está presente na propriedade params.
Você já aprendeu sobre isso antes.
Então eu vou dizer, “findById (req.params.dishid)” e
, em seguida, e o outro.
Então eu vou apenas copiar isso, então, e então, de
lá e, em seguida, descer para o DishRouter e
, em seguida, simplesmente colar isso aqui.
Então vamos dizer, "Res.statusCode200
aplicativo json.res.jsondish e, em seguida, o tratamento de erros.
Para o POST, obviamente não vamos lidar com o post para um endpoint /DISHID.
Então vamos deixá-la como tal.
Para PUT, vamos atualizar
um prato específico que é identificado pelo seu ID prato.
Então é aqui que vamos usar dishes.FindbyidandUpdate.
Então este é o método que vamos usar,
findByidAndUpDate e isso leva como o primeiro parâmetro
req.params.dishid e o segundo valor é
o conjunto e a atualização
estará no corpo da mensagem.
Então eu só vou recuperar isso
do corpo de requisição e, em seguida, também a outra bandeira que eu vou ter.
Então vai dizer, “new: true”, para que este método findById retorne
o prato atualizado como uma string json na resposta.
Então é isso que eu vou estar recebendo aqui e, em seguida, quando esse valor entrar,
eu vou apenas pegar o prato e, em
seguida, simplesmente retornar o prato para o lado do cliente.
Então eu vou dizer res.jason (prato) e, em seguida, vamos lidar com o erro correspondentemente.
Finalmente para o DELETE.
Para o DELETE novamente,
o método correspondente que vamos estar
usando é o método do Mongo chamado findByIdAndRemove.
Então você pode ver que temos este método chamado
findByIdandRemove e este findByIdandRemove,
vai tomar Req.params.Dishid porque esse é o prato que estamos tentando remover.
Então, quando isso é excluído,
assim como nós lidamos com isso aqui,
então eu vou apenas copiar este código do dishes.Remove.
É a mesma coisa que eu vou fazer aqui também.
Então, FindByIdandRemove e qualquer resposta
que eu receba, vou devolvê-la ao meu cliente.
Com isso, atualizamos o DisishRouter.
Vamos salvar todas as alterações que fizemos
até agora e, em seguida, vamos e iniciar o nosso servidor e, em seguida, ver o que ele faz.
Então, indo para o terminal ou a janela de comando, inicie o servidor.
Então eu vou dizer “npm start” e o servidor agora está funcionando.
Vamos usar o carteiro para nos comunicar com este servidor.
Então vamos ao carteiro e, em seguida, executar certas operações.
Então aqui você vê meu carteiro correndo aqui.
Então deixe-me fazer uma operação GET no localhost: 3000/pratos.
Então, quando você faz uma operação GET como você vê,
ele retornará uma string vazia.
Meu banco de dados agora está vazio, então eu não tenho nada lá.
Então eu só vou ser devolvido uma string vazia.
Vamos postar um prato.
Então, quando você postar um prato,
obviamente no corpo,
você estará encerrando um prato e o corpo será definido para ser o tipo json aplicação.
Agora, para postar um prato,
eu já lhe dei o arquivo db.json nos recursos de exercício.
Então, basta abrir o arquivo db.json e, em seguida, copiar o primeiro prato de
lá e, em seguida, vamos colá-lo aqui e, em seguida, postar esse prato.
Então, deixe-me ir ao arquivo db.jason.
Deixe-me copiar o primeiro prato daqui.
Então eu estou indo apenas para copiar
todo o prato todo o caminho até lá e então eu vou postar este prato.
Isso contém muitos dos campos que já temos aqui.
Vamos postar este prato no servidor e ver o que acontece.
Então, voltando para o carteiro.
Aqui, nos dados do formulário,
no corpo, deixe-me colar o prato no lugar.
Então, temos os detalhes completos do prato lá.
Vamos POST este prato para o servidor.
Então, uma vez que o prato é postado para o servidor,
você vê que o carteiro tem,
deixe-me apenas encolher isso,
e então você vê na parte inferior que este prato em particular foi postado para o banco de dados,
para o banco de dados MongoDB pelo meu servidor.
Então, você vê que o valor retornado
aqui mostra quando o prato foi inserido nesse servidor.
Então, você tem o CreateDAT e UpdateDAT adicionado lá.
Você vê que os campos restantes estão todos armazenados lá.
Observe particularmente como o valor do preço está sendo armazenado lá.
É assim que a moeda armazena o valor do preço.
Então, quando você obtém o valor de retorno,
você precisa interpretar isso adequadamente no lado do seu cliente o que isso significa.
Note também que o ID foi adicionado ao meu prato e para cada comentário em si,
porque cada um dos comentários é em si é um subdocumento.
Você terá o UpdateDAT e CreateDAT adicionados,
e o ID de cada um dos comentários também adicionado lá automaticamente pelo meu banco de dados.
Lá vai você. Então, agora,
este prato foi adicionado ao meu banco de dados.
Vamos novamente executar a operação GET,
e, obviamente, neste ponto,
o servidor deve retornar esse prato particular que foi adicionado em.
Então, ele irá retornar uma variedade de pratos aqui,
então, como você pode ver, ele retorna uma variedade de pratos.
Claro, esta matriz contém apenas um prato
ou aquele prato em particular foi devolvido aqui.
Até agora, tudo bem.
Então, vamos fazer um PUT na louça e ver o que acontece.
Quando você faz um PUT, obviamente, ele diz,
“operação PUT não suportado em pratos”, como esperamos.
Vamos fazer um DELETE.
Fazendo uma operação DELETE,
ele retorna esta resposta dizendo,
“N é igual a um”, ok,
um que significa que ele excluiu um prato.
Vamos agora novamente, executar uma operação GET,
e então você veria que meus pratos estão vazios como esperávamos.
Então, você vê que as
operações GET, PUT, POST e DELETE estão funcionando corretamente.
Agora, deixe-me POST o prato novamente
para o servidor porque eu quero ter um prato no servidor.
Então, deixe-me POST esse prato,
e você notaria que o ID mudou agora.
Então, deixe-me selecionar esse ID,
e então vamos fazer um GET com o ID no lugar.
Quando você faz um GET com o ID no lugar,
você vê que ele retorna aquele prato específico como você espera.
Vamos ao terminal e ver o que está
sendo impresso no terminal ou na janela de comando.
Então, indo para o terminal ou sua janela de comando,
você vê que ele está imprimindo todas essas coisas na janela de comando.
Então, quando fizemos a primeira operação GET,
ele diz, GET /pratos.
Então, isso é novamente,
Morgan fazendo este trabalho para você, ele está imprimindo,
rastreando esta informação e ele diz prato criado
e, em seguida, essa informação prato particular foi impresso,
e então ele diz POST /pratos, GET /pratos,
e então quando você fez um PUT retornou um 403
lá e você novamente criou pratos e assim por diante.
Então, você vê que seu servidor está realmente fazendo todo o trabalho,
e essas coisas estão sendo inseridas em seu banco de dados MongoDB como você esperava.
Agora, voltando para o carteiro,
vamos fazer um POST sobre os pratos.
Agora, isso não é suportado no lado do servidor,
então seu servidor deve dizer,
“A operação POST não é suportada nesse endpoint específico”, como você pode esperar.
Vamos fazer uma operação PUT.
Quando você faz uma operação PUT,
o que eu vou fazer na operação PUT é que eu vou estar
substituindo o rótulo lá dentro.
Então, no meu corpo da mensagem.
Então, lembre-se que se você olhar para o arquivo db.json,
o rótulo para isso seria novo,
e então eu vou mudar esse rótulo para quente.
Uma vez que isso precisa ser em Json,
então rótulo também entre aspas Json rótulo quente,
e, em seguida, vamos fazer um PUT up em que endpoint particular.
A operação PUT foi bem-sucedida,
e assim você vê que quando a operação PUT foi concluída,
então você notaria que o rótulo agora mudou de novo para quente aqui,
e observe em particular, o valor
CreateDat e o valor UpdateDat.
Então, observe que esse registro foi criado
neste momento e foi atualizado um pouco mais tarde.
Então, a atualização foi feita pela operação PUT que eu acabei de
executar naquele prato particular.
Vamos apagar o prato.
Isto é permitido. Então, vamos excluir o prato,
e então o prato será excluído e o valor será retornado.
Agora, se você fizer uma operação GET
no ponto final de pratos, você verá que isso retornará um vazio.
Então, você acabou de excluir o prato do nosso banco de dados.
O que eu vou fazer é executar
uma operação GET em um prato inexistente e ver o que acontece.
Quando eu executar uma operação GET em prato inexistente,
ele retorna null porque esse prato não existe.
Então, ele retorna um valor nulo dizendo que o prato não existe.
Agora, deixe-me executar uma operação GET em um não-ObjectID e ver o que acontece.
Ele retorna como você vê.
Deixe-me antever isso.
Então, ele diz, “Transmitir para ObjectID falhou para valor aqui no caminho.”
Então, eu vou ser obviamente este não é
um ObjectID válido então eu apenas consegui excluir parte dele,
e então executar a operação para que ele retorna um erro dizendo,
então você vê que há 500 erro interno servidor.
O servidor não foi capaz de lidar com isso e, em seguida, retornar este valor aqui.
Então, ele diz: “Não,
isso não é permitido.”
Então, porque isso não é um ObjectID válido.
Assim, mesmo os erros são tratados adequadamente como você vê aqui.
Então, deixe-me novamente, fazer uma operação GET nos pratos,
e seu servidor ainda está em execução,
e ele retornará um valor vazio aqui.
Então, vimos como modificando
nosso servidor REST API para ser capaz de interagir com o servidor MongoDB.
Agora temos um servidor API REST completo que é capaz de armazenar,
e recuperar, e executar várias operações
sobre os dados que são armazenados no meu servidor MongoDB.
Com isso, completamos este exercício.
Então, neste exercício,
vimos como somos capazes de interagir com o nosso servidor de API REST,
e por sua vez, com o servidor MongoDB,
e então estamos aproveitando o servidor MongoDB para armazenar e recuperar dados do servidor.
Você é capaz de interagir do
nosso aplicativo Express com o servidor MongoDB usando Mangusto.
Este é um bom momento para você fazer um commit GIT com a mensagem,
“Express REST API com Mangusto Parte Um”.