Forem: Matheus Paixão

Deploy .NET API to Kubernetes using Kind

Matheus Paixão — Wed, 06 Jul 2022 18:50:59 +0000

Hi Devs and Divas.

Today I am going to show you a simple way to install run and test your API locally with docker caontainer and orchestrating with Kubernetes.

If you ever heard that Kubernetes is super difficult, don't worry, it's not that bad.

In this article you will learn how to deploys a simple API to kubernetes with a local environment:

Preparing the API
Publishing API in Docker Hub
Installing Kind for Kubernetes
Preparing the API for Kubernetes
Pushing and Managing API to Kubernetes

Pre-requirements

You should have the basic concept knowledge of:

Kubernetes
Docker/Containers
Kind for Kubernetes
.net API

Preparing the API

We will create a basic Weatherforecast API that dotnet gives us.

Vs Code

Open VS CODE, open a new terminal, navigate to the folder you wish to create your project for example (cd source/repos).
Now type dotnet new webapi -o "weather" to create a sample webapi project.
Now open this project folder in the vscode.
To auto-create the Docker support that is available upon project creation in Visual Studio follow the next steps:
Install the Docker extension.
Press Ctrl + Shift + P
Type Add Docker Files to Workspace
Select .NET: ASP.NET Core
Select Linux
Type the port you wish to expose
Select No for docker compose. At this first moment we won't need it.

Then you notice it generated a new Dockerfile in your workspace.

Visual Studio

Open visual studio and create a ASPNET Core Web API and make sure you enable Docker Support.

Swagger Support

After the project is created you go to Program.cs (.net 6 above) or to Startup.cs (.net 6 below) and remove the IF condition from the swagger setup From this:

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

Should look like this:

    app.UseSwagger();
    app.UseSwaggerUI();

We do this for testing purpose only, because when you push it to kubernetes you need to set which environment you wish to build your application. You can add ASPNETCORE_ENVIRONMENT=Development in your docker profile, it will work as well.

Publishing API in Docker Hub

You must have Docker installed and have a Docker hub Account to complete this step.

In your IDE, open terminal and build the API:

docker build -t weather .

As a prevention measure, test your container before orchestrating with kubernetes. So lets run the image. (You can use whatever port you wish)

docker container run -d -p 8070:80 --name containername weather

Now you should be able to see swagger page if you type localhost:8070/swagger

Pushing to Docker Hub

Before pushing you can add tags to your image.

docker tag weather dockerHubUserName/weather

Now you can push it

docker push dockerHubUserName/weather

If you open your docker hub on your browser you should be able to see your image.

Installing Kind

To install kind refer to original documentation https://kind.sigs.k8s.io/docs/user/quick-start/

But let me show you what I did.

Download the file from https://kind.sigs.k8s.io/dl/v0.14.0/kind-windows-amd64
Rename the file to kind.exe
Move it to a folder named k8s. So should look like this C:\k8s\kind.exe
On windows, go to environment variables and add new PATH C:\k8s

Now if you have docker running, you should be able to create a cluster.

kind create cluster

Wait till it creates the cluster.

You should see a new container running on your docker. To check if the container is running type docker ps in your terminal and you should see a container named kind-control-plane from the image kindest.

To check if there are any clusters type on your terminal:

kind get clusters

And you should get a response like this:

kind

Preparing the API for Kubernetes

To access your application you need at least 2 kubernetes objects:

deploy.yml - A Deployment provides declarative updates for Pods and ReplicaSets.
service.yml - An abstract way to expose an application running on a set of Pods as a network service. To access your pod you need a service to expose it.

You don't need to know how to write it by hear, you can get a template and edit.

I recommend you use VsCode with YAML extension to edit your yml files, because it indentation is very delicate, and Visual Studio has no support for this extension.

This is a simplified version, for testing purpose, there are many options and features to be added according to your project

Create a file in your project weather-deploy.yml

Template:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: Application Name
spec:
  replicas: How many Replicas?
  template:
    metadata:
      labels:
        app: Application Name
    spec:
      containers:
      - name: Application Name
        image: dockerHubUser/applicationName
  selector:
    matchLabels:
      app: Application Name

Our project:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: weather
spec:
  replicas: 2
  template:
    metadata:
      labels:
        app: weather
    spec:
      containers:
      - name: weather
        image: dockerHubUser/weather
  selector:
    matchLabels:
      app: weather

Don't forget to add you docker hub User

Create a file in your project weather-service.yml

Template:

apiVersion: v1
kind: Service
metadata:
  name: Project Name
spec:
  selector:
    app: Project Name
  ports:
  - port: port?
    targetPort: 80 is the standart port

Our project:

apiVersion: v1
kind: Service
metadata:
  name: weather
spec:
  selector:
    app: weather
  ports:
  - port: 8070
    targetPort: 80

Pushing API to Kubernetes

To orchestrate the API to kubernetes pod we will only push this 2 files as the project will come from the docker image.

Terminal:

kubectl apply -f weather-deploy.yml

kubectl apply -f weather-service.yml

Terminal response should be:

deployment.apps/weather created

service/weather created

Wait a minute and check if your pod and service are running:

Terminal:

kubectl get pods

Terminal Response:

Terminal:

kubectl get svc

Terminal response:

kubectl get svc
NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
kubernetes   ClusterIP   xxxxx       <none>        443/TCP    23h
weather      ClusterIP   xxxxx   <none>        8070/TCP   3m53s

Accessing your Pod

To access your pod you need to forward a port to the service.

kubectl port-forward service/weather 8070:8070

Now you should be able to see the Swagger page in your browser typing localhost:8070/swagger

Basically you are telling the kubernetes that when you access port 8070 locally, you will access 8070 on kubernetes service, which is our pod's service.

Matheus PaixãoFollow

Gosto de compartilhar conhecimento pois foi assim que eu aprendi a programar. O meu negócio é todo dia saber mais que eu sabia ontem. Pode me chamar, vamos aprender juntos. Prazer =)

Flutter - How to format DateTime and how to display it

Matheus Paixão — Fri, 29 Apr 2022 01:49:10 +0000

Hello,
Today I will show you how to format datetime in the way you wish to display wi the intl flutter package.

To check the latest version o the package check this link HERE

Installation and Importing

At pubspec.yaml add intl: ^0.17.0 and make sure you check for the latest version, the ^ sign before the version is for the system to auto-update within that main release. So when they release version 0.17.1 it auto-update it self.

dependencies:
  flutter:
    sdk: flutter
  intl: ^0.17.0

At the file you wish to use, import it like this.

import 'package:intl/intl.dart';

How to use

Variable - datetime

You can edit and format as you wish, with dots, comma, arrows, etc.

DateFormat('d MMM y').format(datetime) = 28 Apr 2022
DateFormat('d MM y').format(datetime) = 28 04 2022
DateFormat('d-MM-y').format(datetime) = 28-04-2022

There are also a list o functions that we can use that gives us default formats.

DateFormat.yQQQQ().format(datetime) = 2nd quarter 2022

Have a look at all formats available at the official documentation HERE

Thank you

Matheus PaixãoFollow

Gosto de compartilhar conhecimento pois foi assim que eu aprendi a programar. O meu negócio é todo dia saber mais que eu sabia ontem. Pode me chamar, vamos aprender juntos. Prazer =)

Flutter - Difference between Container vs Column and Row

Matheus Paixão — Fri, 29 Apr 2022 00:36:05 +0000

Today I will simply show the difference between Container vs Column and Row. Both sets are commonly used in interface development and it's wise to know the basic difference between them both.

Container - Flutter doc reference

The container widget is the most used component in flutter apps because it provides you with various common painting, positioning, and sizing widgets, whenever you have widgets that are focus on it’s core functionality and don’t give you the option of positioning and styling, you involve it in a Container.

Accepts only one Widgets as child
Alignment is more flexible and the style options are more broad
Flexible Width, it can use the child width or whatever you set as width
Used when alignment and style is to be personalized

Column/Row

The row is the widget that can display various child widgets in a horizontal manner.
The column displays child widgets in a vertical manner.
By default, they do not support scrolling. It can be enabled by wrapping with other widgets. But, it is preferred to use ListView in case there are numerous child widgets to be displayed.

Accepts a list of Widgets as children
Limited alignment and no style options available.
Always fills the height (Column) and the Row always fills the width
Used when the Widgets are close to each other, follow a pattern or on top of each other

A great use of a Container and a Column/Row together, is when you want to personalize your Column and Row but you can’t. Then you involve your Widget in a Container so you can give better alignment and style it as you wish.

Thank you and let me know what you think bellow in the comments

Matheus PaixãoFollow

Gosto de compartilhar conhecimento pois foi assim que eu aprendi a programar. O meu negócio é todo dia saber mais que eu sabia ontem. Pode me chamar, vamos aprender juntos. Prazer =)

C# - Criando API com Jwt Token - Autorização e Autenticação - Módulo 3 - Arquitetura 3 camadas - Repository Pattern

Matheus Paixão — Thu, 07 Apr 2022 20:30:10 +0000

Sejam Bem Vindos a mais um módulo da nossa série.

Código Modulo 3 - Repositório GitHub

Primeiramente. Olá

Melhorias desse modulo

CRUD de Usuários
Introdução do Repository Pattern
Divisão em 3 Projetos (Infra - Domain - API)

