No exercício anterior,
vimos como foi fácil para nós configurar e, em seguida,
andaime um servidor de destinatários usando o framework LoopBack.
Vemos que esta estrutura LoopBack suporta todo um espectro
dos endpoints destinatários e
todas as operações dos endpoints destinatários automaticamente para nós,
quando andaimes nossa aplicação.
Neste exercício, veremos como podemos conectar
nosso servidor LoopBack a um banco de dados back-end,
ou MongoDB nesta instância,
e também veremos como podemos configurar vários controles de acesso nos endpoints do destinatário.
Assim, usando os controles de acesso,
podemos especificar que tipo de operações podem ser realizadas nos endpoints do destinatário,
e quem terá permissão para realizar essas operações.
Assim, por exemplo, um usuário não autenticado ou um convidado só pode
acessar informações ou fazer uma operação get nos pontos finais do destinatário,
um usuário autenticado também seria capaz de fazer o mesmo,
mas apenas um administrador seria capaz de gravar dados no meu servidor.
Assim, qualquer operação de put, post e delete só pode ser realizada por um administrador.
Ao longo do caminho, também veremos como podemos configurar uma conta de administrador em nosso servidor LoopBack
e, em seguida, configurá-la para que
somente o usuário administrador tenha permissão para executar essas operações.
Então é aqui que LoopBack nos permite definir algo
chamado funções associadas a vários usuários.
Assim, cada usuário pode receber uma função.
Como exemplo, você pode falar sobre um usuário comum,
um administrador, um super administrador e assim por diante.
Assim, você pode subdividir seu conjunto de usuários em vários grupos
e, em seguida, atribuir várias funções a eles.
Também vamos olhar para como o modelo de usuário embutido pode ser ainda mais personalizado,
dentro do nosso aplicativo LoopBack,
e como podemos construir outro modelo em cima do modelo de usuário,
e, em seguida, usar o modelo de usuário como a classe base
e desenvolver um modelo de nível superior chamado Modelo de cliente,
que nos permite armazenar informações adicionais para cada um
dos clientes que entrarão em nosso site.
Então, vamos explorar algumas dessas características do LoopBack neste exercício.
Para começar este exercício,
a primeira coisa que eu gostaria que você fizesse,
é iniciar seu servidor MongoDB.
Então aqui estou eu em outra guia terminal na minha pasta MongoDB,
onde eu configurei meu servidor MongoDB anteriormente,
que foi usado pelo meu servidor Express Plus MongoDB nos exercícios anteriores.
Então deixe-me iniciar o servidor MongoDB digitando
MonGod menos D-B dados de parte
nesta pasta e, em seguida, iniciar o meu servidor MongoDB.
Agora, eu vou conectar meu servidor LoopBack ao meu servidor MongoDB.
Então, indo para a minha pasta de servidor LoopBack aqui,
eu tenho que solicitar a fonte de dados do tipo L-B.
Isso nos permitirá configurar a fonte de dados para o nosso servidor LoopBack. O
próprio LoopBack pode se conectar simultaneamente a várias fontes de dados se você assim escolher,
e ele suporta vários tipos.
Ele suporta bancos de dados My Cycle, ele suporta MongoDB,
ele suporta Cloudant que também é outro banco de dados de documentos,
ele suporta Oracle, e muitos outros tipos de bancos de dados.
Então, você pode facilmente configurar isso.
Neste exemplo, vou configurar o meu servidor LoopBack
para falar com o meu MongoDB no back-end.
Então, no prompt,
se digitarmos a fonte de dados L-B,
ela nos solicitará informações.
Então, a primeira coisa que ele vai nos pedir é para o nome da fonte de dados,
e então eu vou configurar este nome de fonte de dados como MongoDB,
e então ele vai me pedir para selecionar o conector.
LoopBack usa conectores para se conectar a vários bancos de dados nos bastidores.
Então, como você pode ver, o banco de dados in-memory que é o que
eles acabaram de usar no exercício anterior,
mas é claro que o banco de dados in-memory significa que uma vez que você desligar seu servidor,
todos os valores desaparecerão,
e isso não é um armazenamento de dados persistente.
Então aqui você vê os vários tipos de bancos de dados que StrongLoop suporta aqui.
Assim, você pode ver a longa lista dos vários bancos de dados que são suportados.
Então você pode ver que ele suporta Cassandra, Redis,
nós tínhamos brevemente referido a estes quando falamos sobre bancos de dados NoSQL, MongoDB,
My SQL, PostGres, Oracle,
e até mesmo diretamente para outros servidores API de descanso para servidores SOAP,
Coachbase e assim por diante.
Então você vê que ele nos fornece
uma longa lista de vários tipos de fontes de dados de lá,
nosso servidor LoopBack pode ler em informações.
No meu caso, eu vou usar o servidor MongoDB então eu
vou configurar o conector MongoDB.
Então, quando eu faço isso,
LoopBack irá instalar automaticamente o conector MongoDB para nós,
e quando ele pede a URL string de conexão,
vamos deixar isso como vazio porque vamos permitir que
ele use a maneira padrão de configuração.
Quando ele pede para o host, vamos dizer
localhost porque estamos executando nosso MongoDB no mesmo computador.
Caso contrário, você especificará
o nome do host do computador no qual você está MongoDB está sendo executado.
Em seguida, o próximo é o número da porta e estamos
usando o nosso número de porta MongoDB padrão 27017,
e ele também vai pedir o nome de usuário e senha, se necessário,
e agora meu MongoDB está em execução sem ter
que fazer qualquer autenticação, então eu deixo o o nome de usuário e senha vazios,
e o nome do banco de dados.
O nome do banco de dados no servidor MongoDB que está sendo executado em segundo plano,
o nome do banco de dados há confusão.
Se você se lembrar, esse é o nome do banco de dados que eles configuraram em nosso servidor MongoDB.
E então ele vai nos perguntar se ele deve instalar o conector LoopBack,
e eu vou dizer sim,
e vai realmente ir em frente e instalar o módulo NPM que acessar
o conector LoopBack para o banco de dados MongoDB.
E uma vez que isso é feito,
meu conector Loopback é instalado aqui para que você possa ver que esta é a versão 1.18.1
e meu servidor LoopBack está pronto para falar com meu MongoDB.
Agora antes de prosseguir,
no exercício anterior eu realmente não configurar alguns modelos
e, em seguida, eu especificá-los para ser armazenado no banco de dados,
eu vou precisar ir e atualizá-los para armazenar seus dados no meu MongoDB.
Então, vamos redefinir rapidamente nosso código para o servidor LoopBack.
Isso também nos fornece uma oportunidade de olhar para
o que meu servidor Loopback em si configurou nesta pasta.
Abrindo a pasta LoopBack em nosso editor,
você pode ver que Loopback já tem
um monte de arquivos para fora nesta pasta.
O package.json, é claro, contém
todos os módulos NPM relacionados que foram configurados aqui,
e aqui você pode ver que o próprio LoopBack configurou o módulo LoopBack NPM,
o módulo de inicialização LoopBack e, em
particular, deixe-me chamar sua atenção para o LoopBack MongoDB conector,
que tínhamos acabado de instalar há pouco tempo, e muitos outros.
Em particular, a configuração para o servidor Loopback é toda
armazenada principalmente em arquivos Json aqui,
com javascriptcore adicional sempre que necessário.
Vamos procurar a personalização do código javascript um pouco mais tarde.
Deixe-me chamar a sua atenção para esta pasta chamada comum.
Nesta pasta comum,
você verá todos os modelos que configuramos anteriormente.
Então você verá que temos os arquivos Dishes.JSON.
Então, quando você abre o arquivo dishes.json, você vê como LoopBack
armazena todas as informações sobre o modelo de pratos que você acabou de criar,
então ele tem o nome, a base,
e alguns outros valores aqui que ele requer.
E, em seguida, olhar para as propriedades e como todas as propriedades são armazenadas aqui.
Então você vê algumas coisas que são muito fáceis para você
reconhecer que estão no arquivo dishes.json.
Da mesma forma, os leaders.json e as promotions.json.
O arquivo dishes.js é grande,
podemos adicionar algum código de personalização adicional para os pratos,
mas agora não vamos fazer isso,
e então vamos deixá-lo como está.
Então este é o lugar onde você pode adicionar em algum código adicional que pode
precisar ser executado quando você acessar o ponto final de pratos de barra.
Mas agora vamos deixar em branco por enquanto.
Agora vamos também olhar para a pasta do servidor aqui.
E a pasta do servidor,
em particular deixe-me chamar sua atenção para o arquivo datasources.json aqui.
No arquivo fonte de dados,
todas as fontes de dados diferentes serão configuradas aqui.
Então agora, nós só temos o DB que é
o banco de dados in-memory DB que LoopBack por padrão configura,
e, em seguida, o MongoDB que acabamos de configurar,
apenas absorveu a informação que a entrada
foi armazenada em que fontes de dados, arquivo json.
Então, você verá que o próprio LoopBack opera configurando todos esses arquivos
que o próprio framework LoopBack faz uso quando
inicia o servidor API de descanso baseado em Loopback.
Vamos entrar no arquivo model config.json aqui.
O próprio arquivo config.json
armazena muita informação aqui que é útil para nós,
mas aqui, vamos entrar e modificar algumas coisas.
Então, para isso, veremos que há novamente para os pratos,
promoções e líderes, a fonte de dados foi configurada como DB.
Então nós vamos modificar isso para MongoDB aqui.
Não só para este,
eles também vão mudar isso para promoções, e também líderes, o que
significa, que todos esses três vão derivar seus dados do MongoDB.
Além disso, para a função que é definida aqui.
Nós também vamos armazenar em MongoDB.
Vamos logo ver como vamos fazer uso da função,
e também do RoleMapping aqui.
Vamos entender a razão desses dois em pouco tempo.
E, em seguida, ACL, as listas de controle de acesso,
estes também serão armazenados no MongoDB.
E então, o usuário, também,
vamos armazená-lo no MongoDB,
e então eles vão deixá-lo lá.
Então, estas são as modificações que você deve fazer para
o arquivo model-config.json e, em seguida, salvar as alterações.
Como mencionei anteriormente, Loopback por padrão,
suporta este modelo chamado, usuário,
que é usado para suportar autenticação de usuário.
O próprio modelo de usuário armazena apenas três propriedades diferentes.
O nome de usuário, o endereço de email
e as informações relacionadas à senha.
Agora, se eles quiserem ter
uma maneira mais elaborada de armazenar informações adicionais sobre os usuários.
Em seguida, eles podem subclasse este modelo de base de usuários
e, em seguida, fazer uso disso.
Então, neste próximo passo,
vou criar outro modelo chamado, o modelo do cliente,
que usará o usuário como modelo base para o seu funcionamento.
E o modelo do cliente em si armazenará informações adicionais sobre os usuários.
Então, no modelo do cliente,
vou armazenar as coisas como o primeiro nome,
o sobrenome, e a imagem para o usuário e assim por diante.
Assim, o cliente atuará exatamente como o modelo do usuário,
que já vem com seu próprio conjunto de métodos.
Assim, o modelo de usuário é usado para a autenticação do usuário, para
que você possa digitar o nome de usuário e a senha,
e fazer login e sair.
Então, quando criamos este modelo de cliente com base na classe base do modelo de usuário,
o modelo de cliente também suportará as
operações de login e logout usando este modelo de cliente.
Então, podemos fazer login no usuário e sair do usuário e assim por diante.
Então, a autenticação do usuário vem automaticamente para a direita.
Então, para criar o modelo do cliente, no prompt,
digite lb model e para o nome do modelo,
digitaremos Cliente.
E o DataSource, vou escolhê-lo como MongoDB.
E, em seguida, quando ele pede para selecionar a classe base do modelo,
em vez de usar o PersistedModel,
vamos mover para baixo
e, em seguida, selecionar o usuário como a classe base.
Então, dessa forma, ele irá derivar todas as suas propriedades
da classe de usuário base que já está incorporada em Loopback.
E então vamos expor isso com a API REST,
e o MT plural personalizado.
E então isso estaria na pasta comum.
E para isso, as três propriedades que vamos adicionar são,
primeiro nome, que teríamos a string tipos.
E isso não é obrigatório ou não tem um valor padrão.
E, em seguida, sobrenome novamente como a cadeia de caracteres de tipo
, não obrigatório e nenhum valor padrão.
E, em seguida, imagem da cadeia de caracteres de tipo,
não obrigatório e nenhum valor padrão.
Então, você vê que a própria classe de cliente
carrega propriedades adicionais além da classe de usuário.
a classe de usuário já suporta o nome de usuário,
o e-mail e as informações relacionadas à senha lá.
Então, a classe de cliente,
uma vez que sub classe é a classe base,
vamos obter o nome de usuário e o e-mail automaticamente da classe de usuário.
E agora, quando você vai para o arquivo model-config.jason,
você verá que o modelo de cliente já foi adicionado lá.
E então, nos modelos comuns,
agora você verá o arquivo.json adicionado lá
com essas três propriedades adicionais que adicionamos ao modelo do cliente.
Mas note, que ele especifica a base como a classe de usuário para o modelo de cliente aqui.
Então, é assim que Loopback permite que você tome
uma classe base-model e, em seguida, subclasse que para a classe model.
Então, você verá como Loopback nos permite suportar automaticamente a autenticação de usuário usando
a classe de usuário e, em seguida, nos permite definir até mesmo subclasse adicional do que,
que irá armazenar informações adicionais relacionadas à classe de base de usuários.
Em seguida, vamos configurar o Controle de Acesso para
os vários modelos que já configuramos em nosso servidor Loopback.
Então, para configurar o Controle de Acesso
ou as Listas de Controle de Acesso em Lookback. O
Loopback usa essas Listas de Controle de Acesso como uma forma de especificar que tipo de
operações podem ser executadas nos
diferentes pontos finais da API REST correspondem aos diferentes modelos.
Então, para fazer isso, vamos digitar no prompt lb acl,
ACL significa listas de controle de acesso.
E então, quando isso acabar, diremos,
qual modelo queremos que essa Lista de Controle de Acesso seja aplicada.
E então vamos dizer, todos os modelos existentes.
E vamos dizer, Todas as métricas e propriedades.
E vamos dizer,
Todos os tipos de operações.
E então, vamos dizer, Todos os usuários.
E então diremos, negamos explicitamente o acesso.
Então, estamos primeiro fechando todos os modelos para tudo,
então abriremos lentamente,
quaisquer que sejam as operações que possam ser realizadas por diferentes usuários.
Então, primeiro passo, fechamos
todos os tipos de operações em todos os modelos que temos atualmente.
Em seguida, começaremos lentamente a abrir cada uma das operações, passo a passo.
Agora, o próximo passo,
o que faremos é configurar novamente a próxima Lista de Controle de Acesso.
Na segunda Lista de Controle de Acesso, diremos,
para todos os modelos existentes e diremos,
Todas as métricas e propriedades.
E então, vamos dizer, apenas acesso de leitura.
Ou seja, quando o usuário pode executar as operações GET nessas portas finais.
E essas operações GET podem ser executadas por todos os usuários.
Assim, os usuários podem recuperar informações.
E nós explicitamente concederemos o acesso para isso.
Então, o que significa que as operações GET são permitidas no nó de pontos de extremidade da API REST.
Primeiro, fechamos tudo,
depois abrimos apenas as operações GET para os usuários.
Agora, finalmente, eles vão para cada um dos modelos,
e depois fecham e permitem que certas operações
sejam executadas apenas por certos tipos de usuários.
Então, para fazer isso,
a próxima ACL que vamos configurar é para um modelo específico.
Então, vamos preparar este para pratos.
E diremos, um único método.
E, em seguida, o nome do método é, criar.
Então, o que significa que a criação destes só será permitida por.
Então, novamente, quando ele diz selecionar a função,
em seguida, para a função, vamos dizer, outro.
E então o nome da função seria admin.
Então, o que estamos fazendo por esta operação é que,
estamos dizendo que apenas um usuário administrador pode criar novos pratos ou atualizar pratos existentes.
Então, isso é um pouco fechado, as operações restantes.
Então, vamos fazer o mesmo pelos líderes.
E um único método e, em seguida,
o criar e vamos dizer,
apenas o administrador pode fazer isso.
E, finalmente, também para promoções.
Para promoções.
O método único, o método de criação será permitido
somente por usuários que tenham a função designada como administrador.
Veremos como criaremos usuários com uma função específica na próxima etapa.
Conceder acesso explicitamente.
Agora observe que eu não fechei clientes para criar operações.
Se eu fechar clientes,
ninguém será capaz de se registrar no sistema.
Então, é por isso que vou deixar isso aberto.
Porque, o cliente deve ser capaz de se registrar no sistema.
Então, você pode se inscrever para novas contas no sistema.
Contas de usuário no sistema.
Então, isso será deixado em aberto para as pessoas fazerem.
Então, para permitir que para os clientes, vamos dizer, clientes,
um único método, criar todos os usuários.
Assim, os clientes podem ser criados por todos os usuários, pois isso
permitirá que as pessoas façam login em suas contas.
Finalmente, vamos ver como podemos configurar nosso servidor para iniciar
com um único usuário administrador automático configurado em nosso servidor Loopback.
Então, para fazer isso,
em nosso servidor Loopback,
na pasta do servidor temos esta subpasta de inicialização aqui.
Seja qual for o código que colocamos na subpasta de inicialização,
será executado na inicialização do nosso servidor LoopBack.
Então, aqui, você verá que já temos este authentication.js,
que já está configurado,
um Loopback que irá configurar a autenticação do usuário para nós.
E então temos o root.js que irá configurar
algumas informações adicionais para o nosso servidor de Loopback RAM.
E podemos adicionar arquivos adicionais aqui.
Então, eu vou entrar lá na pasta de inicialização
e, em seguida, adicionar neste arquivo chamado, script.js.
E neste script.js,
vou configurar o código para criar um usuário admin por padrão.
Então, no script.js,
que não será nada além de um módulo NPM baseado em arquivo então,
vamos começar dizendo,
module.exports = função (aplicativo).
O aplicativo é o aplicativo Loopback,
que será fornecido como um parâmetro para esta função para nós.
E assim, podemos fazer uso dele dentro do nosso código aqui.
Então, aqui, vamos primeiro configurar um usuário admin.
Então, para fazer isso, vamos dizer,
var Customer = app.models.Customer.
Então, isso nos dá acesso ao modelo de cliente.
Então vamos dizer, clientes. Findone.
Então, vamos primeiro verificar se um usuário com
o nome de usuário como admin já está configurado no sistema ou não.
Se não, então eu vou criar um usuário admin.
E isso me fornece uma função de retorno de chamada com dois parâmetros, err e usuários.
E dentro deste - Então vamos primeiro tentar
ver se um usuário com seu nome admin já existe.
Se o usuário não existe,
então vamos criar o usuário.
Então, para criar o usuário,
vamos dizer aqui, se não usuários.
Então, se os usuários não é nulo ou se o usuário diz nulo,
então isso significa que não há nenhum usuário admin, então eu preciso criar um usuário admin aqui.
Então, neste caso, vamos dizer, customer.create.
E esta criação leva uma matriz de objetos, se você quiser.
E esta matriz de objetos nos permitirá especificar quais contas de usuário queremos criar.
Portanto, a primeira conta de usuário que eu quero criar ou
a única conta de usuário que eu quero criar é o 'Admin'.
Então este será o administrador padrão para o
meu servidor de loopback e, em seguida, eu posso configurar o e-mail.
Portanto, lembre-se que o modelo de usuário suporta essas propriedades,
confusion.net e, em seguida, senha
que vou configurar como senha.
Você também pode fornecer junto com isso,
o primeiro nome e o sobrenome,
se você quiser, para o usuário administrador.
Mas eu vou deixá-lo como tal,
como vazio porque aqueles não são necessários para o usuário administrador.
Então eu vou deixá-lo lá.
Portanto, este comando acabará criando um novo cliente com o nome 'Admin'.
Então, se este usuário ou o nome “Admin” não existir,
então vamos criar um.
E então aqui temos a função de retorno de chamada.
Então errar usuários.
Agora eu vou dizer,
se errar, nós não sabemos o que ele está tentando fazer então nós simplesmente vamos jogar o erro.
Mas normalmente não esperamos que isso aconteça.
Então, agora, como você designa esse usuário como um usuário administrativo?
Então, agora, quando eu me inscrevo aqui,
eu estou apenas inscrevendo um usuário normal aqui,
mas nós queremos dar um papel especial a este usuário.
Então é aí que o loopback suporta uma maneira de especificar funções para usuários.
Então, para especificar uma função,
vamos var Role = app.models.Role.
Então isso me permitirá criar uma função,
uma nova chamada de função admin aqui.
Então, podemos atribuir drones diferentes para diferentes usuários, se você quiser.
E para junto com isso,
eu também preciso criar um RoleMapping aqui.
Então vamos dizer, app.models.RoleMapping.
E se acontecer que o banco de dados já contém
qualquer RoleMapping que já existe,
então eu vou destruir todos aqueles quando eu iniciar meu servidor.
E então deixe-me tentar descobrir
para ver se uma função com
esse nome admin já
existe no sistema.
Está bem.
E neste leva,
como você esperaria,
uma função de retorno de chamada e dentro daqui vamos dizer, role.findone.
Então, se uma função com o nome admin já existir,
então eu não preciso criar uma.
Caso contrário, se isso não existir,
então eu preciso criar o papel.
Então vamos dizer, role. Create.
Então, vamos criar a função de administrador aqui.
E então isso nos leva a parâmetros err,
papel aqui, na função callback.
Agora, novamente, aqui para lidar com o erro,
vamos apenas copiar este 'if err' e depois colá-lo lá.
Da mesma forma aqui também, se o erro ocorrer,
então eu preciso lidar com isso.
Então “se errar “, então “jogue a mensagem”.
Caso contrário, criamos a função.
Então agora eu preciso mapear essa função para esse usuário específico que eu acabei de criar.
Este usuário que acabei de criar aqui.
Este usuário. Quero dar a esse usuário a função de administrador.
Então, desde que eu criei essa função pelo nome admin,
então vamos dizer, role.principals.create.
Então é assim que você cria um mapeamento entre a função e um usuário específico aqui.
Então vamos dizer, role.principals.create.
Então esta é a sintaxe lá.
Vamos dizer, principalType: RolemApping.User
aqui e você terá
um ID principal aqui que é os usuários.
Agora, o que esse usuário se refere?
Este usuários se refere a isso que acabou de entrar.
Então, quando criamos esses usuários, o
cliente deve criar um retorno bem-sucedido para nós aqui.
Então é isso que vou usar aqui.
Vamos dizer, usuários [0].
Então este seria um array de usuários que foram criados e contêm apenas um deles.
Então é por isso que eu estou dizendo usuário [0].
E, em seguida, vamos atribuir ID desse usuário aqui.
Então é assim que vamos criar um RoleMapping entre a função que acabamos de criar,
essa função, e então mapeá-la para o cliente que acabamos de criar.
Agora isso também nos leva aos parâmetros, a função callback.
E nesta função callback vamos simplesmente dizer,
if (err) throw (err).
Caso contrário, não estamos realmente interessados em saber o que mais aconteceu lá.
É isso. Então é assim.
Portanto, se a função chamada admin não existir,
criaremos essa função.
Se não- Então esta é a
parte 'else' onde eu ainda precisarei fazer este mapeamento.
Então deixe-me copiar esse código e então eu vou fazer exatamente isso aqui.
Então role.principals.create e, em seguida, mapeie isso para o usuário lá.
Então, se a função de administrador já existe,
então tudo o que eles precisam fazer é fazer o mapeamento.
Então, isso será armazenado no modelo RoleMapping em nosso banco de dados. É isso.
Então, esse pedaço de código que colocamos no arquivo script.js primeiro tentará
descobrir se um usuário admin existe e esse usuário é identificado pelo nome admin.
Caso contrário, o usuário será criado e, em seguida, criará a função para o usuário.
Criaremos uma função chamada admin.
Se esse papel existe,
então vamos usar isso.
Caso contrário, criaremos o papel.
E depois disso, criaremos esse mapeamento entre a função e o usuário.
Então loopback nos permite fazer o RoleMapping.
Então dizer que este usuário não é para este papel.
Portanto, este mapeamento é feito usando esta instrução.
Então isso completa a configuração de nossos servidores.
Para que um usuário admin seja criado e que o usuário admin
obtenha automaticamente a função do administrador conforme configurado aqui.
É isso. Vamos salvar as alterações em script.js.
E agora nossos servidores de loopback devem estar prontos.
Então vamos agora começar o nosso servidor de retorno e depois verificar o que podemos fazer com isso.
Indo para os terminais,
vamos iniciar o servidor de loopback.
Então vamos dizer, npm start e, em seguida, nosso servidor deve estar ativo e funcionando.
Vamos para o Explorer e, em seguida, procurar as informações lá.
E este servidor de loopback terá automaticamente
conectado ao meu MongoDP porque eu configurou a conexão.
Indo para o meu navegador,
deixe-me recarregar isto.
E quando eu recarregar isso,
agora você verá que temos um novo cliente que foi criado aqui.
O usuário já existia anteriormente.
Os pratos, líderes e promoções estão todos lá.
Vamos executar um get sobre os pratos.
Agora que isso está ligado à boca MongoDB,
meu MongoDB já tem alguns pratos lá.
Se o seu MongoDB está vazio,
você pode postar alguns pratos usando o post aqui.
Então vamos experimentá-lo.
Quando eu fizer uma operação get sobre os pratos de barra,
você verá que no corpo de resposta -
Todos os pratos que existem no meu banco de dados foram todos buscados.
Da mesma forma, eu posso fazer um GET em
promoções e eu deveria ver a promoção que já existe no meu banco de dados lá.
Então, você pode ver que a promoção já existe lá.
Então, isso nos mostra como podemos buscar informações.
Agora, vamos tentar postar um novo prato.
Então, para postar um novo prato,
vamos para o POST aqui.
Deixa-me copiar isto.
Obviamente, neste momento,
porque desde que eu não sou um logado,
Eu não vou ser permitido para postar o prato assim,
mas eu vou demonstrar que para você é apenas copiar e colar esta informação aqui,
e vamos tentar postar esse prato,
e então quando eu tentar postar o prato,
meu servidor responde imediatamente com este erro dizendo, AUTORIZATION_REQUIRED
Você não está autorizado a fazer esta operação.
Então, é por isso que você não está autorizado a fazer esta operação.
Agora, como você se autoriza?
Então, para se autorizar,
lembre-se agora que já criamos um usuário com o nome admin,
e esse usuário admin já existe como cliente aqui.
Então, entrando nos pontos finais da API REST do cliente,
se você rolar
para baixo, abaixo, você verá o login deste cliente.
Então, quando você faz um POST no login do cliente.
Então, para o login do cliente,
você rolar para cima aqui e, em seguida, aqui ele pede as credenciais.
Então, nas credenciais,
podemos digitar o nome de usuário entre aspas duplas, e vamos dizer,
Admin e, em seguida, senha,
vamos dizer, senha, e então vamos postar isso.
E então, quando você postar,
você vai notar que na resposta,
LoopBack vai me enviar de volta esta informação.
Agora, dentro desta informação,
este id específico que ele envia de volta é o AccessStoken para o meu servidor LoopBack.
Então, eu posso apenas copiar este AccesStoken aqui,
e então bem no topo aqui,
você pode ver que este é Token Not Set, aqui.
Diz Token Not Set.
E aqui você pode digitar este AccessStoken
e, em seguida, dizer, Definir token de acesso.
E, em seguida, seu AccessStoken será definido,
e, em seguida, todas as operações subsequentes que você executar irá automaticamente carregar
este AccessStoken no cabeçalho da minha mensagem de solicitação.
Então, dessa forma, agora meu administrador terá permissão para fazer postagens de itens lá.
Então, agora que eu fiz login como administrador,
deixe-me ir para promoções,
e então eu vou postar uma promoção lá,
e mostrar-lhe que eu realmente posso postar promoções.
Então, vamos para um POST,
e então vamos apenas copiar isso, e, em seguida, nos dados,
e, em seguida, para o nome vamos dizer, Promoção de teste,
e imagem vamos apenas deixá-lo como tal, descrição, Descrição do teste.
E eu posso postá-lo lá,
e você verá
que eu não deveria incluir este id aqui porque eu
deixei LoopBack atribuir automaticamente o id a ele.
Deixe-me postar isso e então você verá que no corpo de resposta,
a promoção de teste foi postada aqui.
E acabei de notar que não incluí
a bandeira em destaque para minhas promoções e meus líderes.
Então, eu vou entrar e incluir a bandeira em destaque como
uma das partes das minhas promoções lá.
Então, agora quando eu fizer um GET para as promoções,
você verá que nessa mensagem de resposta,
você verá a antiga promoção que já estava no meu banco de dados
e, em seguida, a nova promoção que acabei de postar no meu banco de dados já incluída aqui.
Então, eu só notei que eu preciso definir a bandeira em destaque,
eu vou mostrar-lhe como fazer isso em um.
Então, isso tipo de demonstra para você como você pode fazer login e explorar seu servidor LoopBack.
Deixe-me destruir este token,
então nós vamos apenas remover o token,
e então clique sobre isso para
que essencialmente enviará o token de acesso para uma
string vazia e assim meu token não será mais processado,
então agora meu usuário não está mais conectado.
Deixe-me criar um novo cliente.
Então, para criar um novo cliente eu vou dizer, clientes POST.
E depois vou copiar isto daqui.
Vou criar uma nova conta aqui.
E assim, aqui,
eu removerei o realm,
eu não preciso disso, eu não preciso do id.
Então, para o primeiro nome
e o EmailVerified deve ser automaticamente definido pelo sistema.
Então, deixe-me entrar como este usuário.
Então, eu vou apenas enviar meu primeiro nome, sobrenome,
e a imagem atualmente,
eu vou apenas definir uma string vazia lá, nome de usuário e e-mail.
E então vamos experimentá-lo,
e então ele volta dizendo,
Detalhes: 'senha' não pode estar em branco.
Então, você vai notar que aqui,
eu também deve incluir junto com o nome de usuário,
senha e, em seguida, vamos postar isso.
Então, quando você postá-lo, ele volta com
o Corpo de Resposta dizendo que você agora é parte do sistema.
Então, seu primeiro nome,
seu sobrenome e seu nome de usuário, seu ID de e-mail
e o ID que LoopBack atribui a você são enviados de volta para você.
Então, isso não é nada além da ID do MongoDB como você pode ver aqui.
Então, agora que eu me inscrevi como um cliente,
eu devo ser capaz de fazer login como o cliente, para
que eu vá para o POST login aqui,
e então aqui em vez do administrador,
eu vou fazer login como o novo usuário que eu fiz login.
Então, eu clico em Testar,
você verá que ele retorna com o id,
então ele me dá o token para este usuário admin aqui.
Então, com isso, concluímos o exame do servidor LoopBack que acabamos de criar.
E como acabei de mencionar,
notei que as promoções e os líderes não têm bandeira, então,
vou entrar no código.
Então, suponha que você esqueça algo assim,
então você pode simplesmente entrar e editar o código Json se quiser.
Então, eu vou para o meu código,
indo para o código,
eu vou primeiro para o commons e então eu vou para o dishes.json.
E, em seguida, no dishes.json,
eu vejo essa propriedade em destaque lá.
Eu vou copiar esta propriedade em destaque,
e então eu vou para leaders.json,
e então eu vou colar essa propriedade de feição para um leaders.json,
e também com promotions.json.
Esqueci de incluir isso quando criei esses modelos.
Eu deveria ter feito isso quando eu estava criando o modelo em si então,
se você esquecer algo assim,
então esta é outra maneira de editar seu modelo
e, em seguida, certificar-se de que seu modelo está configurado corretamente.
Então, é isso.
Então, agora minhas promoções e líderes também terão a bandeira em destaque definida lá.
Com isso, completamos este exercício.
Neste exercício, vimos como podemos configurar
um novo modelo estendendo uma classe modelo base que já está em LoopBack.
Também vimos como podemos configurar controles de acesso usando
as listas de controle de acesso suportadas pelo LoopBack.
Com isso, completamos este exercício.
Este é um bom momento para você fazer um ficar coberto com
as fontes de dados LoopBack mensagem e controle de acesso.