ASP.NET Core - Atualização parcial com HTTP PATCH - II

Hoje veremos como realizar a atualização parcial de um recurso usando os recursos do JSON PATCH e o atributo HttpPatch em uma Web API da ASP .NET Core 2.2.

Continuando o artigo anterior vamos agora definir o controlador e implementar o HTTP Patch.

Criando o controlador CategoriasController

Vamos criar o controlador CategoriasController na pasta Controllers e definir apenas dois métodos.

Podemos criar o controlador clicando com o botão direito sobre a pasta Controllers e selecionar add -> Controller;

A seguir , usando o Scaffold, selecione a opção API Controller - Empty e clique em Add:

Após isso Inclua o código abaixo no controlador:

using Microsoft.AspNetCore.JsonPatch;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using System.Threading.Tasks;
using Webpi_Patch1.Models;

namespace Webpi_Patch1.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class CategoriasController : ControllerBase
    {
        private readonly AppDbContext _context;
        public CategoriasController(AppDbContext contexto)
        {
            _context = contexto;
        }

        [HttpGet]
        public string Index()
        {
            return "API CategoriasController - Testando HTTP PATCH";
        }

        [HttpPatch("{id}")]
        public async Task<ActionResult> Patch(int id, [FromBody] JsonPatchDocument<Categoria> patchCategoria)
        {
            if (patchCategoria == null)
            {
                return BadRequest();
            }

            var categoriaDB = await _context.Categorias.FirstOrDefaultAsync(cat => cat.Id == id);

            if (categoriaDB == null)
            {
                return NotFound();
            }

            patchCategoria.ApplyTo(categoriaDB, ModelState);

            var isValid = TryValidateModel(categoriaDB);

            if (!isValid)
            {
                return BadRequest(ModelState);
            }

            await _context.SaveChangesAsync();

            return NoContent();
        }
    }
}

Observe que no código acima incluimos uma referência a using Microsoft.AspNetCore.JsonPatch; para poder aplicar o JSON PATCH.

Definimos dois métodos :

1. HttpGet - Index() - que apenas retorna uma mensagem indicando que a API esta atendendo na uri informada;
2. HttpPatch - Patch() - onde aplicamos o PATCH.

Neste último método fizemos o seguinte :

a- Usamos o atributo HttpPatch para definir que esta Action será executada ao realizar um HTTP PATCH;

b- Usamos JsonPatchDocument como parâmetro de entrada, recebido a partir do Body do request, para definir os possíveis valores das operações PATCH;

c- Verificamos se patchCategoria não é nulo, e, caso for emitimos um BadRequest (400);

d- Localizamos o registro pelo id no banco de dados; se não existir, retornamos um 404;

e- Usamos o método ApplyTo da variável patchCategoria que aplica as operações no objeto categoriaDB;

f- A seguir tentamos validar o modelo para verificar se todas as regras de validação foram respeitadas. Se não forem retornamos um 400;

g- Finalmente, salvamos as alterações e retornamos um 204 No Content.

Para realizar o teste vamos usar o Postman.

A partir de agora vamos usar o Postman para testar a implementação do PACTH em nossa web api.

Para instalar o Postman acesse esse link : https://www.getpostman.com/apps ou abra o Google Chrome e digite postam e a seguir clique no link:  Postman - Chrome Web Store

Na janela que será aberta clique no botão - Usar no Chrome:

A seguir registre uma conta e faça o login.

Pronto ! Já podemos usar o Postman.

Ao executar o projeto, como não fizemos nenhuma mudança, iremos obter o retorno do método GET para a API ValuesController que é criada por padrão no projeto:

Precisamos testar o atendimento da API CategoriasController.

Para testar o GET digite e url a seguir: https://localhost:44303/api/categorias

Com isso iremos obter o retorno da mensagem definida no método Index() - HttpGet:

Assim já sabemos que nossa API esta atendendo. Vamos agora testar o PATCH:

Com Postman aberto vamos definir a requisição a ser enviada usando o PATCH:

Vamos

1. Defina o método HTTP para PATCH
2. Defina o endereço da URL para :  localhost:44303/api/categorias/1
3. Selecione a opção Body
4. Selecione a opção raw
5. Define o tipo para JSON - JSON(application/json)
6. No editor chave-valor informe a estrutura do patch conforme mostrado abaixo:

   [
      { "op": "replace", "path": "/categorianome", "value": "Nome Categoria - Teste" },
      { "op": "replace", "path": "/categoriadescricao", "value": "Descrição Categoria - Teste" }
   ]

7. Clique no botão Send;

No exemplo estamos alterando o nome e a descrição da categoria de id igual a 1.

Após o processamento você obterá a resposta conforme o resultado exibido na figura abaixo:

Vamos abrir a tabela Categorias no SQL Server e verificar se os dados foram alterados:

Bingo !!! A categoria com id igual a 1 teve os dados dos campos CategoriaNome e CategoriaDescricao alterados conforme esperado após enviarmos um request PATCH via WEB API.

Pegue o projeto completo aqui: Webpi_Patch1.zip

"Bem-aventurado o homem que não anda segundo o conselho dos ímpios, nem se detém no caminho dos pecadores, nem se assenta na roda dos escarnecedores.
Antes tem o seu prazer na lei do Senhor, e na sua lei medita de dia e de noite."
Salmos 1:1,2

Referências:

• ASP .NET Core 2 - MiniCurso Básico - Macoratti

• ASP .NET Core MVC - CRUD básico com ADO .NET -

• ASP .NET Core - Implementando a segurança com .

• ASP .NET Core - Acessando dados com Entity Framework .

• ASP .NET Core - Gerenciador de Despesas Pessoais com ..

• ASP .NET Core - Criando sua primeira Web API com ASP .

• ASP .NET Core - Criando uma Web API com CRUD básico ..

• ASP .NET Core - Criando uma API CRUD - I - Macoratti

• Minicurso ASP .NET Core 2.0 - Criando uma Web API - YouTube

• Curso ASP .NET Core 2.0 - Comprar em Macoratti.net

José Carlos Macoratti