Curso .NETCore 3.1 ou NET5.0 - Criação de Projeto Passo a Passo.txt

. Crie as pastas abaixo:

        mkdir cursoApiNetcore
        mkdir cursoApiNetcore/src
        cd cursoApiNetcore

. Dentro da pasta src execute o comando abaixo:

        cd src
        
        dotnet new sln --name API

. Acesse o VSCode na pasta raiz do projeto:

        cd cursoApiNetcore/src

        code .

. Crie o arquivo global.json na pasta src com o conteúdo abaixo:

        {
                "sdk" : {
                "version" : "5.0.17"
                }     

        }


. Dentro da pasta src execute o comando abaixo:

        cd cursoApiNetcore/src

        dotnet new webapi -n application -o Api.Application --no-https -f net5.0

        dotnet sln add Api.Application

        dotnet build

. Dentro da pasta src acesse o VSCode, ao entrar ele irá fazer uma pergunta para colocar o build e o debug no projeto,
        responda "Yes"

        code .

. Ao responder "Yes", o VSCode ira criar uma pasta do projeto .vscode. Dentro desta pasta teremos dois arquivos
        ( launch.json e tasks.json). Esses arquivos criados automaticamente tem as configurações para depuração.

. Podemos acessar a execução do projeto do icone com triângulo na barra vertical do VSCode, que surgira a "Side Bar".
            Neste ponto surgirá os botões de execução do projeto. 

        . Execute o projeto e no navegador execute a URL abaixo:

            http://localhost:5000/WeatherForecast

. Acesse a pasta /src do seu projeto

. Digite o comando abaixo para criar a classlib:

        dotnet new classlib -n Domain -o Api.Domain -f net5.0

. Dentro da pasta "src" digite o comando abaixo para adicionar a pasta "Api.Domain" a solution:

        dotnet sln add ./Api.Domain/

        dotnet restore

. Acesse a pasta Api.Domain e apague a classe Classe1.cs

. Digite o comando abaixo:

        dotnet build

. Opções para o comando abaixo "Ctrl+Shift+B", ou acesse a opção "Terminal / Run Build Task"


. Acesse a pasta source e digite o comando abaixo:

        cd src

        dotnet new classlib -n CrossCutting -f net5.0 -o Api.CrossCutting

. Dentro da pasta "src" adicone a pasta CrossCutting a solution:

        dotnet sln add ./Api.CrossCutting/


. Acesse a pasta Api.CrossCutting e apague a classe Classe1

        dotnet build

. Acessar a pasta src e digitar o comando abaixo:

        cd src

        dotnet new classlib -n Data -f net5.0 -o Api.Data

. Dentro da pasta "src" adicone a pasta CrossCutting a solution:

        dotnet sln add ./Api.Data/

. Acesse a pasta Api.Data e apague a classe Classe1

. Digite o comando abaixo:

        dotnet build



. Acessar a pasta src e digitar o comando abaixo:

        dotnet new classlib -n Service -f net5.0 -o Api.Service

. Dentro da pasta "src" adicone a pasta CrossCutting a solution:

        dotnet sln add ./Api.Service/

. Acesse a pasta Api.Service e apague a classe Classe1

. Digite o comando abaixo:

        dotnet build

. No VSCode, clique com o botão direito sobre a pasta Api.Domain e crie as folder abaixo:

        Entities
        Interfaces

. No VSCode, clique com o botão direito sobre a pasta Api.Domain.Entities e crie uma nova classe
        com o nome de "BaseEntity" e com o conteúdo abaixo:

        using System;
        using System.ComponentModel.DataAnnotations;

        namespace Api.Domain.Entities
        {
            public abstract class BaseEntity
            {
                [Key]
                public Guid Id { get; set; }

                private DateTime? _createAt;
                public DateTime? CreateAt
                {       
                    get { return _createAt; } 
                    set { _createAt  =  (value == null? DateTime.UtcNow : value); }
                }
                
                public DateTime? UpdateAt { get; set; }

            }
        }



. Acesse a pasta Api.Domain.Entities e crie a classe UserEntity.cs como abaixo:

        namespace Api.Domain.Entities
        {
                [Table("User")]
                public class UserEntity : BaseEntity
                {
                        public string Nome { get; set; }

                        public string Email { get; set; }
                }
        }

. Acesse a pasta ./Api.Data e execute as linhas abaixo no prompt do sistema operacional:

        dotnet add package Microsoft.EntityFrameworkCore --version 5.0.10
        dotnet add package Microsoft.EntityFrameworkCore.Tools --version 5.0.5
        dotnet add package Microsoft.EntityFrameworkCore.Design --version 5.0.5
        dotnet add package Pomelo.EntityFrameworkCore.MySql --version 5.0.4