Nesse módulo, irei abordar a evolução do módulo anterior, será muito fácil se perder na nova arquitetura que implementei, pois são vários caminhos percorridos para conseguir executar um end point.

Divisão em 3 Camadas

API
- Na camada de API colocamos os itens principais do projeto, Controllers, as models de entrada e saída (RequestDTO e ResponseDTO) e as configurações pertinentes a program.cs(.net 6) ou startup.cs (.net 5 ou anterior).
INFRA
- Na camada de infraestrutura colocamos toda a infra de banco de dados e repositórios. (Context, Mapeamentos, Repositories)
DOMAIN
- Na camada de Domain colocamos tudo que é compartilhado entre os outros projetos, as Models, os Services, Utilitários, Interfaces e helpers compartilhados entre os outros projetos. Domain é onde fica toda a regra de negócio da aplicação onde será compartilhado com as outras camadas.

Arquitetura 3 camadas

A arquitetura em 3 camadas serve para dividir as responsabilidades entre 3 projetos, podendo cada um focar em sua parte. Por exemplo, separando a camada de domínio e colocando toda a regra de negócio apenas ali, facilita assim, a manutenção do código, pois você já sabe que cada tecnologia, cada parte de código, está em seu devido lugar.

Como dividir o projeto em 3 camadas?

Criando Biblioteca de classes

Entenda que dividir o projeto em camadas nada mais é do que você criar sua própria biblioteca para consumo interno.

Para fazer a comunicação entre as camadas, é necessário referencia-las como no gif abaixo.

Repare que o projeto domain, não contem referências, pois na verdade ele não depende de ninguém, são os outros projetos que dependem dele, pois é ali que se concentra toda a regra de negócio que precisa ser consumida pela infraestrutura e pelas controllers no projeto principal.

Repository Pattern

O repository pattern é um dos padrões de projetos mais utilizamos mundialmente, ele é amplamente conhecido e aceito em projetos de todos os níveis.

Esse padrão de projeto visa a abstração de responsabilidade e encapsulamento do banco de dados, possibilitando a injeção de dependência.

Mas o que isso significa? Basicamente, você pode ter o banco de dados que for, e isso não irá afetar o resto do sistema. Pois agora cada um tem sua responsabilidade, se o repositório é responsável pelo acesso ao banco de dados, então quando tivermos alguma alteração de banco de dados, já sabemos que a alteração é mais provável que seja apenas ali.

Implementação

Primeiro de tudo eu crio o Repositório base, tem muitos exemplos prontos disponíveis pela internet com os métodos já prontos.

Entenda que pra todo repositório, ou serviço criado, você precisa também criar a Interface, que é o método de acesso a essa classe.

Base Repository

É aqui o único lugar onde terá uma estância do DataContext que é nosso acesso ao Banco de dados.

Os repositórios sempre implementam os métodos definidos na interface dele, e representam de forma genérica uma entidade/model.

public class BaseRepository<T> : IBaseRepository<T> where T : Entity
    {
        private readonly DbSet<T> DbSet;
        private readonly DataContext _context;

        protected BaseRepository(DataContext context)
        {
            _context = context;
            DbSet = _context.Set<T>();
        }

        public async Task<T?> GetById(Guid id) =>
        await DbSet.FindAsync(id);

        public async Task<IEnumerable<T>> GetAllAsync() =>
            await DbSet.ToListAsync();

        public async Task<T?> GetOneBy(Expression<Func<T, bool>> expression) =>
            await DbSet.AsNoTracking().FirstOrDefaultAsync(expression);

        public async Task<IEnumerable<T>> GetListBy(Expression<Func<T, bool>> expression) =>
            await DbSet.Where(expression).ToListAsync();

        public async Task<bool> Exists(Expression<Func<T, bool>> expression) =>
            await DbSet.AnyAsync(expression);

        public async Task AddAsync(T entity)
        {
            await DbSet.AddAsync(entity);
            await SaveChanges();
        }

        public void Update(T entity) =>
            DbSet.Update(entity);

        public void Remove(T entity) =>
            DbSet.Remove(entity);

        public async Task<int> SaveChanges()
        {
            return await _context.SaveChangesAsync();
        }

        public void Dispose()
        {
            _context?.Dispose();
        }
    }

IBaseRepository Interface

Notem que a interface tem todos os métodos que implementamos no repositório base.

A interface é o método de acesso aos repositórios e serviços.

public interface IBaseRepository<T> : IDisposable where T : Entity
    {
        Task<T> GetById(Guid id);
        Task<IEnumerable<T>> GetAllAsync();
        Task<T> GetOneBy(Expression<Func<T, bool>> expression);
        Task<IEnumerable<T>> GetListBy(Expression<Func<T, bool>> expression);
        Task<bool> Exists(Expression<Func<T, bool>> expression);
        Task<int> SaveChanges();
        Task AddAsync(T entity);
        public void Update(T entity);
        public void Remove(T entity);
    }

Service Login

Vou exemplificar como funciona o fluxo com o serviço de Login.

Repare que estanciamos o repositório de Login, que lá dentro acessa o repositório base que tem acesso ao banco de dados. Antes de chegar aqui, esse serviço é estanciado na controller através de sua interface.

public class LoginService :  ILoginService
    {
        private readonly ILoginRepository _loginRepository;
        private readonly TokenService _tokenService;

        public LoginService(ILoginRepository loginRepository, TokenService tokenService)
        {
            _tokenService = tokenService;
            _loginRepository = loginRepository;
        }

        public async Task<string> LoginAsync(string email, string password)
        {
            var user = await _loginRepository.GetUser(email);

            if (user == null)
                return "User or password invalid";

            if (!PasswordHasher.Verify(user.PasswordHash, password))
                return "User or password invalid";

            try
            {
                var token = _tokenService.GenerateToken(user);
                return token;
            }
            catch
            {
                return "Internal Error";
            }
        }

        public void Dispose()
        {
            _loginRepository?.Dispose();
        }
    }

Controller

Terminando aqui o fluxo reverso de como acessar o banco de dados com o repository pattern, podemos ver que na controller estanciamos a interface do serviço de interesse.

public class AuthController : ControllerBase
    {
        private readonly ILoginService _loginService;
        public AuthController(ILoginService loginService)
        {
            _loginService = loginService;
        }

Colocarei aqui novamente a imagem do fluxo de dados no repository pattern. Da controller você acessa os serviço de interesse, onde tem toda a regra de negócio da entidade em questão, depois acessa o repositório da entidade através da interface, e por fim, acessa o repositório base pra acesso aos dados.

Pra tudo isso funcionar, temos que declarar as injeções de dependências, pois é dessa forma que estamos estanciando uma classe na outra.

Sempre declarar na ordem da esquerda pra direita no fluxo de dados, então primeiro a interface depois sua classe de implementação.

public static IServiceCollection ResolveDependencies(this IServiceCollection services)
        {
            services.AddDbContext<DataContext>();
            services.AddScoped<TokenService>();

            services.AddScoped<ILoginService, LoginService>();
            services.AddScoped<ILoginRepository, LoginRepository>();

            services.AddScoped<IRoleRepository, RoleRepository>();
            services.AddScoped<IRoleService, RoleService>();

            services.AddScoped<IUserService, UserService>();
            services.AddScoped<IUserRepository, UserRepository>();

            return services;
        }

Porque implementar tudo isso?

Temos diversos padrões e designs de arquiteturas a adotar, no fim das contas implemente aquele que mais se encaixa com sua demanda.
Se você vai fazer uma API simples, com 2 models, 1 controller e um crud simples, talvez não faça sentido você aplicar essa complexidade. Mas é uma decisão e se tomar com o seu time de desenvolvimento.

Lembrando os benefícios que você aplicar conceitos como S.O.L.I.D e Repository pattern por exemplo.

O sistema ser agnóstico de banco de dados, você pode trocar o banco de dados com facilidade sem afetar o resto do código.
Código centralizado em um único ponto, evitando duplicidade.
Facilita a implementação de testes. Em caso de testes mais avançados, talvez você não consiga fazer sem adotar uma arquitetura mais organizada.
Diminui o acoplamento entre classes.
Padronização de códigos e serviços.
Facilita a reutilização de código.

Fique ligado no próximo artigo da série, onde vamos adicionar o padrão de UOW - Unity of Work para acesso ao banco de dados.

Confira os módulos anteriores

Modulo 1
Modulo 2

.ltag__user__id__729596 .follow-action-button { background-color: #000000 !important; color: #ffffff !important; border-color: #000000 !important; }

Matheus PaixãoFollow

Gosto de compartilhar conhecimento pois foi assim que eu aprendi a programar. O meu negócio é todo dia saber mais que eu sabia ontem. Pode me chamar, vamos aprender juntos. Prazer =)

C# - Criando API Login com Jwt Token - Autorização e Autenticação - Módulo 2

Matheus Paixão — Wed, 02 Mar 2022 17:04:54 +0000

Sejam bem vindos novamente marujos, bora continuar remando rumo à mais um módulo desse projeto incrível.

Código Módulo 2 -> Repositório GitHub

Nesse módulo irei abordar a evolução do projeto da API de Login com autorização através do JWT Token. Modulo 1

Migração de .net 5 para .net 6
Crud de Roles
O Sistema sempre tem 1 admin

Migrando .Net 5 para .Net 6

1 - No arquivo .csproj altere o `TargertFramework` para `net6.0` e dentro do mesmo `<PropertyGroup>` adicione `<Nullable>enable</Nullable>` e `<ImplicitUsings>enable</ImplicitUsings>` e o resultado deve ficar assim:

  <PropertyGroup>     
      <TargetFramework>net6.0</TargetFramework>
      <Nullable>enable</Nullable>
      <ImplicitUsings>enable</ImplicitUsings>     
  </PropertyGroup>

2 - Atualize os pacotes Nugets

3 - Migrando dados da Startup.cs para Program.cs

No .net 6 você não precisa mais dos métodos ConfigureServices() e do Configure(), você precisa apenas estanciar o WebApplication Builder na classe program para poder ter acesso aos métodos de configuração.

Então no nosso programa o método ConfigureServices() ficou assim:

IMPORTANTE: Mudei o JWTkey para o nosso secrets, para não deixar exposto a nossa chave de criptografia.

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddTransient<TokenService>();
builder.Services.AddDbContext<DataContext>();
builder.Services.AddControllers();


//JWTConfig 
var key = Encoding.ASCII.GetBytes(builder.Configuration["Key:JwtKey"].ToString());
builder.Services.AddAuthentication(x =>
{
    x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(x =>
{
    x.TokenValidationParameters = new TokenValidationParameters
    {
        ValidateIssuerSigningKey = true,
        ValidateAudience = false,
        IssuerSigningKey = new SymmetricSecurityKey(key),
        ValidateIssuer = false
    };
});

//Configuração do Swagger para adicionar o Bearer Token na auth
builder.Services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new OpenApiInfo { Title = "JWTAuthAuthentication2", Version = "v1" });
    c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme()
    {
        Name = "Authorization",
        Type = SecuritySchemeType.ApiKey,
        Scheme = "Bearer",
        BearerFormat = "JWT",
        In = ParameterLocation.Header,
        Description = "JWT Authorization header using the Bearer scheme",
    });
    c.AddSecurityRequirement(new OpenApiSecurityRequirement
                {
                    {
                          new OpenApiSecurityScheme
                          {
                              Reference = new OpenApiReference
                              {
                                  Type = ReferenceType.SecurityScheme,
                                  Id = "Bearer"
                              }
                          },
                         new string[] {}
                    }
                });
});

