Neste exercício, vamos continuar trabalhando
no nó Mangusto servidor que desenvolvemos no exercício anterior.
Faremos outra variação disso.
Além disso, também analisaremos como o Mangusto suporta sub-documentos,
e isso nos permite armazenar um documento dentro de
um documento para armazenar informações adicionais.
Vamos ver isso no próximo exercício.
Continuando com o exemplo em que temos trabalhado, agora,
no arquivo index.js,
agora veremos uma nova maneira de criar um prato e adicioná-lo em nosso aplicativo.
Então, antes tínhamos feito var NewDish e pratos e definir o prato.
Agora, neste caso, vamos usar um novo método chamado pratos criar que leva,
como parâmetro, o NewDish para criar e, em seguida, salvá-lo em nossa aplicação.
Então, em vez de fazer este NewDish salvar,
podemos simplesmente remover isso e lidar diretamente com os pratos criar método aqui.
Assim, o método de criação de pratos terá como parâmetro
um novo documento que precisa ser armazenado em nosso banco de dados
e, em seguida, cria e adiciona o documento ao banco de dados.
Depois disso, podemos continuar com o resto do exercício.
Essa modificação menor mostrará
que o mesmo aplicativo é executado exatamente da mesma maneira que antes.
Então, com essa mudança,
deixe-me apenas alterar o recuo
aqui para que o encadeamento dos métodos então seja muito claro.
Então, primeiro fazemos uma criação de pratos que retornará uma promessa
e, em seguida, mudaremos para o então e, em seguida, realizaremos
os passos restantes no prato criado.
Vamos salvar as alterações e, em seguida, ir e dar uma olhada nesta versão do nosso servidor.
Indo para o terminal
, mais uma vez, executando o aplicativo,
vemos que ele criará exatamente o mesmo que a variação anterior do servidor.
Então, estamos criando um novo prato aqui e, em seguida, inserindo-o
no banco de dados e, em seguida,
estamos recuperando esse prato e, em seguida, imprimindo na tela.
Com esta mudança, este é um bom momento para nós fazer
um git commit com a mensagem Mangusto parte dois.
Então, vamos verificar o status do git e, em seguida, adicionar o arquivo ao repositório,
e, em seguida, fazer um git commit com a mensagem Mangoose parte dois.
Continuando com o exercício,
na próxima etapa vamos adicionar um subdocumento
ao documento e ver como subdocumentos podem ser armazenados em nosso banco de dados.
Então, indo para o arquivo dishes.js,
eu vou adicionar em outro esquema no meu arquivo dishes.js chamado
como comentário Esquema e
, em seguida, definir isso como novo esquema.
Neste esquema de comentários,
como você já teria esperado,
vamos usar isso para armazenar comentários sobre o prato.
Assim, os comentários conterão um campo de classificação que
é do número do tipo,
e seu valor mínimo é um, o
valor máximo é cinco e obrigatório é verdadeiro.
Então, você pode ver que quando você usa um campo com o número do tipo,
você pode especificar os limites para ele, se você escolher.
Em seguida, o próximo campo é um campo de comentário que seria da cadeia de caracteres de tipo.
Então, isso armazena uma mensagem e, em seguida, obrigatório
é verdadeiro e, em seguida, vamos também adicionar outro campo chamado autor,
que é do tipo string e obrigatório é verdadeiro.
Nós também adicionaremos o campo de carimbo de data/hora para isso,
e definimos isso como verdadeiro.
Então, para cada comentário que é adicionado,
nós também vamos armazenar o carimbo de data/hora correspondente.
Então, agora que declaramos um esquema de comentário,
podemos então ir em frente e modificar o esquema prato para ser capaz de armazenar comentários.
Então, dentro do esquema de pratos,
podemos adicionar em comentários
que é uma matriz do esquema de comentário tipo, o
que significa que cada objeto prato,
documento prato pode ter vários comentários armazenados dentro de uma matriz dentro do documento prato.
Então, este é o comentário documentos torna-se sub-documentos dentro de um documento prato.
Então, estamos armazenando todos os comentários sobre o prato dentro
do próprio prato como uma série de documentos de comentários.
Então, este é o uso do subdocumento em Mangusto.
Depois disso, vamos para o arquivo index.js e depois modificar nosso arquivo index.js.
Aqui, eles criam o prato como antes.
Então, depois de criarmos o prato,
então nós conectamos o prato.
Depois disso, atualizaremos o prato.
Então, vamos dizer pratos encontrar por ID e atualizar.
Então, vamos modificar o prato que acabamos de inserir na etapa anterior.
Então, vamos dizer, “Encontre por ID e atualize.”
E nós vamos fornecer.
Neste leva dois parâmetros,
o primeiro parâmetro é o prato.
Agora, este prato. _id, claro, refere-se a este prato que acabamos de inserir,
e então vamos modificar esse mesmo prato no próximo passo.
Então, vamos dizer, “Prato. _id.” E então,
entre colchetes, especificamos $set, descrição,
teste atualizado e novo verdadeiro.
Então, isso, estamos modificando o prato que
acabamos de inserir atualizando sua descrição lá.
Agora, isso tem que ser fechado dentro.
Esta segunda bandeira que estamos fornecendo aqui,
novo cólon igual a verdadeiro,
significa que uma vez que a atualização do prato está completa,
então isso irá retornar o prato,
prato atualizado de volta para nós.
Então, essa é a razão para usar esta bandeira aqui, digamos, nova verdade.
Então, este prato será devolvido no próximo passo.
E assim, nós vamos pegar esse prato e, em seguida, imprimir esse prato.
Então, no próximo passo,
vamos modificar isso e dizer, “Isso, depois prato.”
E então, vamos fazer um registro de console de prato.
Então, depois disso, vamos inserir um comentário no prato.
Então, vamos dizer, “prato. Comentários.Empurre.”
Lembre-se de que os comentários é um campo dentro do prato.
Então, voltando ao esquema,
vemos que esses comentários são uma matriz do tipo CommentSchema.
Então, o que significa que podemos empurrar um item para esta matriz.
Então, voltando aqui,
vamos dizer, “Comentários prato empurrar.”
E então, vamos empurrar um documento de comentário para o prato aqui.
Então, eu vou dizer, “Comentários prato empurrar.”
E especifique os campos aqui.
Então, vamos dizer, “Classificação cinco, comentário e autor.”
E assim, isso irá empurrar este comentário para o campo de comentários deste prato específico.
Então, agora que modificamos o prato,
o próximo passo que vamos fazer é,
deixe-me fechar isso e, em seguida, colocar isso nele, então lá.
Vou voltar e consertar isso daqui a pouco.
Então, agora que modificamos o prato,
precisamos salvar o prato.
Então, vamos dizer, “Devolver prato seguro.”
Então, nesta etapa,
estamos inserindo um comentário no prato,
o prato que acabamos de criar e atualizar,
e então estamos salvando esse comentário;
e então, isso retornará o prato.
E quando o prato for retornado no próximo callback,
eu vou então dizer, “Prato de log do console.”
E então, depois disso,
diremos, “Retorne”.
Então, com isso, modificamos nosso arquivo index.js.
Vamos salvar as alterações e olhar para este aplicativo.
Indo para o terminal,
vamos executar npm start e, em seguida, ver o valor resultante aqui.
Então, voltando, vemos que no primeiro passo,
criamos este prato aqui com o nome e descrição como demos anteriormente.
E então, uma vez que o prato é criado,
no segundo passo,
atualizamos o prato e, em seguida, imprimimos a versão atualizada do prato.
Então, a versão atualizada do prato é impressa ali.
E você pode ver que a descrição foi atualizada do caso anterior,
mas o id permanece exatamente o mesmo que o prato que criamos anteriormente.
E o campo de comentários,
como você pode ver aqui,
é um array vazio e o fumado.
Na terceira etapa, nós empurrar o comentário em nosso prato aqui;
e então, este comentário particular que
adicionamos foi adicionado a esta matriz de comentários.
Então, você pode ver esse comentário sendo fechado aqui,
e este é o prato atualizado que agora foi impresso na tela aqui.
Então, você pode ver que fizemos vários passos um após o outro com o nosso prato.
Primeiro criamos o prato,
depois atualizamos o prato,
depois inserimos um comentário no prato,
que é um subdocumento dentro do documento do prato;
e então, imprimimos o resultado para você.
Com isso, completamos este exercício.
Neste exercício, vimos como podemos,
primeiro, criar um prato usando pratos criar,
então vimos o uso de sub-documentos: lá,
definimos um esquema dentro do
arquivo dishes.js e, em seguida, usar o esquema de comentário que definimos e, em
seguida, definimos o campo no esquema de pratos como um do tipo CommentSchema.
E então, no arquivo index.js,
fomos capazes de criar um prato,
atualizar o prato e também empurrar
um documento de comentário para o prato e, em seguida, salvar as alterações aqui.
Com isso, completamos este exercício.
Esta é uma boa hora para você fazer um Git Kermit com a mensagem, “Mangusto parte três.”