. Verifique se as tags abaixo estão no arquivo Api.Data.Data.csproj:


        <ItemGroup>
                <!-- <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="5.0.5" /> -->

                <PackageReference Include="Pomelo.EntityFrameworkCore.MySql" Version=5.0.4" />

                <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="5.0.5">
                        <PrivateAssets>all</PrivateAssets>
                        <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
                </PackageReference>
        
                <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="5.0.5">
                        <PrivateAssets>all</PrivateAssets>
                        <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
                </PackageReference>

        </ItemGroup>


. Acesse a pasta /src/Api.Data e execute os comandos abaixo:

        dotnet ef  # Verificação se a ferramenta foi instalada com sucesso

        dotnet restore

        # Caso não exista a ferramenta "dotnet-ef" execute a linha abaixo
        dotnet tool install --global dotnet-ef

        dotnet build

. Verifique se depois do "build" a aplicação compilou com zero erro.

. Dentro da pasta Api.Data crie as pastas abaixo:

        Content
        Mapping
        Repository

. No terminal e na pasta src faça a referência da pasta Api.Domain para a pasta Api.Data.

        dotnet add ./Api.Data/ reference ./Api.Domain/

        . Verifique no arquivo ./Api.Data/Data.csproj se existe uma referência ao projeto Api.Domain

. Crie a classe MyContext.cs dentro da pasta ./Api.Data/Context como abaixo. O contexto que fará a conexão
        com o banco de dados.

        using System;
        using Api.Domain.Entities;
        using Microsoft.EntityFrameworkCore;

        namespace Api.Data.Content
        {
                public class MyContext : DbContext
                {
                        public DbSet<UserEntity> Users { get; set; }

                        protected override void OnConfiguring(DbContextOptionsBuilder options)
                                => options.UseMySql("Server=localhost;Port=3306;Database=testdb;Uid=root;Pwd=root",
                                                        ServerVersion.AutoDetect("Server=localhost;Port=3306;Database=testdb;Uid=root;Pwd=root"));
                }
        }


. Crie na pasta "mapping" a classe "UserMap" como abaixo:

        using Api.Domain.Entities;
        using Microsoft.EntityFrameworkCore;
        using Microsoft.EntityFrameworkCore.Metadata.Builders;

        namespace Api.Data.Mapping
        {
                public class UserMap : IEntityTypeConfiguration<UserEntity>
                {
                        public void Configure(EntityTypeBuilder<UserEntity> builder)
                        {
                        builder.ToTable("User");

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

                        builder.HasIndex( u => u.Email );

                        builder.Property( u => u.Nome )
                                .HasColumnName("Nome")
                                .HasColumnType("VARCHAR")
                                .HasMaxLength(60)
                                .IsRequired();

                        builder.Property( u => u.Email )
                                .HasColumnName("Email")
                                .HasColumnType("VARCHAR")
                                .HasMaxLength(100)
                                .IsRequired();

                        builder.Property( u => u.CreatedAt )
                                .HasColumnName("CreatedAt")
                                .HasColumnType("TIMESTAMP")
                                .HasDefaultValueSql("CURRENT_TIMESTAMP");
                        }
                }
        }


        . Observações: O Engine EF do MySQL não se mostrou eficiente para criar a base. Nesse caso compensa mais criar
                        o script manualmente e executá-lo no banco:

                CREATE DATABASE testdb;

                USE testdb;

                CREATE TABLE `User` (
                `Id` int NOT NULL AUTO_INCREMENT,
                `Nome` VARCHAR(100) CHARACTER SET utf8mb4 NULL,
                `Email` VARCHAR(100) CHARACTER SET utf8mb4 NULL,
                `CreatedAt` TIMESTAMP NULL DEFAULT CURRENT_TIMESTAMP,
                `UpdateAt` datetime(6) NULL,
                CONSTRAINT `PK_Users` PRIMARY KEY (`Id`)
                ) CHARACTER SET utf8mb4;


. Acesse a classe Api.Data.Content.MyContext.cs e altere o método "OnModelCreating" como abaixo:

        using Api.Data.Mapping;
        using Api.Domain.Entities;
        using Microsoft.EntityFrameworkCore;

        namespace Api.Data.Content  {
                public class MyContext : DbContext
                {

                        public DbSet<UserEntity> Users { get; set; }

                        public MyContext(DbContextOptions<MyContext> options) : base(options){  }

                        protected override void OnModelCreating(ModelBuilder modelBuilder){
                                base.OnModelCreating(modelBuilder);

                                modelBuilder.Entity<UserEntity>( new UserMap().Configure );     // Linha incluída
                        
                        }
                }
        }