E o método Configure() vai ficar assim:

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
    app.UseSwagger();
    app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "JWTAuthAuthentication2 v1"));
}
app.UseHttpsRedirection();
app.UseRouting();

////JWTConfig - Adicionar sempre Authentication antes de Authorization
app.UseAuthentication();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
});
app.Run();

Repare que não fiz grandes alterações, só passei as configurações da startup para a classe Program.cs e agora você pode excluir a classe Startup.cs adotoando os padrões do .net 6

Crud de Roles

Create Read Update Delete - CRUD

Como vamos fazer um crud completo da entidade Roles, é de boa prática criar uma Controller só pra isso, separando as responsabilidades.

Nessa Controller só terá autorização quem tiver acesso de Admin.
Regas de negócio que aplicamos:

1 - Usuário não pode alterar sua própria role
2 - Precisa ter ao menos 1 usuário admin no banco de dados
3 - Não pode haver duas Roles com o mesmo nome

E assim ficou a RolesController

Post

    [HttpPost("AddRole")]
    public async Task<IActionResult> AddRole(RoleViewModel roleRequest,
                                             [FromServices] DataContext context)
    {
        if (!ModelState.IsValid) return BadRequest(ModelState);
        if (context.Roles.Any(x => x.Name.Equals(roleRequest.Name))) return BadRequest("Role duplicated");

        var roleModel = new Role
        {
            Name = roleRequest.Name,
        };

        await context.Roles.AddAsync(roleModel);
        await context.SaveChangesAsync();
        return Ok(roleModel);
    }

Patch Change User Role

    [HttpPatch("ChangeUserRole")]
    public async Task<IActionResult> ChangeUserRole(int UserId,
                                                    int NewRoleId,
                                                    [FromServices] DataContext context)
    {
        if(!ModelState.IsValid) return BadRequest(ModelState);

        //Consultas
        var userModel = await context
            .Users
            .FirstOrDefaultAsync(x => x.Id == UserId);

        var roleModel = await context
            .Roles
            .AsNoTracking()
            .FirstOrDefaultAsync(x => x.Id == NewRoleId);

        //Validações
        if (userModel == null || roleModel == null)
            return StatusCode(401, "Invalid Id");

        //Verificando quantos usuarios admins temos no sistema
        var userList = await context.Users.ToListAsync();
        int adminUsers = 0;
        foreach (var item in userList)
        {
            if (item.RolesId == 2) adminUsers++;
        }

        //Verificando se sobrará pelo menos 1 admin no sistema
        if (userModel.RolesId == 2 && adminUsers <= 1) return StatusCode(400, "You must have at least 1 admin user in the database");

        userModel.Roles = roleModel;

        //Admin não pode mudar sua própria role
        if (User.Claims.First(x => x.Type == ClaimTypes.NameIdentifier).Value.Equals(userModel.Id.ToString())) return StatusCode(400, "You cannot change your own role");


        await context.SaveChangesAsync();
        return Ok(userModel.Name + " Role changed to " + roleModel.Name);
    }

Get Mostrar todos os Roles

[HttpGet("GetRoles")]
    public async Task<IEnumerable<Role>> GetRoles([FromServices] DataContext context)
    {
        return await context.Roles.ToListAsync();
    }

Patch Edit Role

    [HttpPatch("EditRole")]
    public async Task<IActionResult> EditRole([FromServices] DataContext context,
                                                              Role roleRequest)
    {
        if(!ModelState.IsValid) return BadRequest(ModelState);

        var roleModel = await context.Roles.AsNoTracking().FirstOrDefaultAsync(x => x.Id == roleRequest.Id);

        //Validações
        if (roleModel == null) return NotFound("Role not found");
        if (context.Roles.Any(x => x.Name.Equals(roleRequest.Name))) return BadRequest("Role duplicated");


        context.Roles.Update(roleRequest);
        await context.SaveChangesAsync(); 
        return Ok(roleRequest);        
    }

Delete Roles

[HttpDelete("DeleteRoles")]
    public async Task<IActionResult> DeleteRoles(int roleId,
                                                [FromServices] DataContext context)
    {
        if(!ModelState.IsValid) return BadRequest(ModelState);

        var roleModel = await context.Roles.FirstOrDefaultAsync(x => x.Id == roleId);

        //Validações
        if (roleModel == null) return NotFound("Role not found");
        if (roleModel.Name.Contains("admin")) return BadRequest("Cannot delete admin role");

        context.Roles.Remove(roleModel);
        await context.SaveChangesAsync();
        return Ok("Role " + roleModel.Name + " Deleted");
    }

O código está inteiro comentado e separei os blocos por #region para facilitar leitura e busca dos métodos.

Qualquer dúvida, é só comentar ou entrar em contato comigo.

No proximo módulo eu adicionarei:

CRUD de Usuários
introdução do Repository Pattern
Divisão em 3 Projetos (Infra - Domain - API) Obrigado por lerem mais um módulo da série dessa API.

Matheus PaixãoFollow

Gosto de compartilhar conhecimento pois foi assim que eu aprendi a programar. O meu negócio é todo dia saber mais que eu sabia ontem. Pode me chamar, vamos aprender juntos. Prazer =)

C# - Criando API com Jwt Token - Autorização e Autenticação - Módulo 1

Matheus Paixão — Mon, 07 Feb 2022 17:10:27 +0000

Código Módulo 1 -> Repositório GitHub

Olá Devs, este artigo vai mostrar de forma simples como criar um API de autenticação e autorização de API's através de JWT Token e definindo Roles(cargos) pra cada usuário do sistema.

Sumário - Clique e ache rápido o que deseja ler

Regra de Negócio e Contextualização
Banco de dados Postgres
Criando API Básica com JWT - Models
Configuração do JWT
Controller Auth
Criptografia da senha de usuário
Configuração Startup
Populando o Banco de Dados
Teste com Swagger

Regra de Negócio

`Modulo 1`

Nesse primeiro módulo, iremos focar na aplicação pura do JWT Token com Roles. Nos próximos módulos teremos os CRUDs completos e complementos de funcionalidades.

O usuário Admin é cadastrado na mão, no banco de dados e ele é o único que tem o poder de mudar as Roles dos usuários.
As roles são cadastradas direto no banco de dados também.
O sistema cadastra um usuário.
O sistema faz Login do usuário.

Importância do Controle de Acesso

Imagina que você tem um sistema que vários usuários com cargos diferentes e você quer que cada cargo tenha um tipo de acesso diferente. Exemplo: O Assistente Financeiro terá acesso a relatórios da área de finanças, mas, apenas o Diretor financeiro terá acesso a liberar verbas, aumentar e diminuir budgets (despesas) de cada departamento.

Para que você consiga fazer esse controle por tipo de usuário, uma solução pode ser definir Roles.

Roles

No nosso caso, no Modulo 1, teremos 2 tipos de usuários: Admin e o User.

