Esta é a segunda parte do Exercício de Sessões Expressas.
Concluímos a primeira parte anteriormente, em
que adicionamos suporte para Sessões Expressas
e usamos Sessões Expressas como uma forma de rastrear os usuários no lado do servidor
e reconhecer as solicitações recebidas dos usuários.
Neste exercício, não estamos nos concentrando tanto em Sessões Expressas,
mas veremos uma maneira de estender nosso servidor de API REST expresso para oferecer suporte a
um novo modelo para registrar e autenticar usuários.
Então, vamos introduzir um novo modelo de usuário e esquema em nossa aplicação.
Já temos a rota de usuários de barra que
o gerador expresso já montou o roteador de um usuário.
Então, vamos aproveitar isso e, em seguida,
atualizá-lo para suportar o registro de novos usuários,
autenticar um usuário existente
e também fazer logout de um usuário do nosso site de servidor.
Então, vamos olhar para Express Sessions como uma maneira de rastrear os usuários uma vez que o usuário fizer login
e, em seguida, quando
o usuário sair, a sessão será removida do sistema.
Então, como vamos fazer essa extensão neste exercício?
Vamos descobrir.
Continuando com o nosso servidor Express REST API,
vamos agora entrar nos modelos e adicionar um novo arquivo chamado user.js.
Este é o arquivo onde vamos criar o esquema do usuário e o modelo.
Vamos criar um esquema de usuário simples que rastreia o nome de usuário e senha,
e também um sinalizador que é definido para indicar
se o usuário é um administrador ou um usuário normal.
Então, esta é uma maneira de distinguir entre diferentes tipos de usuários.
Então, neste arquivo,
vamos primeiro exigir Mangusto porque estamos criando um esquema Mangusto,
e então vamos criar um esquema chamado esquema Mangusto,
e então vamos dizer var usuário.
Então este é o esquema de usuário que vamos criar,
e vamos dizer novo esquema de usuário.
O esquema do usuário será definido como eu acabei de mencionar,
com três campos aqui chamados nome de usuário
que obviamente seria do tipo string,
e este é um campo obrigatório,
e este é um campo único.
Você não quer dois usuários com o mesmo nome de usuário em seu sistema,
então criamos o nome de usuário e, em seguida, o segundo campo é o campo de senha.
Agora, é claro, você pode estender
este esquema de usuário para permitir que o usuário rastreie todo o seu perfil,
mas vamos fazer isso em um dos exercícios posteriores, para o momento,
um usuário é reconhecido dentro do sistema simplesmente pelo nome de usuário e senha.
Então, a senha é do tipo string e, em seguida, é necessária.
O terceiro campo que vou usar é chamado de administrador.
Então, o administrador é do tipo booleano,
e vamos dizer default false.
Assim, por padrão, quando um usuário é criado,
um novo usuário é criado,
o sinalizador admin será definido como false.
Você pode defini-la explicitamente como true a partir de
seu código para marcar um usuário como um usuário administrativo.
Talvez você possa fornecer privilégios adicionais a um usuário administrativo,
ou talvez permitir que o usuário administrador execute
determinadas operações que os usuários normais não fariam isso.
Vamos olhar para isso em um dos exercícios posteriores,
para o momento, este é o esquema de usuário que criamos,
vamos criar um módulo fora disso e exportar a partir
deste módulo um modelo Mangusto do nome usuário.
Então, este é o modelo Mangusto e o esquema é
o esquema do usuário que acabamos de definir um pouco mais cedo.
Então, é assim que definimos nosso esquema de usuário.
Então, agora que definimos nosso esquema de usuário,
vamos para o roteador que já foi configurado
pelo express generator quando ele gerar esta aplicação express.
Então, se você entrar na pasta rotas,
você verá este arquivo chamado users.js.
Então, este arquivo users.js será estendido para criar o roteador.
Então, bem ali o que eu vou fazer é importar corpo-parser,
e então eles vão declarar o roteador express,
e então vamos dizer também importar
o esquema de usuário e
modelo de modelos de usuário,
e então para o roteador expresso vamos dizer,
roteador usar body analisador.
Então, agora que declaramos o analisador de corpo lá,
vamos deixar esta parte como tal,
mais tarde vamos modificar isso para permitir que o administrador
seja capaz de recuperar
todos os usuários que estão registrados no sistema, mas no momento,
vamos deixar essa rota como tal.
Vamos adicionar mais algumas rotas aqui,
então vamos dizer, “Postagem do roteador”.
Então, apoiaremos a operação de postagem em uma rota chamada inscrição e, como você espera,
essa rota de inscrição permitirá que um usuário se
inscreva no sistema, então isso suportará a inscrição do usuário.
Então, vamos dizer, “Rec, res, próximo.”
Portanto, este seria o registro de postagem do roteador,
os métodos restantes não serão permitidos na parte final do cadastro.
Então, para acessar isso,
uma vez que este roteador de usuários é montado em usuários de barra,
nós especificaríamos este ponto final como usuários de barra barra inscrição,
e este é o ponto final que será usado para registrar novos usuários dentro do sistema.
Então, a primeira coisa que vamos fazer é usar
o método do usuário e a expectativa é que para um usuário para se inscrever,
o nome de usuário e senha será fornecido como uma string JSON
dentro do corpo da solicitação de post de entrada.
Então, a partir do corpo,
uma vez que o corpo já teria sido analisado pelo analisador de corpo,
então a partir do corpo,
irá primeiro verificar para se certificar de que
o usuário com esse nome de usuário não existe dentro do sistema.
Se o usuário com esse nome de usuário existir,
então você está tentando registrar um usuário duplicado
e isso não deve ser permitido no sistema.
Então, vamos dizer, “Usuários encontram um”, e então vamos tentar descobrir se
há um usuário com o nome de usuário que foi
selecionado pelo cliente que está tentando registrar um novo usuário.
Se o usuário já existe,
então obviamente você não permitirá que o novo usuário se inscreva com o mesmo nome de usuário.
Então, vamos dizer, “Então usuário.”
Então, isso retornará o usuário aqui e dentro deste campo de usuário,
então vamos verificar se o usuário já existe,
e então deixe-me pegar o erro aqui.
Então vamos dizer, “Erro de captura” e, em seguida, “próximo erro”.
Então, vamos apenas passar isso para o manipulador de erros lá.
Então, se essa pesquisa para o usuário retorna o campo de usuário,
se o usuário não for igual a null.
Então, se o usuário que é retornado por esta pesquisa
não é nulo, então isso significa que o usuário com esse nome de usuário dado já existe,
então você não deve permitir uma inscrição duplicada.
Então, vamos dizer, “Var err novo erro.”
E nós diremos, “Usuário req. body username.”
Já existe. Então, basicamente,
você está impedindo que um usuário duplicado se inscreva e então vamos dizer
err.status 403 versus o proibido e, em seguida, sair,
chamando o manipulador de erros, próximo erro. Caso
contrário, isso significa que o usuário não existe
, portanto, você deve permitir que o usuário seja desconectado.
Então, na outra parte,
diremos, retorne user.create ().
Vamos criar um novo usuário com o nome de usuário definido como req.body.username
e, em seguida, deixe-me colocar isso na próxima linha para que fique mais claro para você,
e vamos dizer senha: req.body.password.
Agora, nós já sabemos que o sinalizador admin por padrão será definido como false,
então vamos deixá-lo como tal,
e isso permitirá que nosso novo usuário seja registrado e quando o novo usuário for registrado,
isso retornará uma promessa e dentro do “então” vamos lidar com essa promessa aqui.
Então, isso vai devolver a promessa
deste “então” e então vamos lidar com isso no próximo “então” aqui.
Dirá então, Res.statusCode é 200,
Res.setHeader e vamos dizer Content-type application/json
e vamos dizer, res.json (status: Registro bem-sucedido),
e se você quiser,
podemos carregar o usuário
nesta mensagem de resposta aqui como uma propriedade no json.
Vai dizer Registro bem-sucedido.
Então, se houver um erro
nesta operação, dirá “próximo erro”.
Então isso vai lidar com o erro.
Se a promessa não resolver com sucesso,
então será tratado por isso. Então é isso.
Então aqui, temos uma maneira de o usuário se inscrever.
Então, para que o usuário se inscreva,
o usuário fará uma postagem em /users/signup e no corpo da mensagem,
o cliente incluirá uma string json
com propriedades de nome de usuário e senha nessa string json.
É assim que você se inscreve para um novo usuário.
Agora, vamos ver como vamos fazer login no usuário.
Agora, ainda usaremos as sessões Express que fizemos anteriormente para rastrear o usuário.
Então, para registrar um usuário dirá “router.post” no ponto final/login.
Então, no endpoint /login,
faremos um roteador.post.
Vamos, obviamente, em vez de dizer função,
você pode usar a função seta aqui para o router.post,
eu vou fazer a mesma coisa aqui.
Apaixonei-me por funções de seta.
Então, vamos fazer uma função de seta aqui.
Então, para o login, como o login prossegue?
Então, para o login,
o que vamos fazer é que vamos para o arquivo app.js e, em seguida, dentro desta auth,
nós estávamos fazendo esse registro para o usuário lá.
Então, o que eu vou fazer é copiar
tudo isso porque eu não estaria fazendo tudo isso de qualquer maneira.
Então, em vez disso, deixe-me copiar todo o caminho a partir deste ponto para o req.session.user.
Então, a parte if de req.session.user que vou copiar
e, em seguida, chegar ao users.js e para o login.
É exatamente como vou fazer a autenticação.
Então, vamos dizer se não req.session.user.
Então isso significa que o usuário ainda não se autenticou.
Em seguida, você espera que a autenticação básica como
um mecanismo para o usuário usar para autenticação.
Então vamos dizer var AuthHeader se! AuthHeader, em seguida, vamos levantar o erro,
caso contrário, vamos recuperar o nome de usuário e senha do cabeçalho.
Agora, aqui estávamos fazendo se nome de usuário é igual a admin e senha é igual a senha.
Mas agora, o que vamos fazer é procurar no
banco de dados para ver se esse usuário em particular existe.
Então, em vez de fazer isso aqui,
em vez de fazer isso se nome de usuário e senha,
vamos dizer, user.findOne
e vamos dizer nome de usuário é nome de usuário.
Então, esta propriedade é igual a este nome de usuário que acabamos de recuperar
e, em seguida, vamos dizer então usuário.
Então, dentro deste “então”.
Então eu vou mover este código dentro deste “então” porque
agora o que eu vou verificar é agora que eu recuperei o usuário,
eu preciso verificar para ter certeza de que este usuário é exatamente o que eu estou procurando.
Então, neste ponto,
vamos primeiro verificar para garantir que o usuário não é nulo.
Então, vamos dizer se o usuário é nulo.
Então, se o usuário é nulo,
então o que significa que não conseguimos encontrar um usuário com esse nome de usuário específico.
Então, você terá que retornar um erro aqui.
Então deixe-me apenas copiar esta parte e, em seguida, colá-lo
aqui e, em seguida, vamos voltar dizendo var novo erro
e vamos dizer nome de
usuário espaço
não existe.
Então, neste caso,
este usuário não existe então eu vou apenas remover esta parte e,
em seguida, o status de erro correspondente seria 403 aqui.
Então esta é a primeira parte.
Se o usuário é nulo, então estamos obviamente indo para dizer que o usuário não existe.
A segunda parte que vamos verificar é Else se senha de usuário.
Então, o que significa que o usuário existe neste momento.
Então, a segunda verificação que faremos é que a senha do usuário não é
igual a senha então.
Mais uma vez precisamos indicar o erro lá.
Portanto, o erro seria dizer,
neste caso, diremos
“sua senha está incorreta”.
Então essa é a segunda parte aqui.
Então sua senha está incorreta e, em seguida, a última parte.
Vamos dizer “outro”.
Então deixe-me recuar este código.
Então senão se
user.username é nome de usuário que obviamente deve ser verdadeiro neste caso.
Em seguida, a segunda parte,
user.password é igual a senha que também obviamente deve estar correta neste ponto.
Mas, em qualquer caso,
vou verificar esse problema aqui e isso não ocorrerá neste caso.
Então, no momento em que você chegar a este ponto,
o nome de usuário deve ser
o mesmo que o nome de usuário e senha deve ser o mesmo que uma senha,
mas em qualquer caso eu colocar em uma verificação dupla nesse ponto apenas para ter certeza duplamente.
Então, neste caso,
diremos que req.session.user está autenticado.
Então, vamos definir isso para autenticado
e também este, vamos dizer
Res.StatusCode é 200.
Assim, conseguimos autenticar o usuário com sucesso.
Então, vamos dizer Res.StatusCode é 200 e, em seguida, vamos dizer Res.SetHeader
Content-Type texto simples e
res.end vamos simplesmente enviar uma mensagem dizendo “Você está autenticado”.
É isso. Então, isso cobre a parte então do usuário Findone.
Então, primeiro, verificamos se o usuário é nulo,
isso significa que não conseguimos encontrar o usuário,
então estamos obviamente retornando um erro dizendo que o nome de usuário não existe.
Se a senha do usuário não coincidir com a senha,
então, neste momento,
o usuário existe mas a senha não coincidiu, então diremos,
“Sua senha está incorreta”, e então, finalmente,
chegamos a esse ponto, então o nome de usuário e a senha devem ser identificados corretamente.
Embora eu não precise desta verificação, mas eu apenas colocá-lo lá no lugar e, em seguida, neste ponto,
eu vou definir o req.session.user para
autenticá-lo e, em seguida, definir o código de status para 200, o que significa que você foi
capaz de autenticar com sucesso o usuário e, em seguida, você pode terminar nesse ponto.
Porque este é um então,
eu vou colocar em uma captura neste ponto,
então vamos dizer erro catch e se o erro ocorrer,
então eu vou simplesmente passar o erro
para o próximo para
que o manipulador de erros será capaz de lidar com o erro adequadamente.
Então que termina este usuário Findone.
Agora, este é o caso quando o req.session.user não está definido.
Se isso já estiver definido,
isso significa que o usuário já está conectado.
Então, neste caso,
a outra parte aqui lida com a situação dizendo que vamos definir
o StatusCode como 200
e o Content-Type como text/plain e então vamos dizer,
“Você já está autenticado.”
Então, se você chegar a essa outra parte,
você viria aqui porque o req.session.user já não é nulo,
o que significa que o usuário já foi autenticado, o
que significa que quando você chegar a esse ponto,
então o usuário já fez login mais cedo,
então você não precisa verificar.
Então você vai simplesmente dizer,
“Você já está autenticado”, e depois terminar neste ponto.
Está bem. Então, agora, o último método que vamos implementar é para fazer logout do usuário.
Então, vamos fazer um roteador.entrar em /logout.
Você deve estar se perguntando por que fazemos um get
no logout em vez de um post que fizemos no login?
No login, você precisa enviar o nome de usuário e a senha.
Para logout, você está simplesmente fazendo logout do sistema,
então você não precisa fornecer nenhuma informação adicional porque
o servidor já está rastreando você com base no
seu ID de sessão e dentro desse cookie de sessão aqui.
Então, é por isso que não estamos
explicitamente precisando enviar qualquer informação adicional no corpo da mensagem.
Então, vamos dizer se req.session então o que significa que a sessão deve existir,
caso contrário, você está tentando fazer logout de um usuário que não fez login.
Então não faz sentido.
Agora, a sessão em si fornece este método
chamado destruir e quando você chama o método destruir,
a sessão é destruída e as informações são
removidas do lado do servidor referente a esta sessão.
Então, o que significa que se o cliente tentar enviar novamente
as informações da sessão que são armazenadas na forma
de um cookie assinado no lado do cliente,
isso será inválido.
Portanto, precisamos de um método de excluir o cookie que é armazenado no lado do cliente.
Agora, esta operação irá remover
as informações da sessão do lado do servidor para que a sessão não é mais válida.
Então, neste ponto,
vamos dizer req.session.destroy e então vamos dizer, Res.ClearCookie.
Portanto, o ClearCookie é uma maneira de pedir ao cliente para
remover o cookie e o nome do cookie é o ID da sessão.
Então, no exercício anterior,
vimos que o cookie foi armazenado com o nome do ID da sessão no lado do cliente.
Então, estamos pedindo ao cliente para excluir este cookie do
lado do cliente na mensagem de resposta e, em seguida, vamos dizer,
res.redirect e vamos redirecioná-lo para a página inicial aqui.
Então, esta é uma maneira de redirecionar o usuário para entrar em sua página padrão,
então, por exemplo, a página inicial do seu aplicativo.
Então, esta é a maneira que você lidaria com o logout do sistema.
Se o req.session não existir,
isso significa que você não está logado,
então teremos que gerar um erro.
Então vamos dizer var err,
new Error, “Você não está logado”,
e vamos definir o status do erro como 403,
esta é uma operação proibida e,
em seguida, gerar o erro para o manipulador de erros, é isso.
Então agora, você vê que nós expandimos o roteador do usuário para suportar três novos endpoints,
o endpoint de inscrição que permite que um usuário se inscreva,
o endpoint de login que permite que um usuário inscrito faça login
e, em seguida, o endpoint de logout que permite que um usuário conectado faça logout do sistema.
No processo de logout,
você está destruindo a sessão no lado do servidor,
você também está limpando o cookie no lado do cliente, para
que o cliente não possa ser usado na sessão expirada para tentar entrar em contato com esse servidor.
Uma pequena correção em users.js,
isso deve ser var User require.. /models/user,
lembre-se de que o arquivo users.js está na pasta rotas e, em seguida,
o arquivo user.js está
na pasta models que está acima de um nível e, em seguida, na pasta models.
Então, isto deve ser... /models/usuário,
então faça essa pequena correção, é isso.
Nós modificamos o arquivo users.js,
agora a última coisa que precisamos fazer é ir e consertar o arquivo app.js.
No arquivo app.js do aplicativo,
se você navegar para o arquivo app.js,
você veria que temos
esse índice de barra aqui e barra os usuários aqui após a autenticação.
Agora, isso não vai funcionar para nós porque se você precisa se inscrever,
então o usuário iria se inscrever e fazer login antes que a autorização seja confirmada, de
qualquer maneira se o registro e login é para o processo de inscrição,
então eu vou movê-los para cima antes da etapa de autenticação aqui.
Então, vamos mover isto para este local.
Assim, um usuário de entrada pode acessar o arquivo de índice
na barra e também acessar o endpoint de usuários sem ser autenticado,
mas qualquer outro endpoint,
o usuário tem que ser autenticado, de
modo que é assim que configuramos isso.
Dentro da autenticação da função, diremos,
“Se não req.session.user”, então observe que este lugar,
não estaríamos permitindo que o usuário entre aqui sem que o usuário tenha feito login.
Então, se não req.session.user,
então nós simplesmente diríamos que você não está autenticado.
Esta autenticação tem de ser feita utilizando o método de início de sessão aqui.
Então, eu vou remover esta parte inteira aqui.
Então, vamos dizer, se não req.session.user,
diremos que você não está autenticado e então teremos que enviar uma foto três aqui, o
que significa que você nunca deve descer a este ponto
sem que o usuário faça login.
Então, diremos que você não está autenticado.
Lembre-se de que você precisa se autenticar fazendo um POST
na barra de usuários barra ponto final de login.
Então vamos dizer que você não está autenticado, caso contrário,
se req.session.user for igual a,
lembre-se que na função de login no
users.js definimos o próximo usuário da sessão para a string autenticada.
Então, é isso que vamos verificar.
Nós diremos, se req.session.user for autenticado,
diremos a seguir, caso contrário você não será autenticado novamente.
Então enviaremos uma mensagem proibida. É isso.
Então, com esta atualização,
meu arquivo app.js também está pronto.
Agora, tendo feito essas atualizações,
vamos verificar como nosso aplicativo funciona agora.
Indo para o terminal,
se o servidor estiver em execução, pare e reinicie o servidor.
Meu servidor não está sendo executado no momento,
então eu vou dizer npm start,
e meu servidor deve estar ativo e funcionando.
Vamos agora ver como vamos acessar o servidor.
Indo para Postman, deixe-me fazer um GET no
localhost: 3000/pratos e então você verá imediatamente
que ele se queixa dizendo que você não está autenticado.
Obviamente, não estou autenticado aqui.
Deixe-me tentar acessar apenas o localhost: 3000 e você verá que,
essa raiz está disponível para nós.
Agora, é claro, queremos primeiro registrar um usuário e, em seguida, fazer login
como o usuário e, em seguida, obter acesso ao resto dos pontos finais da API REST.
Então, primeiro, deixe-me registrar um usuário.
Para registrar o usuário,
eu preciso fazer um POST para o localhost: 3000/users/signup.
Para esta mensagem POST,
no corpo da mensagem,
eu preciso incluir no corpo da
mensagem uma string JSON com o nome de usuário.
Então, deixe-me fazer login e
então eu vou usar a senha como senha.
Este é um registro válido.
Então, quando eu me inscrever como um usuário com
essas informações na forma de uma string JSON incluída no corpo da mensagem,
deixe-me ver que o cabeçalho agora contém o aplicativo tipo de conteúdo,
JSON porque eu configurei o JSON no corpo da
mensagem e, em seguida, enviar o POST para a inscrição.
Então, quando eu enviar o POST para a inscrição,
você verá imediatamente o que é retornado pelo servidor aqui.
Então, você vê que o servidor voltou dizendo,
“Registro bem-sucedido” e ele mesmo,
ele me dá os detalhes do usuário aqui.
Então, este é um registro que existe no meu MongoDB e
note que o tipo de modelo é o tipo de modelo de usuário que tivemos configuração.
Então, temos o nome de usuário e senha e
o sinalizador admin como você pode ver é definido como false por padrão.
Uma vez que registramos o usuário,
este usuário agora é um usuário válido.
Então, deixe-me tentar novamente POST o mesmo usuário e ver o que acontece.
Então, quando eu POST o mesmo usuário obviamente,
lá do lado do servidor,
ele responde dizendo que este usuário já existe.
Então, você pode ver que nós configuramos nosso procedimento de inscrição para não permitir que
o usuário duplicar o registro com o mesmo ID de usuário.
Está bem. Então, essa é a segunda parte.
Agora, vamos fazer um login do usuário.
Para fazer um login do usuário,
deixe-me remover o tipo de conteúdo e, em seguida, eu também
removerei o corpo porque para o login, isso não é necessário.
Então, eu não preencho nada
no cabeçalho e, em seguida, tentar fazer login e quando eu tentei entrar,
ele responde de volta dizendo que você não está autenticado.
Você não está autorizado.
Agora, eu preciso me conectar.
Então, é aqui que eu posso usar a autenticação básica.
Então, na autenticação básica,
vou apenas digitar meu nome de usuário e
senha que acabei de registrar na etapa anterior e, em seguida, atualizar minha solicitação
e, em seguida, fazer um POST no login.
Então, quando eu faço um POST no login,
você vê que o servidor responde dizendo: “Você está autenticado”.
Então, neste ponto,
eu posso executar as
solicitações GET, PUT, POST e DELETE em todos os outros endpoints.
Então, neste ponto, se eu fizer um GET no endpoint de pratos,
você veria que isso retorna
o campo vazio porque meu banco de dados está atualmente vazio no momento.
Deixe-me limpar a autorização e também do cabeçalho remover
a autorização e, em seguida, fazer o GET e é caixa de ferramentas muito bem.
Então, você pode ver que agora eu sou capaz de
acessar os endpoints porque eu mesmo fiz login.
Então, agora, deixe-me fazer um logout do usuário.
Então, vamos dizer, localhost: 3000 e logout.
Observe também que, nos cookies,
um cookie foi configurado no ID da sessão ali mesmo.
Então, esse cookie existe no site do meu cliente.
Então, agora, deixe-me sair dizendo GET localhost: 3000/users/logout.
Então, quando eu fizer um log out do usuário,
você verá imediatamente que eu sou redirecionado para
esse endpoint localhost: 3000 e também notará que o cookie desapareceu.
Então, quando eu olho para cookies,
você vê que o localhost,
o cookie se foi porque do lado do meu servidor quando eu faço o logout
ele envia de volta um cookie claro descanso para o lado do cliente e assim o cookie se foi.
Agora, se eu tentar fazer um GET
no endpoint localhost: 3000/pratos,
isso não funcionará porque eu não estou autenticado.
Então, isso demonstra a você como você pode estender seu servidor Express para
permitir que os usuários se registrem e, em seguida, permitir que o usuário faça login no sistema
e, em seguida, também logout do sistema.
No lado do servidor, você está rastreando um usuário conectado usando a sessão e usando
o cookie no lado do cliente e quando o usuário faz
logout o cookie é destruído no lado do cliente.
Com isso, completamos este exercício.
Este é um bom momento para você fazer um commit Git,
com a mensagem, sessões Express parte dois.