ASP.NET Core - Exibindo e atualizando dados relacionados

ASP.NET Core - Exibindo e atualizando dados relacionados - II

Neste tutorial veremos como exibir e atualizar dados relacionados em uma aplicação ASP .NET Core MVC.

Vamos continuar a primeira parte do artigo. criando os repositórios.

Criando os repositórios para Clientes e Pedidos

A partir do projeto criado no artigo anterior, vamos criar a pasta Repositories no projeto e nesta pasta criar as classes ClientesRepository e PedidosRepository que vão conter o acesso, a consulta aos dados e a persistência dos dados.

1 - ClientesRepository

using Aspn_MasterDetail.Context;
using Aspn_MasterDetail.Models;
using Aspn_MasterDetail.ViewModels;
using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;
using System.Linq;

namespace Aspn_MasterDetail.Repositories
{
    public class ClientesRepository
    {
        private readonly AppDbContext context;
        public ClientesRepository(AppDbContext contexto)
        {
            context = contexto;
        }
        public Cliente GetCliente(int clienteId)
        {
            if (clienteId > 0)
            {
              var cliente = context.Clientes.AsNoTracking()
                               .Where(x => x.ClienteId == clienteId)
                               .Single();

                    return cliente;
            }
            return null;
        }

        public List<ClienteExibeViewModel> GetClientes()
        {
            using(context)
            {
                List<Cliente> clientes = new List<Cliente>();
                clientes = context.Clientes.AsNoTracking().ToList();

                if (clientes != null)
                {
                    List<ClienteExibeViewModel> clientesView = new List<ClienteExibeViewModel>();
                    foreach (var x in clientes)
                    {
                        var clienteView = new ClienteExibeViewModel()
                        {
                            ClienteId = x.ClienteId,
                            Nome = x.Nome,
                            Email = x.Email
                        };
                        clientesView.Add(clienteView);
                    }
                    return clientesView;
                }
                return null;
            }
        }

        public ClienteEditaViewModel CriaCliente()
        {
            var cliente = new ClienteEditaViewModel();
            return cliente;
        }

        public bool SalvarCliente(ClienteEditaViewModel clienteEdita)
        {
            if (clienteEdita != null)
            {
                using (context)
                {
                        var cliente = new Cliente()
                        {
                            Nome = clienteEdita.Nome,
                            Email = clienteEdita.Email,
                        };
                        context.Clientes.Add(cliente);
                        context.SaveChanges();
                        return true;
                }
            }
            // Retorna false se clienteEdita == null 
            return false;
        }
    }
}

Na classe ClientesRepository estamos incluindo uma instância do contexto via injeção de dependência no construtor da classe.

Definimos também os seguintes métodos neste repositório:

GetCliente - Retorna um objeto do tipo Cliente pelo id do cliente;
GetClientes - Retorna uma lista de objetos do tipo ClienteExibeViewModel ;
CriaCliente - Cria um objeto do tipo ClienteEditaViewModel;
SalvarCliente - Inclui um objeto cliente e faz a persistência dos dados;

Para poder referenciar via injeção de dependência os repositórios temos que registrar cada repositório como um serviço no método ConfigureServices da classe Startup:

public void ConfigureServices(IServiceCollection services)
        {
            services.Configure<CookiePolicyOptions>(options =>
            {
                options.CheckConsentNeeded = context => true;
                options.MinimumSameSitePolicy = SameSiteMode.None;
            });

            services.AddScoped<ClientesRepository>();
            services.AddScoped<PedidosRepository>();

            services.AddDbContext<AppDbContext>(options =>
              options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
        }

2 - PedidosRepository

using Aspn_MasterDetail.Context;
using Aspn_MasterDetail.ViewModels;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;

namespace Aspn_MasterDetail.Repositories
{
    public class PedidosRepository
    {
        private readonly AppDbContext context;
        private readonly ClientesRepository clienteRepo;

        public PedidosRepository(AppDbContext contexto,ClientesRepository repo )
        {
            context = contexto;
            clienteRepo = repo;
        }

        public ClientePedidosViewModel GetClientePedidosView(int clienteId)
        {
            if (clienteId > 0)
            {
                using (context)
                {
                    var cliente = clienteRepo.GetCliente(clienteId);
                    if (cliente != null)
                    {
                        var clientePedidosVM = new ClientePedidosViewModel()
                        {
                            ClienteId = cliente.ClienteId,
                            ClienteNome = cliente.Nome,
                            Email = cliente.Email
                        };

                        List<PedidoExibeViewModel> listaPedido = context.Pedidos.AsNoTracking()
                            .Where(x => x.ClienteId == clienteId)
                            .OrderBy(x => x.DataPedido)
                            .Select(x =>
                           new PedidoExibeViewModel
                           {
                               ClienteId = x.ClienteId,
                               PedidoId = x.PedidoId,
                               DataPedido = x.DataPedido,
                               Descricao = x.Descricao
                           }).ToList();

                        clientePedidosVM.Pedidos = listaPedido;

                        return clientePedidosVM;
                    }
                }
            }
            return null;
        }

        public PedidoEditaViewModel CriaPedido()
        {
            var pedido = new PedidoEditaViewModel()
            {
                DataPedido = DateTime.Now
            };
            return pedido;
        }

        public List<PedidoExibeViewModel> GetPedidosView()
        {
            PedidoExibeViewModel listaPedido = null;
            List<PedidoExibeViewModel> listaPedidos = new List<PedidoExibeViewModel>();

            var pedidos = context.Pedidos.ToList();

            if (pedidos != null)
            {
                foreach (var pedido in pedidos)
                {
                    var cliente = clienteRepo.GetCliente(pedido.ClienteId);
                    if (cliente != null)
                    {
                        listaPedido = new PedidoExibeViewModel
                        {
                            ClienteId = pedido.ClienteId,
                            NomeCliente = cliente.Nome,
                            PedidoId = pedido.PedidoId,
                            DataPedido = pedido.DataPedido,
                            Descricao = pedido.Descricao
                        };
                        listaPedidos.Add(listaPedido);
                    }
                }
                return listaPedidos;
            }
            return null;
        }

        public void SalvarPedidos(List<PedidoExibeViewModel> pedidos)
        {
            if (pedidos != null)
            {
                using (context)
                {
                    foreach (var pedido in pedidos)
                    {
                        var registro = context.Pedidos.Find(pedido.PedidoId);
                        if (registro != null)
                        {
                            registro.Descricao = pedido.Descricao;
                        }
                    }
                    context.SaveChanges();
                }
            }
        }
    }
}

Na classe PedidosRepository estamos incluindo uma referência ao contexto - AppDbContext - e ao repositório ClientesRepository no construtor da classe via injeção de dependência.

Nesta classe temos os seguintes métodos:

GetClientePedidosView - Retorna os clientes e seus pedidos pelo id do cliente;
CriaPedido - Cria um objeto do tipo PedidoEditaViewModel;
GetPedidosView - Retorna uma lista de pedidos do tipo PedidoExibeViewModel;
SalvarPedidos - Faz a persistência dos pedidos;

Agora podemos criar os controladores ClientesController e PedidosController na pasta Controller e as respectivas views. E faremos isso na próxima parte do artigo.

"Então, aproximando-se dele um escriba, disse-lhe: Mestre, seguir-te-ei para onde quer que fores.
Mas Jesus lhe respondeu: As raposas têm seus covis, e as aves do céu, ninhos; mas o Filho do Homem não tem onde reclinar a cabeça."
Mateus 8:19,20

Referências:

José Carlos Macoratti