Admin - Acesso a todos os endpoints
User - Acesso ao endpoint de registro de usuários e o de login de usuários

Qual a diferença entre Autenticação e Autorização?

Autenticação é o processo de ver quem você é, qual seu nome, senha, email, você realmente é quem você diz ser? Isso é AUTENTICAR
Autorização é o processo de verificar aonde você tem permissão de acessar. Quais endpoints você terá acesso. Isso é AUTORIZAR

Exemplo: Você chega numa balada e logo na entrada precisa ser Autenticado, eles verificaram seu nome, seu cartão de crédito e vão verificar pelo seu nome aonde você tem Autorização de entrar se você vai apenas na pista é uma pulseira, se pode ir na pista e no camarote, já é outra pulseira. No programação essa pulseira de identificação seria o seu Token, contendo suas informações básicas e suas Claims, que seriam as autorizações que você tem, compactadas naquela pulseira (token).

Criando uma API básica usando o processo de autenticação COM JWT token

Models e View Models

`Role`



public class Role
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

`User`



public class User
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
        public string PasswordHash { get; set; }
        public string Slug { get; set; }
        public int RolesId { get; set; }
        public Role Roles { get; set; }
    }

`LoginViewModel`



public class LoginViewModel
    {
        [Required(ErrorMessage = "Name is required")]
        public string Name { get; set; }

        [Required(ErrorMessage = "Email is required")]
        [EmailAddress(ErrorMessage = "Email must be valid")]
        public string Email { get; set; }
        [Required(ErrorMessage = "Password is required")]
        public string Password { get; set; }
    }

`RegisterViewModel`



public class RegisterViewModel
    {
        [Required(ErrorMessage = "Name is required")]
        public string Name { get; set; }

        [Required(ErrorMessage = "Email is required")]
        [EmailAddress(ErrorMessage = "Email must be valid")]
        public string Email { get; set; }
        [Required(ErrorMessage = "Password is required")]
        public string Password { get; set; }
    }

Banco de Dados - Postgres

`Mapeamentos`

`UserMap`



public class UserMap : IEntityTypeConfiguration<User>
    {
        public void Configure(EntityTypeBuilder<User> builder)
        {
            // Tabela
            builder.ToTable("User");

            // Chave Primária
            builder.HasKey(x => x.Id);

            // Identity
            builder.Property(x => x.Id)
                .ValueGeneratedOnAdd()
                .UseIdentityColumn();

            // Propriedades
            builder.Property(x => x.Name)
                .IsRequired()
                .HasColumnName("Name")
                .HasColumnType("VARCHAR")
                .HasMaxLength(80);

            builder.Property(x => x.Email)
                .IsRequired()
                .HasColumnName("Email")
                .HasColumnType("VARCHAR")
                .HasMaxLength(160);

            builder.Property(x => x.PasswordHash).IsRequired()
                .HasColumnName("PasswordHash")
                .HasColumnType("VARCHAR")
                .HasMaxLength(255);

            builder.Property(x => x.Slug)
                .IsRequired()
                .HasColumnName("Slug")
                .HasColumnType("VARCHAR")
                .HasMaxLength(80);              


            // Índices
            builder
                .HasIndex(x => x.Slug, "IX_User_Slug")
                .IsUnique();            
        }
    }

`RolesMap`



public class RolesMap : IEntityTypeConfiguration<Role>
    {
        public void Configure(EntityTypeBuilder<Role> builder)
        {
            builder.ToTable("Role");

            builder.HasKey(x => x.Id);

            builder.Property(x => x.Id)
                .ValueGeneratedOnAdd()
                .UseIdentityColumn();

            builder.Property(x => x.Name)
                .HasMaxLength(128)
                .HasColumnType("VARCHAR")
                .HasColumnName("Name");

        }
    }

`Startup.cs`



public void ConfigureServices(IServiceCollection services)
        {
...
            //DBContext
            services.AddDbContext<DataContext>();
...
...
        }

`DataContext`



public class DataContext : DbContext
    {
        public DbSet<User> Users { get; set; }
        public DbSet<Role> Roles { get; set; }

        private IConfiguration configuration;

        public DataContext(IConfiguration _configuration)
        {
            configuration = _configuration;
        }
        protected override void OnConfiguring(DbContextOptionsBuilder options)
            => options.UseNpgsql(configuration["ConnectionString:Postgres"].ToString());

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.ApplyConfiguration(new UserMap());
            modelBuilder.ApplyConfiguration(new RolesMap());
        }
    }

`ConnectionString - secrets.json`



{
  "ConnectionString:Postgres": "Host=localhost;Database=Teste;Username=seu username;Password=sua senha"
}

Token de Assinatura

`Configuration.cs`

A chave de assinatura ou JWTKey é no nosso caso um GUID que colocamos dentro da



public static class Configuration
    {
        //Token
        public static string JwtKey { get; set; } = "12345678-1234-1234-1234-123456789123";
    }

O segredo por trás de tudo

`TokenService.cs`

Bibliotecas usadas



using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;



public string GenerateToken (User user)
        {
            //Estancia do manipulador de Token
            var tokenHandler = new JwtSecurityTokenHandler();
            //Chave da classe Configuration. O Token Handler espera um Array de Bytes, por isso é necessário converter
            var key = Encoding.ASCII.GetBytes(Configuration.JwtKey);
            //
            var claims = user.GetClaims();
            var tokenDescriptor = new SecurityTokenDescriptor
            {
                Subject = new ClaimsIdentity(claims), //Claims que vão compor o token
                Expires = DateTime.UtcNow.AddHours(8), //Por quanto tempo vai valer o token?
                SigningCredentials = //Assinatura do token, serve para identificar que mandou o token e garantir que o token não foi alterado no meio do caminho.
                new SigningCredentials(
                    new SymmetricSecurityKey(key),
                    SecurityAlgorithms.HmacSha256Signature)
            };

            //Gerando o token
            var token = tokenHandler.CreateToken(tokenDescriptor);
            //Retornando tudo como uma string
            return tokenHandler.WriteToken(token);
        }

tokenHandle - Chave da classe Configuration. O Token Handler espera um Array de Bytes, por isso é necessário converter
key - JWTKey em formato byte
claims - Resultado do método GetClaims() que gera as Claims que vão copor o token
tokenDescriptor = new SecurityTokenDescriptor{} - Montando o token com todos seus parâmetros.

Há mais comentários detalhando cada linha do código no próprio código.

`GetClaims()`

Método que adiciona dentro de uma lista todas as informações que você quer export do usuário no Jwt token através da Claim.



public static class RoleClaimExtention
    {
        public static IEnumerable<Claim> GetClaims(this User user)
        {
            var result = new List<Claim>
            {
                new(ClaimTypes.Name, user.Name),
                new(ClaimTypes.Email, user.Email),
                new(ClaimTypes.Role, user.Roles.Name)
            };
            return result;
        }
    }

Controller

`Bibliotecas`



using SecureIdentity.Password;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.Threading.Tasks;

Endpoints -

Post Register - Rota - api/auth/v1/register Registra uma nova conta de usuário no banco de dados
Post Login - Rota- api/auth/v1/login Autoriza o usuário através da validação das credenciais, e gera um JWT Token
Patch ChangeRole - Rota- api/auth/v1/changeUserRole Altera a Role do usuário no banco de dados

`Classe da Controller`



    [Authorize]
    [Route("api/auth")]
    [ApiController]
    public class AuthController : ControllerBase

EndPoint `Register`



        [AllowAnonymous]
        [HttpPost("v1/register")]
        public async Task<IActionResult> Register([FromBody] RegisterViewModel model,
                                              [FromServices] DataContext context)
        {
            if (!ModelState.IsValid) return BadRequest(ModelState);

            var user = new User
            {
                Name = model.Name,
                Email = model.Email,
                Slug = model.Email.Replace("@", "-").Replace(".", "-"),
                RolesId = 1,
                PasswordHash = PasswordHasher.Hash(model.Password),
            };

            try
            {
                await context.Users.AddAsync(user);
                await context.SaveChangesAsync();

                return Ok($"{user.Email} {user.PasswordHash}");
            }
            catch (DbUpdateException)
            {
                return StatusCode(400, "Duplicate Email");
            }
            catch
            {
                return StatusCode(500, "Internal Error");
            }
        }

Criptografia da senha do usuário

Usamos a classe PasswordHasher da biblioteca SecureIdentity para criptografar a senha digitada pelo usuário e salvar no banco esse senha criptografada. PasswordHash = PasswordHasher.Hash(model.Password) O que é Hash?

Para segurança do usuário nunca salvar a senha do usuário sem criptografia no banco de dados.

Na hora de fazer a autenticação, e verificar a senha, é necessário discriptografar a senha do banco de dados e comparar com a senha que o usuário digitou.
PasswordHasher.Verify(Senha do banco de dados, Senha digitada pelo usuário)

EndPoint `Login`



        [AllowAnonymous]
        [HttpPost("v1/login")]
        public async Task<IActionResult> Login(
       [FromBody] LoginViewModel model,
       [FromServices] DataContext context,
       [FromServices] TokenService tokenService)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState.Values);

            var user = await context
                .Users
                .Include(x => x.Roles)
                .AsNoTracking()
                .FirstOrDefaultAsync(x => x.Email == model.Email);

            if (user == null)
                return StatusCode(401, "User or password invalid");

            if (!PasswordHasher.Verify(user.PasswordHash, model.Password))
                return StatusCode(401, "User or password invalid");

            try
            {
                var token = tokenService.GenerateToken(user);
                return Ok(token);
            }
            catch
            {
                return StatusCode(500, "Internal Error");
            }
        }