. Na pasta raiz Api.Data digite os comandos abaixo para criação das tabelas no banco de dados:

        # UserMigrations é o nome que é data para a migração
        dotnet ef migrations add UserMigration

        donet ef database update

. Crie a interface abaixo em Api.Domain.Interfaces

        using System;
        using System.Collections.Generic;
        using System.Threading.Tasks;
        using Api.Domain.Entities;

        namespace Api.Domain.Interfaces
        {
                public interface IRepository<T,K> where T: BaseEntity
                {
                        Task<T> InsertAsync( T item);
                        Task<T> UpdateAsync( T item );
                        Task<bool> DeleteAsync(K id );
                        Task<T> SelectAsync( K id );
                        Task<IEnumerable<T>> SelectAsync();
                        Task<bool> ExistAsync( K id );
                }
        }

. Crie dentro da pasta Api.Data.Repository a classe BaseRepository como abaixo:

        using System;
        using System.Collections.Generic;
        using System.Threading.Tasks;
        using Api.Data.Content;
        using Api.Domain.Entities;
        using Api.Domain.Interfaces;
        using Microsoft.EntityFrameworkCore;

        namespace Api.Data.Repository
        {
                public class BaseRepository<T, K> : IRepository<T, K> where T : BaseEntity
                {
                        protected readonly MyContext _context;

                        private DbSet<T> _dataSet;

                        public BaseRepository(MyContext context)
                        {
                        _context = context;
                        _dataSet = _context.Set<T>();

                        }


                        public async Task<bool> DeleteAsync(K id)
                        {
                        var result = await _dataSet.SingleOrDefaultAsync(p => p.Id.Equals(id));

                        if (result == null)
                                return false;

                        _dataSet.Remove(result);

                        await _context.SaveChangesAsync();

                        return true;
                        }

                        public async Task<T> InsertAsync(T item)
                        {
                        item.CreatedAt = DateTime.UtcNow;

                        _dataSet.Add(item);

                        await _context.SaveChangesAsync();


                        return item;

                        }

                        public async Task<IEnumerable<T>> SelectAsync()
                        {
                        return await _dataSet.ToListAsync();

                        }

                        public async Task<T> SelectAsync(K id)
                        {
                        return await _dataSet.SingleOrDefaultAsync(p => p.Id.Equals(id));

                        }

                        public async Task<T> UpdateAsync(T item)
                        {
                        var result = await _dataSet.SingleOrDefaultAsync(p => p.Id.Equals(item.Id));

                        if (result == null)
                                return null;

                        item.UpdateAt = DateTime.UtcNow;
                        item.CreatedAt = result.CreatedAt;

                        _context.Entry(result).CurrentValues.SetValues(item);

                        await _context.SaveChangesAsync();


                        return item;
                        }

                        public async Task<bool> ExistAsync(K id)
                        {
                        return await _dataSet.AnyAsync(p => p.Id.Equals(id));
                        }
                }
        }

. Dentro da pasta Api.Domain/Interface crie a pasta "Services".

. Dentro da nova pasta "Services" crie a pasta "User".

. No VSCode, clique com o botão direito sobre a pasta "User", escolha a opção "New C# Interface" e
        dê o nome da interface de "IUserService".

. Copie o código abaixo para a interface IUserService:

        using System;
        using System.Collections.Generic;
        using System.Threading.Tasks;
        using Api.Domain.Entities;

        namespace Api.Domain.Interfaces.Services.User
        {
                public interface IUserService
                {
                        Task<UserEntity> Get(int id);
                        Task<IEnumerable<UserEntity>> GetAll();
                        Task<UserEntity> Post(UserEntity user);
                        Task<UserEntity> Put(UserEntity user);
                        Task<bool> Delete(int id);
                }
        }

. Vá ao terminal, na pasta "src" e execute o comando abaixo:

        dotnet add ./Api.Service/ reference ./Api.Domain/

        dotnet add ./Api.Service/ reference ./Api.Data/

        dotnet add ./Api.Service/ reference ./Api.CrossCutting/

. Acesse o arquivo src/Api.Service/Service.cproj e verifique se as referências acima foram
        inseridas corretamente neste arquivo.

. Na pasta "src" digite o comando abaixo no prompt do sistema operacional:

        dotnet build

. Dentro da pasta Api.Service crie a pasta "Services" com clique direito no VSCode.

. No VSCode, clique com o botão direito sobre a nova pasta "Services", escolha a opção "New C# Class" e
        dê o nome da interface de "UserService".

