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 =)

.

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.