EndPoint `changeUserRole`



        [Authorize(Roles = "admin")]
        [HttpPatch("v1/changeUserRole")]
        public async Task<IActionResult> ChangeRole(int UserId,
                                                    int NewRoleId,
                                                    [FromServices] DataContext context)
        {
            var user = await context
                .Users
                .FirstOrDefaultAsync(x => x.Id == UserId);

            var role = await context
                .Roles
                .AsNoTracking()
                .FirstOrDefaultAsync(x => x.Id == NewRoleId);

            if (user == null || role == null)
                return StatusCode(401, "Invalid Id");

            user.Roles = role;

            await context.SaveChangesAsync();
            return Ok();
        }

[Authorize] - Data Notation que limita o acesso apenas para quem está autorizado/Logado apenas.
[AllowAnonymous] - Data Notation que permite acesso de usuários que não estão autorizados/logados na API.
[Authorize(Roles = "admin")] - Data Notation que permite acesso de usuários que contem a role admin em seu Claim

Configuração da Startup



public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services)
        {
            //DBContext
            services.AddDbContext<DataContext>();

            //JWTConfig
            var key = Encoding.ASCII.GetBytes(JwtKey);
            services.AddAuthentication(x =>
                {
                    x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
                    x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
                }).AddJwtBearer(x =>
                {
                    x.TokenValidationParameters = new TokenValidationParameters
                    {
                        ValidateIssuerSigningKey = true,
                        ValidateAudience = false,
                        IssuerSigningKey = new SymmetricSecurityKey(key),
                        ValidateIssuer = false
                    };                    
                });
            //Injeção de Dependencia
            services.AddTransient<TokenService>();

            services.AddControllers();

            //Configuração do Swagger para adicionar o Bearer Token na auth
            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new OpenApiInfo { Title = "JWTAuthAuthentication", Version = "v1" });
                c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme()
                 {
                     Name = "Authorization",
                     Type = SecuritySchemeType.ApiKey,
                     Scheme = "Bearer",
                     BearerFormat = "JWT",
                     In = ParameterLocation.Header,
                     Description = "JWT Authorization header using the Bearer scheme",
                 });
                c.AddSecurityRequirement(new OpenApiSecurityRequirement
                {
                    {
                          new OpenApiSecurityScheme
                          {
                              Reference = new OpenApiReference
                              {
                                  Type = ReferenceType.SecurityScheme,
                                  Id = "Bearer"
                              }
                          },
                         new string[] {}
                    }
                }); 
            });
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
                app.UseSwagger();
                app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "JWTAuthAuthentication v1"));

            }

            app.UseHttpsRedirection();

            app.UseRouting();

            ////JWTConfig - Adicionar sempre Authentication antes de Authorization
            app.UseAuthentication();
            app.UseAuthorization();


            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }
    }

Populando o Banco de dados

Da forma que achar melhor, através de GUIs como PgAdmin ou console, popúle a tabela de Role como na imagem abaixo, pois ainda não criaram um endpoint para isso.

E na tabela User crie um usuário com a role de Admin, pois ele será o ínico que terá acesso ao endpoint changeRoles.

Teste com Swagger

`Register`

`Login`

Antes de seguirmos com a validação do token, tente alterar as roles no endpoint changeRoles e repare que o retorno é 401, não autorizado.

O retorno que temos do login é o JTW token com as claims que definimos do token service. Para se autorizar, pegue esse Token e se tudo deu certo na configuração do Swagger, você deve ver um ícone no lado direito superior da pagina do Swagger:

Clique nele e insira o token nesse formado Bearer + Token, como na imagem abaixo.

Porém, mesmo assim você não terá acesso ao endpoint changeRoles, pois quando você cria um usuário, o role dele não é de admin.

Faça o login com o usuário Admin que criou no banco de dados.

Insira o Bearer Token e altere a role do usuário que acabou de criar.

E veja que o resultado é 200, sucesso.

Para verificar o JWT token e suas claims, acesse o site Jwt.io e cole o token no quadro de Encoded.

Repare o payload do token tem o nome, email, a role e os timestamps de quando foi gerando e até quando dura o token.

Obrigado por ler este artigo. Abaixo colocarei os links dos próximos módulos quando forem lançados, a ideia é evolouirmos pouco a pouco essa aplicação.

Spoiler

Modulo 2

CRUD da Roles
O sistema tem sempre que ter um Admin
Admin não pode mudar suas próprias roles
E muito mais.

Matheus PaixãoFollow

Gosto de compartilhar conhecimento pois foi assim que eu aprendi a programar. O meu negócio é todo dia saber mais que eu sabia ontem. Pode me chamar, vamos aprender juntos. Prazer =)

How to use Postgres SQL, NoSql and Entity Framework Core

Matheus Paixão — Wed, 15 Dec 2021 21:14:16 +0000

Hello. I'll show you step by step how to work with relational and non-relational database at the same time with Postgres and support for EFCore.

Postgres

Postgres is an object-relational database owned by Oracle company, however it is an open source database with a strong community backing it. Postgres is incredibly robust and reliable, given its 30-year history in the market.

Data Types

Primitives: Integer, Numeric, String, Boolean
Structured: Date/Time, Array, Range / Multirange, UUID
Document: JSON/JSONB, XML, Key-value (Hstore)
Geometry: Point, Line, Circle, Polygon
Customizations: Composite, Custom Types

JSON/JSONB - Working with NSql

One of the wonders of the Postgres database is the possibility of working in a relational and non-relational way in the same database, in the same object, in the same table. YEA ! It is possible, through the Document data type that receives Json and JsonBinary (JsonB) data.

Entity FrameWork Core ORM

In order to be able to use EFcore in our methods using NSql, we need to install a nuget package called npgsql.entityframeworkcore.postgresql which will allow us to make the CRUD methods more similar to the EFCore ORM we are used to.

Prática - Config

Pacotes

npgsql.entityframeworkcore.postgresql Microsoft.EntityFrameworkCore Microsoft.EntityFrameworkCore.Design Microsoft.EntityFrameworkCore.Toll EFCore.NamingConventions

StartUp

ConfigureServices Method



            services.AddDbContext<PostgresNsql.MyContext>(option => option.UseNpgsql(Configuration.GetConnectionString("Nsql")));

DBContext



public class MyContext : DbContext
    {
        public MyContext(DbContextOptions options) :base(options)
        {

        }
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
            => optionsBuilder
            .UseNpgsql()
            .UseSnakeCaseNamingConvention();

        protected override void OnModelCreating(ModelBuilder modelBuilder)
            => modelBuilder
            .Entity<DataModel>()
            .Property(e => e.Id)
            .UseIdentityAlwaysColumn();

        public DbSet<DataModel> DataModels { get; set; }
    }

UseSnakeCaseNamingConvention() Snake Case may be needed to handle JSONs that separate 2 words with _ underscore. That way you won't have problems with serialization.

Setting auto-increment for ID column
.Property(e => e.Id) .UseIdentityAlwaysColumn(); Identity always column is one of the types of value assignment you can give, in this mode you define that the values will be generated directly in the database, making it impossible for you to set the value at the time of insertion into the database.

Model

In creating the model is the big leap in using SQL and NSql together. If you have unstable data yet and it's not 100% mappable and structured, you can use DataType Json to get the NSql part of your data.

For that, you need to add the System.Text.Json library and type its property with the JsonDocument class, as it will already identify that data will be received there in JSON and will facilitate de-cerealization.

The model needs to be IDisposable as the JsonDocument class is IDisposable too, improving memory management.



public class DataModel : IDisposable
    {
        public int Id { get; set; }
        public string Nome { get; set; }
        public int idade { get; set; }

        public JsonDocument Data { get; set; }

        public void Dispose() => Data?.Dispose();
    }

Estructured Data

To identify the NSql part of our model, we need to add the Data Notation [Column(TypeName = "jsonb")] to identify the Json object and map the properties.



public class DataModel
    {
        public int Id { get; set; }
        public string Nome { get; set; }
        public int idade { get; set; }

        [Column(TypeName = "jsonb")]
        public Endereco Address { get; set; }
    }

public class Endereco // Mapping the JSON Data received
{
    public string Rua { get; set; }
    public int Numero { get; set; }
    public Casa[] Casas { get; set; }
}

public class Casa 
{
    public decimal Preco { get; set; }
    public string EnderecoCompleto { get; set; }
}

CRUD

I didn't use a repository or some more complex architecture to make the article easier to understand.

But I will now show in Controller how we can work with JSON type data.

GetAll()

Note that nothing changes in the listing of all columns.



public List<DataModel> GetAll()
        {
            return _myContext.DataModels.ToList();
        }

GetCustom

A question I had when starting to work with Postgres SQL and NSql together is whether it could be done in a query, joining the SQL and NSql data. Below is an example of a Get where I parameterize that I only want results from 12 year olds AND with the last name equal to "Paixao". Age is an SQL value from the age column and "lastname" is an item of the data we receive in JSON.



