public async Task <IActionResult> Delete(int idUsuario, int idEndereco)
{
var cliente = await _context.Clientes.FindAsync(idUsuario);
var endereco = cliente.Enderecos.FirstOrDefault(e => e.IdEndereco == idEndereco);
if (endereco != null)
{
cliente.Enderecos.Remove(endereco);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Endereço excluído com sucesso.");
if (endereco.Selecionado && cliente.Enderecos.Count() > 0)
{
cliente.Enderecos.FirstOrDefault().Selecionado = true;
await _context.SaveChangesAsync();
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Não foi possível excluir o endereço.", TipoMensagem.Erro);
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Endereço não encontrado.", TipoMensagem.Erro);
}
return(RedirectToAction("Index", new { cid = idUsuario }));
}
public async Task <IActionResult> Delete(int idPedido, int idProduto)
{
var itemPedido = await _context.ItensPedidos.FindAsync(idPedido, idProduto);
if (itemPedido != null)
{
_context.ItensPedidos.Remove(itemPedido);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Item de pedido excluído com sucesso.");
var pedido = await _context.Pedidos.FindAsync(itemPedido.IdPedido);
pedido.ValorTotal = _context.ItensPedidos
.Where(i => i.IdPedido == itemPedido.IdPedido)
.Sum(i => i.ValorUnitario * i.Quantidade);
await _context.SaveChangesAsync();
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Não foi possível excluir o item de pedido.", TipoMensagem.Erro);
}
return(RedirectToAction("Index", new { ped = idPedido }));
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Item de pedido não encontrado.", TipoMensagem.Erro);
return(RedirectToAction("Index", new { ped = idPedido }));
}
}
public async Task <IActionResult> Create(int?cid)
{
if (cid.HasValue)
{
var cliente = await _context.Clientes.FindAsync(cid);
if (cliente != null)
{
_context.Entry(cliente).Collection(c => c.Pedidos).Load();
PedidoModel pedido = null;
if (_context.Pedidos.Any(p => p.IdCliente == cid && !p.DataPedido.HasValue))
{
pedido = await _context.Pedidos
.FirstOrDefaultAsync(p => p.IdCliente == cid && !p.DataPedido.HasValue);
}
else
{
pedido = new PedidoModel {
IdCliente = cid.Value, ValorTotal = 0
};
cliente.Pedidos.Add(pedido);
await _context.SaveChangesAsync();
}
return(RedirectToAction("Index", "ItemPedido", new { ped = pedido.IdPedido }));
}
TempData["mensagem"] = MensagemModel.Serializar("Cliente não encontrado", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
TempData["mensagem"] = MensagemModel.Serializar("Cliente não informado", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
public async Task <IActionResult> Create(int?ped, int?prod)
{
if (ped.HasValue)
{
if (_context.Pedidos.Any(p => p.IdPedido == ped))
{
var produtos = _context.Produtos
.OrderBy(x => x.Nome)
.Select(p => new { p.IdProduto, NomePreco = $"{p.Nome} ({p.Valor:C})" })
.AsNoTracking().ToList();
var produtosSelectList = new SelectList(produtos, "IdProduto", "NomePreco");
ViewBag.Produtos = produtosSelectList;
if (prod.HasValue && ItemPedidoExiste(ped.Value, prod.Value))
{
var itemPedido = await _context.ItensPedidos
.Include(i => i.Produto)
.FirstOrDefaultAsync(i => i.IdPedido == ped && i.IdProduto == prod);
return(View(itemPedido));
}
else
{
return(View(new ItemPedidoModel()
{
IdPedido = ped.Value, ValorUnitario = 0, Quantidade = 1
}));
}
}
TempData["mensagem"] = MensagemModel.Serializar("Pedido não encontrado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
TempData["mensagem"] = MensagemModel.Serializar("Pedido não informado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
public async Task <IActionResult> DeleteConfirmed(int id)
{
var produto = await _context.Produtos.FindAsync(id);
//delete image from wwwroot/image
var imagePath = Path.Combine(_hostEnvironment.WebRootPath, "image", produto.ImageName);
if (System.IO.File.Exists(imagePath))
{
System.IO.File.Exists(imagePath);
}
if (produto != null)
{
_context.Produtos.Remove(produto);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Produto excluído com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Não foi possível excluir o produto.", TipoMensagem.Erro);
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Produto não encontrado.", TipoMensagem.Erro);
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Create([FromForm] ItemPedidoModel itemPedido)
{
if (ModelState.IsValid)
{
if (itemPedido.IdPedido > 0)
{
var produto = await _context.Produtos.FindAsync(itemPedido.IdProduto);
itemPedido.ValorUnitario = produto.Valor;
if (ItemPedidoExiste(itemPedido.IdPedido, itemPedido.IdProduto))
{
_context.ItensPedidos.Update(itemPedido);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Item de pedido alterado com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Erro ao alterar item de pedido.", TipoMensagem.Erro);
}
}
else
{
_context.ItensPedidos.Add(itemPedido);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Item de pedido cadastrado com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Erro ao cadastrar item de pedido.", TipoMensagem.Erro);
}
}
var pedido = await _context.Pedidos.FindAsync(itemPedido.IdPedido);
pedido.ValorTotal = _context.ItensPedidos
.Where(i => i.IdPedido == itemPedido.IdPedido)
.Sum(i => i.ValorUnitario * i.Quantidade);
await _context.SaveChangesAsync();
return(RedirectToAction("Index", new { ped = itemPedido.IdPedido }));
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Pedido não informado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
}
else
{
var produtos = _context.Produtos
.OrderBy(x => x.Nome)
.Select(p => new { p.IdProduto, NomePreco = $"{p.Nome} ({p.Valor:C})" })
.AsNoTracking().ToList();
var produtosSelectList = new SelectList(produtos, "IdProduto", "NomePreco");
ViewBag.Produtos = produtosSelectList;
return(View(itemPedido));
}
}
public async Task <IActionResult> Delete(int?cid, int?eid)
{
if (!cid.HasValue)
{
TempData["mensagem"] = MensagemModel.Serializar("Cliente não informado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
if (!eid.HasValue)
{
TempData["mensagem"] = MensagemModel.Serializar("Endereço não informado.", TipoMensagem.Erro);
return(RedirectToAction("Index", new { cid = cid }));
}
var cliente = await _context.Clientes.FindAsync(cid);
var endereco = cliente.Enderecos.FirstOrDefault(e => e.IdEndereco == eid);
if (endereco == null)
{
TempData["mensagem"] = MensagemModel.Serializar("Endereço não encontrado.", TipoMensagem.Erro);
return(RedirectToAction("Index", new { cid = cid }));
}
ViewBag.Cliente = cliente;
return(View(endereco));
}
public async Task <IActionResult> Index(int?cid)
{
if (cid.HasValue)
{
var cliente = await _context.Clientes.FindAsync(cid);
if (cliente != null)
{
var pedidos = await _context.Pedidos
.Where(p => p.IdCliente == cid)
.OrderByDescending(x => x.IdPedido)
.AsNoTracking().ToListAsync();
ViewBag.Cliente = cliente;
return(View(pedidos));
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Cliente não encontrado",
TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Cliente não informado",
TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
}
public async Task <IActionResult> Create(int?id, [FromForm] ProdutoModel produto)
{
string wwwwRootPath = _hostEnvironment.WebRootPath;
string fileName = Path.GetFileNameWithoutExtension(produto.ImageFile.FileName);
string extension = Path.GetExtension(produto.ImageFile.FileName);
produto.ImageName = fileName = fileName + DateTime.Now.ToString("yymmssfff") + extension;
string path = Path.Combine(wwwwRootPath + "/Image/", fileName);
using (var fileStream = new FileStream(path, FileMode.Create))
if (ModelState.IsValid)
{
// upload save image to wwwroot/image
{
await produto.ImageFile.CopyToAsync(fileStream);
}
if (id.HasValue)
{
if (ProdutoExiste(id.Value))
{
_context.Produtos.Update(produto);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Produto alterado com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Erro ao alterar produto.", TipoMensagem.Erro);
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Produto não encontrado.", TipoMensagem.Erro);
}
}
else
{
_context.Produtos.Add(produto);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Produto cadastrado com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Erro ao cadastrar produto.", TipoMensagem.Erro);
}
}
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(produto));
}
}
public async Task <IActionResult> Create(int?id)
{
if (id.HasValue)
{
var cliente = await _context.Clientes.FindAsync(id);
if (cliente == null)
{
TempData["mensagem"] = MensagemModel.Serializar("Cliente não encontrado.", TipoMensagem.Erro);
return(RedirectToAction("Index"));
}
return(View(cliente));
}
return(View(new ClienteModel()));
}
public async Task <IActionResult> Delete(int?id)
{
if (!id.HasValue)
{
TempData["mensagem"] = MensagemModel.Serializar("Cliente não informado.", TipoMensagem.Erro);
return(RedirectToAction(nameof(Index)));
}
var cliente = await _context.Clientes.FindAsync(id);
if (cliente == null)
{
TempData["mensagem"] = MensagemModel.Serializar("Cliente não encontrado.", TipoMensagem.Erro);
return(RedirectToAction(nameof(Index)));
}
return(View(cliente));
}
public async Task <IActionResult> Create(int?id, [FromForm] ClienteModel cliente)
{
if (ModelState.IsValid)
{
if (id.HasValue)
{
if (ClienteExiste(id.Value))
{
_context.Clientes.Update(cliente);
_context.Entry(cliente).Property(x => x.Senha).IsModified = false;
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Cliente alterado com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Erro ao alterar cliente.", TipoMensagem.Erro);
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Cliente não encontrado.", TipoMensagem.Erro);
}
}
else
{
_context.Clientes.Add(cliente);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Cliente cadastrado com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Erro ao cadastrar cliente.", TipoMensagem.Erro);
}
}
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(cliente));
}
}
public async Task <IActionResult> Delete(int?ped, int?prod)
{
if (!ped.HasValue || !prod.HasValue)
{
TempData["mensagem"] = MensagemModel.Serializar("Item de pedido não informado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
if (!ItemPedidoExiste(ped.Value, prod.Value))
{
TempData["mensagem"] = MensagemModel.Serializar("Item de pedido não encontrado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
var itemPedido = await _context.ItensPedidos.FindAsync(ped, prod);
_context.Entry(itemPedido).Reference(i => i.Produto).Load();
return(View(itemPedido));
}
public async Task <IActionResult> Delete(int?id)
{
if (id == null)
{
TempData["mensagem"] = MensagemModel.Serializar("Produto não informado.", TipoMensagem.Erro);
return(RedirectToAction(nameof(Index)));
}
var produto = await _context.Produtos
.FirstOrDefaultAsync(m => m.IdProduto == id);
if (produto == null)
{
TempData["mensagem"] = MensagemModel.Serializar("Produto não encontrado.", TipoMensagem.Erro);
return(RedirectToAction(nameof(Index)));
}
return(View(produto));
}
public async Task <IActionResult> Cadastrar(int?id, [FromForm] PedidoModel pedido)
{
if (ModelState.IsValid)
{
if (id.HasValue)
{
if (PedidoExiste(id.Value))
{
_context.Pedidos.Update(pedido);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Pedido alterada com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Erro ao alterar pedido.", TipoMensagem.Erro);
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Pedido não encontrada.", TipoMensagem.Erro);
}
}
else
{
_context.Pedidos.Add(pedido);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Pedido cadastrada com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Erro ao cadastrar pedido.", TipoMensagem.Erro);
}
}
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(pedido));
}
}
public async Task <IActionResult> Create(int?id, [FromForm] CategoriaModel categoria)
{
if (ModelState.IsValid)
{
if (id.HasValue)
{
if (CategoriaExiste(id.Value))
{
_context.Categorias.Update(categoria);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Categoria alterada com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Erro ao alterar categoria.", TipoMensagem.Erro);
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Categoria não encontrada.", TipoMensagem.Erro);
}
}
else
{
_context.Categorias.Add(categoria);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Categoria cadastrada com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Erro ao cadastrar categoria.", TipoMensagem.Erro);
}
}
return(RedirectToAction(nameof(Index)));
}
else
{
return(View(categoria));
}
}
public async Task <IActionResult> Index(int?ped)
{
if (ped.HasValue)
{
if (_context.Pedidos.Any(p => p.IdPedido == ped))
{
var pedido = await _context.Pedidos
.Include(p => p.Cliente)
.Include(p => p.ItensPedido.OrderBy(i => i.Produto.Nome))
.ThenInclude(i => i.Produto)
.FirstOrDefaultAsync(p => p.IdPedido == ped);
ViewBag.Pedido = pedido;
return(View(pedido.ItensPedido));
}
TempData["mensagem"] = MensagemModel.Serializar("Pedido não encontrado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
TempData["mensagem"] = MensagemModel.Serializar("Pedido não informado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
public async Task <IActionResult> Create(int?cid, int?eid)
{
if (cid.HasValue)
{
var cliente = await _context.Clientes.FindAsync(cid);
if (cliente != null)
{
ViewBag.Cliente = cliente;
if (eid.HasValue)
{
_context.Entry(cliente).Collection(c => c.Enderecos).Load();
var endereco = cliente.Enderecos.FirstOrDefault(e => e.IdEndereco == eid);
if (endereco != null)
{
return(View(endereco));
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Endereço não encontrado.", TipoMensagem.Erro);
}
}
else
{
return(View(new EnderecoModel()));
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Cliente não encontrado.", TipoMensagem.Erro);
}
return(RedirectToAction("Index"));
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Nenhum proprietário de endereços foi informado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
}
public async Task <IActionResult> Fechar(int id)
{
if (PedidoExiste(id))
{
var pedido = await _context.Pedidos
.Include(p => p.Cliente)
.Include(p => p.ItensPedido)
.ThenInclude(i => i.Produto)
.FirstOrDefaultAsync(p => p.IdPedido == id);
if (pedido.ItensPedido.Count() > 0)
{
pedido.DataPedido = DateTime.Now;
foreach (var item in pedido.ItensPedido)
{
item.Produto.Quantidade -= item.Quantidade;
}
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Pedido fechado com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Não foi possível fechar o pedido.", TipoMensagem.Erro);
}
return(RedirectToAction("Index", new { cid = pedido.IdCliente }));
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Não é possível fechar um pedido sem itens.", TipoMensagem.Erro);
return(RedirectToAction("Index", new { cid = pedido.IdCliente }));
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Pedido não encontrado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
}
public async Task <IActionResult> Fechar(int?id)
{
if (!id.HasValue)
{
TempData["mensagem"] = MensagemModel.Serializar("Pedido não informado.", TipoMensagem.Erro);
return(RedirectToAction("Index"));
}
if (!PedidoExiste(id.Value))
{
TempData["mensagem"] = MensagemModel.Serializar("Pedido não encontrado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
var pedido = await _context.Pedidos
.Include(p => p.Cliente)
.Include(p => p.ItensPedido)
.ThenInclude(i => i.Produto)
.FirstOrDefaultAsync(p => p.IdPedido == id);
return(View(pedido));
}
public async Task <IActionResult> Entregar(int idPedido, int idEndereco)
{
if (PedidoExiste(idPedido))
{
var pedido = await _context.Pedidos
.Include(p => p.Cliente)
.ThenInclude(c => c.Enderecos)
.FirstOrDefaultAsync(p => p.IdPedido == idPedido);
var endereco = pedido.Cliente.Enderecos
.FirstOrDefault(e => e.IdEndereco == idEndereco);
if (endereco != null)
{
pedido.EnderecoEntrega = endereco;
pedido.DataEntrega = DateTime.Now;
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Entrega registrada com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Não foi possível registrar a entrega do pedido.", TipoMensagem.Erro);
}
return(RedirectToAction("Index", new { cid = pedido.IdCliente }));
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Endereço não encontrado.", TipoMensagem.Erro);
return(RedirectToAction("Index", new { cid = pedido.IdCliente }));
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Pedido não encontrado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
}
public async Task <IActionResult> Delete(int id)
{
var categoria = await _context.Categorias.FindAsync(id);
if (categoria != null)
{
_context.Categorias.Remove(categoria);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Categoria excluída com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Não foi possível excluir a categoria.", TipoMensagem.Erro);
}
return(RedirectToAction(nameof(Index)));
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Categoria não encontrada.", TipoMensagem.Erro);
return(RedirectToAction(nameof(Index)));
}
}
public async Task <IActionResult> Delete(int id)
{
var cliente = await _context.Clientes.FindAsync(id);
if (cliente != null)
{
_context.Clientes.Remove(cliente);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Cliente excluído com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Não foi possível excluir o cliente.", TipoMensagem.Erro);
}
return(RedirectToAction(nameof(Index)));
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Cliente não encontrado.", TipoMensagem.Erro);
return(RedirectToAction(nameof(Index)));
}
}
public async Task <IActionResult> Excluir(int id)
{
var pedido = await _context.Pedidos.FindAsync(id);
if (pedido != null)
{
_context.Pedidos.Remove(pedido);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Pedido excluído com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Não foi possível excluir o pedido.", TipoMensagem.Erro);
}
return(RedirectToAction(nameof(Index), new { cid = pedido.IdCliente }));
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Pedido não encontrado.", TipoMensagem.Erro);
return(RedirectToAction(nameof(Index), "Cliente"));
}
}
public async Task <IActionResult> Index(int?cid)
{
if (cid.HasValue)
{
var cliente = await _context.Clientes.FindAsync(cid);
if (cliente != null)
{
_context.Entry(cliente).Collection(c => c.Enderecos).Load();
ViewBag.Cliente = cliente;
return(View(cliente.Enderecos));
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Cliente não encontrado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Só é possível mostrar endereços de um cliente específico.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
}
public async Task <IActionResult> Create([FromForm] int?idUsuario,
[FromForm] EnderecoModel endereco)
{
if (idUsuario.HasValue)
{
var cliente = await _context.Clientes.FindAsync(idUsuario);
ViewBag.Cliente = cliente;
if (ModelState.IsValid)
{
if (cliente.Enderecos.Count() == 0)
{
endereco.Selecionado = true;
}
endereco.CEP = ObterCepNormalizado(endereco.CEP);
if (endereco.IdEndereco > 0)
{
if (endereco.Selecionado)
{
cliente.Enderecos.ToList().ForEach(e => e.Selecionado = false);
}
if (EnderecoExiste(idUsuario.Value, endereco.IdEndereco))
{
var enderecoAtual = cliente.Enderecos
.FirstOrDefault(e => e.IdEndereco == endereco.IdEndereco);
_context.Entry(enderecoAtual).CurrentValues.SetValues(endereco);
if (_context.Entry(enderecoAtual).State == EntityState.Unchanged)
{
TempData["mensagem"] = MensagemModel.Serializar("Nenhum dado do endereço foi alterado.");
}
else
{
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Endereço alterado com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Erro ao alterar endereço.");
}
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Endereço não encontrado.", TipoMensagem.Erro);
}
}
else
{
var idEndereco = cliente.Enderecos.Count() > 0 ? cliente.Enderecos.Max(e => e.IdEndereco) + 1 : 1;
endereco.IdEndereco = idEndereco;
_context.Clientes.FirstOrDefault(c => c.IdUsuario == idUsuario).Enderecos.Add(endereco);
if (await _context.SaveChangesAsync() > 0)
{
TempData["mensagem"] = MensagemModel.Serializar("Endereço cadastrado com sucesso.");
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Erro ao cadastrar endereço.");
}
}
return(RedirectToAction("Index", "Endereco", new { cid = idUsuario }));
}
else
{
return(View(endereco));
}
}
else
{
TempData["mensagem"] = MensagemModel.Serializar("Nenhum proprietário de endereços foi informado.", TipoMensagem.Erro);
return(RedirectToAction("Index", "Cliente"));
}
}