Esta postagem foi publicada em SCIO SCIRE DOMINIUM às 18:39:42 de 04/10/2022

Ferramenta para estudos de FORECAST – Parte 1

Camada de autenti cação e de autorização
Como continuidade do último post que pode ser encontrado aqui, vamos implementar a camada de
autenticação e autorização da ferramenta multitenancy de forecast. Iniciaremos o passo a passo com a
camada de autenticação baseado em Member ship (base de dados implementada em um banco de
dados) usando Json Web Token. Mais informações sobre JWT, clique aqui.

Criação e preparação
inicial do projeto
1. Abrir o Visual Studio;
2. Selecionar no GET
STARTED a opção
CREATE A NEW PROJECT;
3. Em CREATE A NEW
PROJECT o projeto do
tipo BLANK SOLUTION;
4. Nomear a nova
SOLUTION; (nomeie
como achar
conveniente);
5. Posicione o cursor sobre
a SOLUTION recém
criada, pressione o botão
do mouse direito e
selecione ADD no menu
de contexto;
6. No submenu selecionar
NEW PROJECT;

7. Selecione um projeto do
tipo ASP NET CORE WEB
APP (no caso de
dificuldades de
encontrar esse template
de projeto, digite na
caixa de busca) e
pressione NEXT;
8. Nomeie o projeto na
caixa PROJECT NAME. No
caso adotaremos aqui
DELFOS.JWT.SSO.API;
9. Pressione o botão NEXT
e vamos especificar as
características desejadas
nesse template de
projeto;
10. Na combo FRAMEWORK,
selecione a opção .NET
6.0 (Long-term Support);
11. Certifique-se que a check
box CONFIGURE FOR
HTTPS está selecionada;
12. As seguintes check boxes
devem ficar
DESMARCADAS:
 ENABLE DOCKER;
 DO NOT USE
TOP-LEVEL
STATEMENTS
13. Pressionar o botão
CREATE. Verifique o
SOLUTION EXPLORER
que deve apresentar a
configuração semelhante
a mostrada na segunda
figura a direita no painel
ao lado. Nesse projeto
será realizadas as
implementações;
 14. Instalar os pacotes de
biblioteca que usaremos
na implementação.
Instalar os seguintes
pacotes:
 Microsoft.AspNe
tCore.Authentica
tion.Jwt
 Microsoft.Identit
yModel.Tokens
 System.Identity
Model.Tokens.jw
t
15. Como estamos utilizando
a versão .Net 6.0 não
deveremos ter
problemas em usar a
última versão de cada
um dos pacotes. Além
dos pacotes citados no
item 15 instalar também
tipicamente os pacotes
do Entity Framework
para interação com uma
base de dados.

Ajustes no
appsettings.json
16. Abra o arquivo
appsettings.json;
17. Ao final da chave
"AllowedHosts": "*"
adicione uma vírgula (,)
e tecle ENTER ;
18. Na linha de baixo
adicione a chave:

"Jwt": {
"Key": "Dhf .....",
"Issuer": "https://....",
"Audience": "https:// ...."
}

19. Na chave Key basta

gerar um número GUID
nesses sites de geração
como
 https://www.guidgener
ator.com/ . No caso
desse site desmarcar
todas as opções de
formato e todas as
opções de encoding e
ajustar para 1 o número
de GUID’s que vc quer
gerar e pressionar o
botão GENERATE SOME
GUIDs !. Gerado o
número, copie e cole
como valor na chave
Key.
20. Para gerar os conteúdos "Jwt": {
"Key": "0f278a5ab8bc44859e5c45ba67380104",
das chaves Issuer e
"Issuer": "https://localhost:44358",
Audience, "Audience": "https://localhost:44358"
respectivamente, ir em }
propriedades do
projeto, na tela de
propriedades, no painel
esquerdo selecionar
DEBUG, click no link
OPEN DEBUG LUNCH
PROFILES UI e na tela
que se abre copie o
moniker https que está
em App SSL URL nas
duas chaves.
21. O appsettings.json ficou
como representado ao
lado no meu caso.
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
22. Agora precisamos .AddJwtBearer(options => {
options.TokenValidationParameters = new TokenValidationParameters
configurar o serviço JWT {
ValidateIssuer = true,
e ajustar os parâmetros ValidateAudience = true,
para o serviço; ValidateLifetime = true,
ValidateIssuerSigningKey = true,
23. Como estamos usando ValidIssuer = builder.Configuration["Jwt:Issuer"],
ValidAudience = builder.Configuration["Jwt:Audience"],
o .NET 6, abrir o IssuerSigningKey = new
SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"]))
Program.cs; });
};