public IEnumerable<string> Get()
        {
            var resultado = _myContext.DataModels;

            return resultado.Where(x => x.idade == 12 && x.Data.RootElement.GetProperty("lastName").GetString() == "Paixao").ToList();           
        }

Another example I brought is if you want to display only 1 of the data items in JSON.



public IEnumerable<string> Get()
        {
            var resultado = _myContext.DataModels;

return resultado.Select(x=>x.Data.RootElement.GetProperty("lastName").GetString()).ToList();
        }

Elements of the JsonElement class from the above code

RootElement is a class that will get the JSON data from the Data property allowing you to then name with the GetProperty("property") method which JSON property you will work with and finally you must put the GetString method () to convert the JSON data you filtered to string.

Thank you

Matheus PaixãoFollow

Gosto de compartilhar conhecimento pois foi assim que eu aprendi a programar. O meu negócio é todo dia saber mais que eu sabia ontem. Pode me chamar, vamos aprender juntos. Prazer =)

Como trabalhar com Postgres SQL e NOSql juntos com Entity Framework Core?

Matheus Paixão — Tue, 14 Dec 2021 03:38:39 +0000

This topic in English

Olá. Vou mostrar um passo a passo de como trabalhar com banco de dado relacional e não relacional ao mesmo tempo com Postgres e suporte para EFCore.

Postgres

Postgres é uma banco de dados objeto-relational que pertence a empresa Oracle, porém é um banco de dados open source com uma forte comunidade mantendo-o. Postgres é incrivelmente robusto e confiável, dado seu histórico de 30 anos no mercado.

Data Types

JSON/JSONB - Trabalhando com NSql

Uma das maravilhas do banco de Postgres é a possibilidade de trabalhar de forma relacional e não relacional no mesmo banco, no mesmo objeto, na mesma tabela. SIM ! É possível, através do tipo de dado Document, que recebe dados Json e JsonBinary (JsonB).

Entity FrameWork Core ORM

Para podermos usar o EFcore nos nossos métodos usando o NSql, precisamos instalar um pacote nuget chamado npgsql.entityframeworkcore.postgresql ele vai permitir fazer os métodos CRUD de forma mais parecida com o EFCore ORM que estamos acostumados.

Prática - Configuração

Pacotes

npgsql.entityframeworkcore.postgresql Microsoft.EntityFrameworkCore Microsoft.EntityFrameworkCore.Design Microsoft.EntityFrameworkCore.Toll EFCore.NamingConventions

StartUp

ConfigureServices Method

            services.AddDbContext<PostgresNsql.MyContext>(option => option.UseNpgsql(Configuration.GetConnectionString("Nsql")));

DBContext

public class MyContext : DbContext
    {
        public MyContext(DbContextOptions options) :base(options)
        {

        }
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
            => optionsBuilder
            .UseNpgsql()
            .UseSnakeCaseNamingConvention();

        protected override void OnModelCreating(ModelBuilder modelBuilder)
            => modelBuilder
            .Entity<DataModel>()
            .Property(e => e.Id)
            .UseIdentityAlwaysColumn();

        public DbSet<DataModel> DataModels { get; set; }
    }

UseSnakeCaseNamingConvention() Snake Case pode ser necessário para lidar com JSONs que separam 2 palavras com _ underline. Dessa forma não tera problemas com serialização.

Definindo auto-increment na coluna ID
.Property(e => e.Id) .UseIdentityAlwaysColumn(); Identity always column é um dos tipos de atribuição de valor que você pode dar, nessa modalidade você define que os valores serão gerados diretamente no banco, impossibilitando você setar o valor no momento de inserção no banco de dados.

Model

Na criação da model é que está o grande pulo do gato no uso de SQL e NSql juntos. Caso você tenha dados instáveis ainda e eles não são 100% mapeaveis e estruturados, você pode usar o DataType Json para receber a parte NSql dos seus dados.

Para isso, você precisa adicionar a biblioteca System.Text.Json e tipar a sua propriedade com a classe JsonDocument, pois ele já identificará que ali será recebido dados em JSON e facilitará a descerialização.

A model precisa ser IDisposable pois a classe JsonDocument é IDisposable também, melhorando o gerenciamento de memória.

public class DataModel : IDisposable
    {
        public int Id { get; set; }
        public string Nome { get; set; }
        public int idade { get; set; }

        public JsonDocument Data { get; set; }

        public void Dispose() => Data?.Dispose();
    }

Dados Estruturados

Para identificar a parte NSql da nossa model, é preciso adicionar a Data Notation [Column(TypeName = "jsonb")] para identificar o objeto Json e mapear as propriedades.

public class DataModel
    {
        public int Id { get; set; }
        public string Nome { get; set; }
        public int idade { get; set; }

        [Column(TypeName = "jsonb")]
        public Endereco Address { get; set; }
    }

public class Endereco // Mapeando os dados recebidos em Json
{
    public string Rua { get; set; }
    public int Numero { get; set; }
    public Casa[] Casas { get; set; }
}

public class Casa 
{
    public decimal Preco { get; set; }
    public string EnderecoCompleto { get; set; }
}

CRUD

Eu não usei um repositório ou alguma arquitetura mais complexa para facilitar o entendimento do artigo.

Mas mostrarei agora na Controller como podemos trabalhar com os dados do tipo JSON.

GetAll()

Percebam que nada muda na listagem de todas as colunas.

public List<DataModel> GetAll()
        {
            return _myContext.DataModels.ToList();
        }

GetPersonalidado

Uma dúvida que tinha quando começando a trabalhar com Postgres SQL e NSql junto é se dava pra fazer em uma consulta, juntar os dados SQL e NSql. Abaixo está um exemplo de um Get onde eu parametrizo que quero apenas resultados de pessoas com 12 anos E com o ultimo nome igual a "Paixao". Idade é um valor SQL da coluna idade e "lastname" é um item dos dados que recebemos em JSON.

public IEnumerable<string> Get()
        {
            var resultado = _myContext.DataModels;

            return resultado.Where(x => x.idade == 12 && x.Data.RootElement.GetProperty("lastName").GetString() == "Paixao").ToList();           
        }

Um outro exemplo que trouxe, é caso você quero exibir apenas 1 dos itens dos dados em JSON.

public IEnumerable<string> Get()
        {
            var resultado = _myContext.DataModels;

return resultado.Select(x=>x.Data.RootElement.GetProperty("lastName").GetString()).ToList();
        }

Elementos da classe JsonElement do código apresentado acima

RootElement é uma classe que vai pegar os dados JSON da propriedade Data permitindo que você então denomine com o método GetProperty("propriedade") qual propriedade do JSON você vai trabalhar e por final você deve colocar o método GetString() para converter o dados JSON que você filtrou em string.

Obrigado

.ltag__user__id__729596 .follow-action-button { background-color: #000000 !important; color: #ffffff !important; border-color: #000000 !important; }

Matheus PaixãoFollow

Gosto de compartilhar conhecimento pois foi assim que eu aprendi a programar. O meu negócio é todo dia saber mais que eu sabia ontem. Pode me chamar, vamos aprender juntos. Prazer =)

Disclaimer

A VaiVoa incentiva seus Desenvolvedores em seu processo de crescimento e aceleração técnica. Os artigos publicados não traduzem a opinião da VaiVoa. A publicação obedece ao propósito de estimular o debate.

How to map Nested Object mappings with AutoMapper C#

Matheus Paixão — Mon, 29 Nov 2021 19:50:55 +0000

So let me start by saying that I decided to share this content because I just couldn't find the perfect answer on internet, it took me half a day to figure this out.

As a good practice, we are using the RequestDTO and a ResponseDTO, so we don't return the same model we receive.

RequestDTO

    public class Attributes
    {
        public string type { get; set; }
        public string url { get; set; }
    }

    public class Keep
    {
        public Attributes attributes { get; set; }
        public DateTime LastModifiedDate { get; set; }
        public string Email { get; set; }            
    }

    public class Discart
    {
        public Attributes attributes { get; set; }
        public DateTime LastModifiedDate { get; set; }
        public string Email { get; set; }

    }

    public class Root
    {            
        public List<DataWeNeed> Keep { get; set; }
        public List<DataWeDontNeed> Discart { get; set; }
        public string userId { get; set; }
    }
}

ResponseDTO

    public class Attributes
    {
        public string type { get; set; }
        public string url { get; set; }
    }

    public class ResponseKeep
    {
        public Attributes attributes { get; set; }
        public DateTime LastModifiedDate { get; set; }
        public string Email { get; set; }            
    }

AutoMapper Basic Configuration Startup.cs



 public void ConfigureServices(IServiceCollection services)
        {            
            services.AddAutoMapper(typeof(Startup));
        }

Controller



public class Controller : ControllerBase
    {
//AutoMapper Dependency Injection
        private readonly IMapper _map;

        public ValuesController(IMapper map)
        {
            _map = map;
        }

        [HttpPost]
        [Route("api")]
        public Keep Post(Object value)
        {            
//Deserialize de Json request into our Object
            Root deserialized = JsonConvert.DeserializeObject<Root>(value.ToString());

//Mapping the first item of the Keep List into the responseDto
            var responseDTO = _map.Map<ResponseDTO>(deserealized.Keep.FirstOrDefault());

            return responseDTO;
        }
    }