. Digite o código abaixo na classe UserService:

        using System;
        using System.Collections.Generic;
        using System.Threading.Tasks;
        using Api.Domain.Entities;
        using Api.Domain.Interfaces;
        using Api.Domain.Interfaces.Services.User;

        namespace Api.Service.Services
        {
                public class UserService : IUserService     // 1.   2.
                {
                        private IRepository<UserEntity, int> _repository;         // 3.

                        public UserService(IRepository<UserEntity, int> repository)  // 4. 
                        {
                                _repository = repository;
                        }


                        public Task<bool> Delete(int id)
                        {
                                throw new NotImplementedException();
                        }

                        public Task<UserEntity> Get(int id)
                        {
                                throw new NotImplementedException();
                        }

                        public async Task<IEnumerable<UserEntity>> GetAll()
                        {
                                return await _repository.SelectAsync();
                        }

                        public async Task<UserEntity> Post(UserEntity user)
                        {
                                return await _repository.InsertAsync(user);
                        }

                        public async Task<UserEntity> Put(UserEntity user)
                        {
                                return await _repository.UpdateAsync(user);
                        }
                }
        }

. Acesse a pasta src e digite o comando abaixo no prompt do sistema operacional:

        dotnet add Api.Application reference Api.Domain

        dotnet add Api.Application reference Api.Service

        dotnet add Api.Application reference Api.CrossCutting

. Acesse a classe Api.Application.Application.csproj e verifique se as dependências foram incluidas com sucesso.

. O padrão de nomenclatura para se criar uma classe controller seria [nome do objeto] + Controller. Sem esse padrão
        de nomenclatura o .Net não reconhece a classe como um controller.

. Crie a classe Api.Application.Controllers.UsersController com o código abaixo:

        using System;
        using System.Net;
        using System.Threading.Tasks;
        using Api.Domain.Entities;
        using Api.Domain.Interfaces.Services.User;
        using Microsoft.AspNetCore.Mvc;

        namespace Api.Application.Controllers
        {
                //http://localhost:5000/api/users   
                [Route("api/[controller]")]             // 2. O [controller] indica ao MVC que para ser chamado é necessário informar "users" que será associado a classe UserController
                [ApiController]
                public class UsersController : ControllerBase       // 1. Interface ControllerBase contém todos os métodos de uma API
                {
                        public IUserService _service { get; set; }
        
                        public UsersController(IUserService service)
                        {
                                _service = service;
                        }

                        [HttpGet]
                        public async Task<ActionResult> GetAll()
                        {
                                if (!ModelState.IsValid)
                                {
                                        return BadRequest(ModelState);  // 400 Bad Request - Solicitação Inválida
                                }

                                try
                                {
                                        return Ok(await _service.GetAll());
                                }
                                catch (ArgumentException e)
                                {
                                        return StatusCode((int)HttpStatusCode.InternalServerError, e.Message);
                                }
                        }

                        [HttpGet]
                        [Route("{id}", Name = "GetWithId")]
                        public async Task<ActionResult> Get(int id)
                        {
                                if (!ModelState.IsValid)
                                {
                                        return BadRequest(ModelState);
                                }
                                try
                                {
                                        return Ok(await _service.Get(id));
                                }
                                catch (ArgumentException e)
                                {
                                        return StatusCode((int)HttpStatusCode.InternalServerError, e.Message);
                                }
                        }

                        [HttpPost]
                        public async Task<ActionResult> Post([FromBody] UserEntity user)
                        {
                                if (!ModelState.IsValid)
                                {
                                        return BadRequest(ModelState);
                                }
                                try
                                {
                                        var result = await _service.Post(user);
                                        if (result != null)
                                        {
                                        return Created(new Uri(Url.Link("GetWithId", new { id = result.Id })), result);
                                        }
                                        else
                                        {
                                        return BadRequest();
                                        }
                                }
                                catch (ArgumentException e)
                                {
                                        return StatusCode((int)HttpStatusCode.InternalServerError, e.Message);
                                }
                        }

                        [HttpPut]
                        public async Task<ActionResult> Put([FromBody] UserEntity user)
                        {
                                if (!ModelState.IsValid)
                                {
                                        return BadRequest(ModelState);
                                }
                                try
                                {
                                        var result = await _service.Put(user);
                                        if (result != null)
                                        {
                                                return Ok(result);
                                        }
                                        else
                                        {
                                                return BadRequest();
                                        }
                                }
                        catch (ArgumentException e)
                        {
                                return StatusCode((int)HttpStatusCode.InternalServerError, e.Message);
                        }
                        }

                        [HttpDelete("{id}")]
                        public async Task<ActionResult> Delete(int id)
                        {
                                if (!ModelState.IsValid)
                                {
                                        return BadRequest(ModelState);
                                }

                                try
                                {
                                        return Ok(await _service.Delete(id));
                                }
                        catch (ArgumentException e)
                        {
                                return StatusCode((int)HttpStatusCode.InternalServerError, e.Message);
                        }
                        }
                }
        }