24. Inserir uma linha em

branco acima da linha:
builder.Services.Ad
dRazorPages();
25. Posicionando o cursor na
linha inserida digite o
bloco de código
representado ao lado. O
aspecto do Program.cs
 fica como representado
ao lado:

Ajustando a
inicialização no
Program.cs
 26. Logo em seguida a using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
inserção do bloco de using System.Text;
configuração do serviço
JWT, adicionar três var builder = WebApplication.CreateBuilder(args);
linhas de código:
// Add services to the container.
builder.Services.Ad builder.Services.AddAuthentication(JwtBearerDefaults.Authenticatio
dMvc(); .AddJwtBearer(options => {
builder.Services.Ad options.TokenValidationParameters = new TokenValidationPar
dControllers(); {
builder.Services.Ad ValidateIssuer = true,
dAuthorization(); ValidateAudience = true,
ValidateLifetime = true,
ValidateIssuerSigningKey = true,
ValidIssuer = builder.Configuration["Jwt:Issuer"],
27. Identifique na listagem ValidAudience = builder.Configuration["Jwt:Audience"],
do código do Program.cs IssuerSigningKey = new
SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration[
a linha de comando:
};
app.UseRouting();
});
28. Posicione o cursor ao builder.Services.AddMvc();
final dessa linha, builder.Services.AddControllers();
builder.Services.AddAuthorization();
pressione ENTER e builder.Services.AddRazorPages();
inserir a linha de
comando:
var app = builder.Build();
app.UseAuthenticati
// Configure the HTTP request pipeline.
on; if (!app.Environment.IsDevelopment())
{
29. O bloco de código deve app.UseExceptionHandler("/Error");
ficar semelhante a isso: // The default HSTS value is 30 days. You may want to change t
production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}

OBSERVAÇÃO IMPORTANTE:
Caso esteja utilizando .NET 5 app.UseAuthorization();
mudanças sutis devem ser
introduzidas. As linhas de
ajuste do serviço JWT
devem ser inseridas no
Startup.cs;
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthentication();
app.MapRazorPages();
app.MapControllers();
//app.UseEndpoints(endpoints =>
//{
// endpoints.MapControllers();
// endpoints.MapRazorPages();
//});

app.Run();

Criação dos modelos de

dados dos usuários
30. Vamos adicionar os
modelos necessários ao
processo de
autenticação e
autorização.
31. No Solution Explorer
(caso esteja em uso o
Visual Studio 2022),
selecione o projeto e
adicione uma nova pasta
e a nomeie como
MODELS;
32. Com o botão direito do
mouse, selecione a pasta
MODELS e no menu de
contexto selecione Add e
no submenu selecione
Class;
33. Nomeie a classe como
UserModel. O arquivo
UserModel.cs terá o
aspecto ao lado:
34. Na classe UserModel,
introduza a seguinte
sequencia de código
para determinar as
propriedades do usuário:

public int Id { get; set; }

public string UserName { get; set; }
public string Password { get; set; }
public string EmailAddress { get; set; }
public string Role { get; set; }
public string Surname { get; set; }
public string GivenName { get; set; }

35. Na pasta MODELS, criar

uma nova classe
chamada UserLogin.cs;
36. Nessa classe
implementar as
seguintes propriedades
para o login do usuário:

public string UserName { get; set; }

public string Password { get; set; }

37. Para efeito de teste do

funcionamento da API,
vamos criar uma classe
com dados ajustados em
código para testarmos e
constatarmos o retorno
do TOKEN;
38. Ainda na pasta MODELS,
crie uma classe
UserConstants.cs;
 39. Nessa classe iremos
implementar os dois
valores de teste,
conforme detalhado na
tela ao lado:

Adicionando as
Controllers da API
40. No Solution Explorer,
selecionar o projeto com
o botão direito do mouse
e no menu de contexto
selecionar ADD New
FOLDER;
41. Nomeie a nova pasta a
ser criada como
CONTROLLERS;
42. Posicione o mouse sobre
a pasta CONTROLLERS e
com o botão direito
selecione a opção ADD >
ADD NEW ITEM. Na tela
que surge, ilustrado ao
lado selecione a caixa de
busca e digite API, em
seguida no painel a
esquerda selecione API
CONTROLLER – Empty e
na caixa NAME digite
LoginController.cs;
43. Abrindo a using DELFOS.JWT.SSO.API.Models;
using Microsoft.AspNetCore.Authorization;
LoginController.cs, o using Microsoft.AspNetCore.Mvc;
seguinte fragmento de using Microsoft.IdentityModel.Tokens;
código ao lado deve ser using System.IdentityModel.Tokens.Jwt;
implementado na classe: using System.Security.Claims;
using System.Text;

namespace DELFOS.JWT.SSO.API.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class LoginController : ControllerBase
{
// injeção de dependencia com IConfiguration
public IConfiguration _config;
public LoginController(IConfiguration config)
{
_config = config;
}
/// <summary>
/// Implementa as ações executadas na chamada da controlle
/// </summary>
/// <returns></returns>
[AllowAnonymous]
[HttpPost]
public IActionResult Login([FromBody] UserLogin userLogin)
{
var user = Authenticate(userLogin);
if (user !=null)
{
var token = Generate(user);
return Ok(token);
}
return NotFound("Usuário não encontrado");
}

private string Generate(UserModel user)

{
var securityKey = new SymmetricSecurityKey(Encoding.UT
var credentials = new SigningCredentials(securityKey,S
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, user.UserName
new Claim(ClaimTypes.Email, user.EmailAddress),
new Claim(ClaimTypes.GivenName, user.GivenName),
new Claim(ClaimTypes.Surname, user.Surname),
new Claim(ClaimTypes.Role, user.Role)
};
var token = new JwtSecurityToken(_config["Jwt:Issuer"]
_config["Jwt:Audience"
claims,
expires: DateTime.Now.
signingCredentials: cr
return new JwtSecurityTokenHandler().WriteToken(token)
}

private UserModel? Authenticate(UserLogin userLogin)

{
var currentUser = UserConstants.
Users.FirstOrDefault(op => op.UserName.ToLower() =
userLogin.UserName.ToLower() && op.Password == use
if(currentUser != null)
{
return currentUser;
}
return null;
Teste da Geração do
Token Usando o
POSTMAN
44. Executar o projeto no
Visual Studio 2022;
45. Uma tela do browser
com a aplicação WEB
em execução deve
surgir. No address bar
do browser copie a URL
de execução. No meu
caso é
https://localhost:7178/ ;
46. Abrir o POSTMAN;
47. Na caixa SEND cole a
URL de execução exibida
pelo seu browser
acrescido de /api/login.
Em meu caso fica
https://localhost:7178/a
pi/login ;
48. Troque a operação de
GET para POST;
49. Selecione a Guia BODY;
50. Selecione o modo RAW e
o formato JSON;
51. Passe os parâmetros de
entrada do método
Authenticate (UserName
e Password):

{"UserName":"José_Admin","Password":"MinhaSenha#01"}

52. Pressione o botão SEND

e a tela deverá se
apresentar como
demonstrado ao lado:

53. E recebemos o token de

autenticação porque
UserName e Password
correspondem.
54. O artigo parte 2
implementará essa
estrutura para
autenticação e
autorização para
múltiplas aplicações.