Mapping Profile

Here is where the magic happens.

To make sure the the automapper does the right mapping and doesn't returns an exception we must resolve the mapping in details.
How?

As we have different Objects, we need to tell automapper which objects and fields are mapped and from where, using the method ForMember and MapFrom.

See that the main Object the automapper does automatically without mapping the fields, but, when it comes to the Object Value Attributes I had to map one by one so it would understand where the information is sourced and where the information the designated.



public AutoMapper()
        {
            CreateMap<RequestDTO.Attributes, ResponseDTO.Attributes>()
                .ForMember(
                    dest => dest.type,
                    opt => opt.MapFrom(src => src.type)
                )
                .ForMember(
                    dest => dest.url,
                    opt => opt.MapFrom(src => src.url)
                );
            CreateMap<Keep, ResponseKeep>()
                .ForMember(
                dest => dest.attributes,
                opt => opt.MapFrom(src => src.attributes));
        }

That's the solution I found to solve my issue, If you have another solution, specially that doesn't involve mapping field by field.

Obrigado

Matheus PaixãoFollow

Gosto de compartilhar conhecimento pois foi assim que eu aprendi a programar. O meu negócio é todo dia saber mais que eu sabia ontem. Pode me chamar, vamos aprender juntos. Prazer =)

Criando uma Web API com .NET Core, EntityFramework Core - Número Cartão de Crédito Aleatório

Matheus Paixão — Mon, 18 Oct 2021 21:07:29 +0000

Este projeto irá te guiar no Passo a Passo de como criar uma Web API aplicando os conceitos REST em .NET Core, usando Entity Framework.

Pré-requisitos:

Visual Studio 2019 com pacotes de ASP.NET e desenvolvimento web instalados
.NET Core 3.1
Postman

O Projeto:

Desenvolver uma aplicação Web API com .NET Core, EntityFramework Core usando arquitetura REST.

A API deverá gerar números aleatórios para o pedido de um novo cartão de crédito virtual. Cada cartão gerado deve estar associado a um email para identificar a pessoa que está utilizando.

EndPoints

GET
Listar todos os números de cartão de crédito indexados a um email fornecido em forma de parâmetro pelo cliente.

POST
Cadastrar email

Gerar Número de cartão de crédito aleatório.

Indexar email criado a Número de cartão gerado.

Mostrar número de cartão gerado ao final da operação.

Relacionamentos

É de extrema importância entender e modelar o projeto em questão antes de avançar para os códigos.

Esse projeto pode ser feito com apenas uma classe, uma tabela de dados, pois são apenas 2 informações coletadas e o relacionamento exigido permite isso.

Classe: ClienteDados

Atributos

int Id
string Email
string CardNumber

A chave primária dessa classe é o ID, pois será uma forma de indexar o e-mail a seu respectivo cartão de crédito e também porque o atributo Email não poderia ser chave primária pois chave primária não pode ser repetir e podemos ter vários emails iguais.

Podemos 1 email com vários cartões de crédito (Email 1 para * muitos Cartões de crédito), porém podemos ter apenas 1 email por cartão de crédito, esse é o relacionamento de dados entre os atributos.

Agora que compreendemos o que o projeto pede, mãos à obra.

Digite o nome do projeto e clique em Proximo.

Em informações adicionais selecione “.NET Core 3.1 (suporte de longo prazo)” e clique em Criar.

Instalar pacotes de NuGet

Para instalar o suporte EF Core a um projeto, vá em Gerenciar Pacotes de NuGet para a Solução, para instalar os pacotes necessários para esta API.

Os pacotes a serem instalados são:
Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.InMemory
Microsoft.EntityFrameworkCore.Design
Microsoft.EntityFrameworkCore.SqlServer

Para instalar, digite o nome do pacote em Procurar, selecione o pacote, selecione o nome do seu projeto e clique em instalar.

Criar Models e Classes

O projeto vem com uma classe e um Controller de exemplos, os WeatherForecast.cs. Exclua esses dois arquivos pois não vamos usá-los.

Agora vamos criar nosso Modelo e nossa Classe ClienteDados.

Criar uma pasta chamada Models, clicando com o botão direito no nome do projeto clique em Adicionar > Pasta. Nomear de Models. Models é onde armazenamos nossas classes.

Dentro da pasta Models criar uma Class chamada ClienteDados. Clicando com o botão direito na pasta Models e depois clique em Adicionar > Classe. Nomear ClienteDados e criar.

Agora declare os atributos que usaremos neste projeto.

namespace APICartaoDeCredito.Models
{
    public class ClienteDados
    {
        public int Id {get; set;}
        public string Email {get; set;}
        public string CardNumber {get; set;}
    }   
}

Construir o contexto de Banco de Dados

Criar a pasta de banco de dados chamada DataBase e dentro dessa parte criar a nossa classe de contexto a ApiContext.cs. Essa classe é a responsável principal pela comunicação com a Entity Framework Core

Dentro dessa classe, vamos criar o nosso InMemory Data Base, que será nosso banco de dados em memória.

Carregue os pacotes que usaremos nessa classe.
using Microsoft.EntityFrameworkCore;
using ApiCartaoDeCredito.Models;

Olhando o Código pronto abaixo, temos ClientesDb que será nossa propriedade DbSet de acesso ao banco de dados.

Dentro da classe ApiContex seria onde podemos definir regras de relacionamento, definir quem é chave primária entre outras coisas relacionadas a Banco de Dados, mas não será necessário nesse projeto.

public class ApiContex : DbContext

    {
        public ApiContex(DbContextOptions<ApiContex> options) : base(options)
        {

        }
        public DbSet<ClienteDados> ClientesDb { get; set; }
    }
}

Criar registro do ApiContex

No projeto tem uma classe que foi criada com a criação do projeto que precisamos registrar o banco de dados que criamos. Abra a classe Startup.cs e procure o método ConfigureServices() e adicione essa linha de código.

public void ConfigureServices(IServiceCollection services)
        {
            services.AddDbContext<ApiContex>(opt =>
            opt.UseInMemoryDatabase("ClienteDb"));

            services.AddControllers();
        }

Criar Controllers

Clicar com botão direito na pasta Controllers > Adicionar > Novo Item Scaffold. Na janela que abrir selecione Controlador API com ações, usando o Entity Framework, depois clique em Adicionar.

Na janela que abrir, temos que escolher para qual classe estamos criando nossa Controller. Selecione ClienteDados. Logo abaixo tem a opção da classe de contexto de dados, que é a classe ApiContext, que criamos para ser nossa classe de controle do banco de dados.
Escolher o nome do Controller, mas de default Visual Studio já nos fornece o nome apropriado.
Agora clique em Adicionar.

Usar o Scaffold para criar os Controllers, nos dá o benefício de que eles já criam automaticamente os métodos REST, que são os vistos na imagem abaixo. GET PUT POST e DELETE.

GET: Método onde vamos extrair informações do banco de dados e exibi-los.
PUT: Método que altera informações do banco de dados
POST: Método para adicionar informações no banco de dados.
DELETE: Método para deletar informações do banco de dados.

Lembrando das exigências que vimos anteriormente, neste projeto usaremos apenas o método GET e POST.

Método POST

Id - Gerada automaticamente (Chave primária, gerada automaticamente pelo sistema)
Email - Adicionado pelo usuário.
CardNumber - Gerado automaticamente de forma aleatória.

No método POST adicione as linhas de código abaixo.

    public async Task<ActionResult<ClienteDados>> PostClienteDados(ClienteDados clienteDados)
    {        
        Random rnd = new Random();
        int ccn1 = rnd.Next(1000, 9999);
        int ccn2 = rnd.Next(1000, 9999);
        int ccn3 = rnd.Next(1000, 9999);
        int ccn4 = rnd.Next(1000, 9999);
        clienteDados.CardNumber = $"{ccn1} {ccn2} {ccn3} {ccn4}";

        _context.ClientesDb.Add(clienteDados);  
            await _context.SaveChangesAsync();
            return CreatedAtAction("PostClienteDados", new { clienteDados = clienteDados.CardNumber }, clienteDados.CardNumber);
    }

Random rnd - Para gerarmos números aleatórios crie uma instância da classe Random para acessarmos as funções desta classe.
Como não foi especificado no nosso projeto a bandeira do cartão de crédito ou quantos números teria, então decidi que neste projeto serão 4 blocos de 4 números aleatórios.

int ccn1/2/3/4 - Estas 4 variáveis são os 4 blocos de 4 números.
Para gerarmos de fato os números aleatórios precisamos chamar a função next da classe Random, através da instância rnd. rnd.Next. Dentro da função Next definimos o range de números que queremos.

rnd.Next(1000, 9999);

Agora que temos os números criados, precisamos armazená-los dentro do nosso atributo que representa o número do cartão de crédito no nosso banco de dados, o CardNumber.
Precisamos então concatenar as 4 variáveis ccn para armazená-las em CardNumber.

clienteDados.CardNumber = $"{ccn1} {ccn2} {ccn3} {ccn4}"

Aqui usamos a nossa instância (clienteDados) da classe (ClienteDados) do projeto para acessar o atributo CardNumber.

Bom, já temos nosso número aleatório de cartão de crédito, agora precisamos armazenar tudo no banco de dados.

_context.ClientesDb.Add(clienteDados);
        await _context.SaveChangesAsync();

Usamos a nossa instância do nosso contexto do banco de dados _context.ClientesDb para acessar o banco de dados e executar a função .Add para ADICIONAR informação da classe ClienteDados.
E toda vez que adicionamos algo ao banco de dados precisamos salvar através da função .SaveChangesAsync();

O projeto pede que após o usuário inserir o seu email, o sistema vai retornar apenas o número de cartão de crédito. Para isso vamos usar o código abaixo.

            return CreatedAtAction("PostClienteDados", new { clienteDados = clienteDados.CardNumber }, clienteDados.CardNumber);

Se atentar para o método que está sendo chamado, que é o PostClienteDados e para o que vem após de new, pois deve ser o mesmo parâmetro da função PostClienteDados. Para filtrar e mostrar apenas CardNumber é necessário que especifique clienteDados.CardNumber.

Método GET

O projeto pede que quando o usuário insere o seu e-mail como parâmetro, retorne em ordem de criação apenas os números de cartão de crédito.

Antes do método GET precisamos criar um TYPE, para ter acesso aos atributos da nossa classe.

    public class NEW_TYPE
    {
        public string Cartao { get; set; }
    };

     // GET: api/ClienteDados/”inserir email aqui”
    [HttpGet("{email}")]
        public async Task<ActionResult<IEnumerable<ClienteDados>>> GetEmail(string email)
        {
            var list = from a in _context.ClientesDb
                        where a.Email.Equals(email)
                        select new NEW_TYPE
                        {
                            Cartao = a.CardNumber
                        };
            var CartoesdeCredito = await list.ToListAsync();
            return Ok(CartoesdeCredito);
        }

Repare que agora o [HttpGet] está com um complemento, que é o parâmetro que o usuário vai inserir [HttpGet(“{email}”).

Como estamos recebendo um parâmetro, precisamos receber em uma variável, por isso temos (string email) após a declaração do método.

public async Task>> GetEmail

Crie uma instância do nosso banco de dados.

var list = from a in _context.ClientesDb

Crie uma estrutura de consulta com filtro.

var list = from a in _context.ClientesDb
where a.Email.Equals(email)
select new NEW_TYPE
{
Cartao = a.CardNumber
};

Agora que temos a informação filtrada, vamos adicionar a uma lista.

var CartoesdeCredito = await list.ToListAsync();

E retornaremos a lista para o usuário.

return Ok(CartoesdeCredito);

Roteamento

Antes de testarmos nossa API precisamos atualizar o arquivo launchSettings.json adicionando a rota do URL que desejamos acessar nossa API

 "profiles": {
"IIS Express": {
  "commandName": "IISExpress",
  "launchBrowser": true,
  "launchUrl": "api/ClienteDados",
  "environmentVariables": {
    "ASPNETCORE_ENVIRONMENT": "Development"
  }
},
"APICartaoDeCredito": {
  "commandName": "Project",
  "launchBrowser": true,
  "launchUrl": "api/ClienteDados",
  "applicationUrl": "https://localhost:5001;http://localhost:5000",
  "environmentVariables": {
    "ASPNETCORE_ENVIRONMENT": "Development"
  }

Atualize o parâmetro “launchUrl” e coloque o caminho desejado, no nosso caso vai ser o api/ClienteDados.

Na parte superior desse arquivo você pode escolher a porta do localhost a ser usada.

Caso você queira personalizar a URL, você deve se atentar para mudar o roteamento no Controller também, pois ele vem como de Defaut roteando para api/nome da classe e se você inicializar com outro nome, deve especificar no Controller.

Postman

Por conveniência, escolhi a plataforma Postman para realizar os testes do projeto, existem outras formas e plataformas para testar.

Ao abrir o Postman clique em Create New para criar um novo projeto, e na próxima janela que abrir escolha HTTP Request.

Na próxima janela que abrir clique em New Collection, dê um nome pra ela, e clique em Create, na próxima janela clique em Save e pronto, projeto criado.

De volta ao Visual Studio, na barra superior de ferramentas, no símbolo de PLAY para executar nosso projeto.

O seu navegador padrão deverá abrir no endereço que roteamos no projeto.

https://localhost:44340/api/ClienteDados

Lembrando que a porta do URL pode ser diferente.

Pegue esse link e cole no Postman.

Você deve receber Status 200 OK que significa que a requisição retornou com sucesso.

Como não demos nenhuma entrada até esse momento, ele retornou tudo em branco.

Endpoint 1

Para realizarmos a primeira entrada, clique no Dropdown menu onde está escrito GET e aparecerá todos os verbos disponíveis de Http para você escolher.

Clique em Post para acessarmos o método Post do nosso projeto.
Clique em Body, depois em raw, depois troque o método de entrada de Text para JSON.

O código para darmos a primeira entrada no banco de dados, inclui apenas Email, pois as outras informações são geradas automaticamente.

{
"Email": "digite o email aqui"
}

Após digitar o email desejado clique em Send para executar o código e o sistema retornará 200 OK e o número de cartão de crédito gerado.

Para fazer o teste do segundo Endpoint, crie vários números para o mesmo email.

Endpoint 2

Mude o verbo Http no Postman para GET novamente.
E no caminho URL adicione o email cadastrado e clique Send novamente.

https://localhost:44340/api/ClienteDados/EmailCadastradoAQUI

E o sistema retornou os cartões de crédito que pertencem ao usuário do email cadastrado, e listou-os em ordem de criação.

É possível testar o método GET no browser também, digitando o caminho do URL+email https://localhost:44340/api/ClienteDados/emailcadastrado e ele dará o mesmo retorno que no Postman.

Com isso concluímos este projeto. https://github.com/mgpaixao/APICartaoDeCredito

Obrigado

Matheus PaixãoFollow

Gosto de compartilhar conhecimento pois foi assim que eu aprendi a programar. O meu negócio é todo dia saber mais que eu sabia ontem. Pode me chamar, vamos aprender juntos. Prazer =)

Forem: Matheus Paixão

Deploy .NET API to Kubernetes using Kind

Pre-requirements

Preparing the API

Vs Code

Visual Studio

Swagger Support

Publishing API in Docker Hub

Installing Kind

Preparing the API for Kubernetes

Pushing API to Kubernetes

Accessing your Pod

Matheus PaixãoFollow

Flutter - How to format DateTime and how to display it

Installation and Importing

How to use

Matheus PaixãoFollow

Flutter - Difference between Container vs Column and Row

Container - Flutter doc reference

Column/Row

Matheus PaixãoFollow

C# - Criando API com Jwt Token - Autorização e Autenticação - Módulo 3 - Arquitetura 3 camadas - Repository Pattern

Melhorias desse modulo

Divisão em 3 Camadas

Arquitetura 3 camadas

Como dividir o projeto em 3 camadas?

Criando Biblioteca de classes

Repository Pattern

Implementação

Base Repository

IBaseRepository Interface

Service Login

Controller

Porque implementar tudo isso?

Matheus PaixãoFollow

C# - Criando API Login com Jwt Token - Autorização e Autenticação - Módulo 2

Migrando .Net 5 para .Net 6

1 - No arquivo .csproj altere o TargertFramework para net6.0 e dentro do mesmo <PropertyGroup> adicione <Nullable>enable</Nullable> e <ImplicitUsings>enable</ImplicitUsings> e o resultado deve ficar assim:

2 - Atualize os pacotes Nugets

3 - Migrando dados da Startup.cs para Program.cs

Crud de Roles

Create Read Update Delete - CRUD

Post

Patch Change User Role

Get Mostrar todos os Roles

Patch Edit Role

Delete Roles

Matheus PaixãoFollow

C# - Criando API com Jwt Token - Autorização e Autenticação - Módulo 1

Sumário - Clique e ache rápido o que deseja ler

Regra de Negócio

Modulo 1

Importância do Controle de Acesso

Roles

Qual a diferença entre Autenticação e Autorização?

Criando uma API básica usando o processo de autenticação COM JWT token

Models e View Models

Role

User

LoginViewModel

RegisterViewModel

Banco de Dados - Postgres

Mapeamentos

UserMap

RolesMap

Startup.cs

DataContext

ConnectionString - secrets.json

Token de Assinatura

Configuration.cs

O segredo por trás de tudo

TokenService.cs

GetClaims()

Controller

Bibliotecas

Endpoints -

Classe da Controller

EndPoint Register

Criptografia da senha do usuário

EndPoint Login

1 - No arquivo .csproj altere o `TargertFramework` para `net6.0` e dentro do mesmo `<PropertyGroup>` adicione `<Nullable>enable</Nullable>` e `<ImplicitUsings>enable</ImplicitUsings>` e o resultado deve ficar assim:

`Modulo 1`

`Role`

`User`

`LoginViewModel`

`RegisterViewModel`

`Mapeamentos`

`UserMap`

`RolesMap`

`Startup.cs`

`DataContext`

`ConnectionString - secrets.json`

`Configuration.cs`

`TokenService.cs`

`GetClaims()`

`Bibliotecas`

`Classe da Controller`

EndPoint `Register`

EndPoint `Login`

EndPoint `changeUserRole`

`Register`

`Login`