public async Task <int> InserirEditar(ProdutoInserirEditarDto produtoDto)
{
await _validarProduto.ValidateAndThrowAsync(produtoDto);
Produto produto = null;
if (produtoDto.Id == null)
{
produto = new Produto();
_lojaContext.Add(produto);
}
else
{
produto = await _lojaContext
.Set <Produto>()
.Where(p => p.Id == produtoDto.Id)
.FirstOrDefaultAsync();
ChecarSe.Encontrou(produto);
}
produto.Descricao = produtoDto.Descricao;
produto.Valor = produtoDto.Valor;
await _lojaContext.SaveChangesAsync();
return(produto.Id);
}
public async Task <IActionResult> Edit([Bind("ID,UsuarioId,Data")] Pedido pedido)
{
if (ModelState.IsValid)
{
try
{
_context.Update(pedido);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PedidoExists(pedido.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["UsuarioId"] = new SelectList(_context.Usuarios, "ID", "ID", pedido.UsuarioId);
return(View(pedido));
}
public async Task <IActionResult> PutConsultor([FromRoute] int id, [FromBody] Consultor consultor)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != consultor.Id)
{
return(BadRequest());
}
_context.Entry(consultor).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ConsultorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <int> Inserir(ClienteDto clienteDto)
{
if (string.IsNullOrWhiteSpace(clienteDto.Nome))
{
throw new ValidationException("Nome", "Preencha o nome");
}
//cliente.Id = GerarProximoId();
var cliente = new Cliente();
cliente.Nome = clienteDto.Nome.ToUpper();
cliente.CpfOuCnpj = clienteDto.CpfOuCnpj.Trim();
cliente.DataNascimento = clienteDto.DataNascimento;
if (clienteDto.Telefones != null)
{
foreach (var telefoneDto in clienteDto.Telefones)
{
var telefone = new ClienteTelefone();
telefone.Numero = telefoneDto.Numero;
cliente.Telefones.Add(telefone);
}
}
_lojaContext.Add(cliente);
await _lojaContext.SaveChangesAsync();
return(cliente.Id);
}
public async Task <IActionResult> JogarPedido([Bind("tipoProdutoId,nome,qtd")] TipoProduto tipoProduto)
{
Confeccao confeccao = new Confeccao(tipoProduto);
_context.Update(confeccao);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Create([Bind("IdLoja,CNPJ,Nome_Completo")] Loja loja)
{
if (ModelState.IsValid)
{
_context.Add(loja);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(loja));
}
public async Task <IActionResult> Create([Bind("ID,Nome,Cpf,Email")] Usuario usuario)
{
if (ModelState.IsValid)
{
_context.Add(usuario);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(usuario));
}
public async Task <IActionResult> Create([Bind("Id,CdCl,DsNome,IdTipo,CdVend,DsLim")] Clientes clientes)
{
if (ModelState.IsValid)
{
_context.Add(clientes);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(clientes));
}
public async Task <IActionResult> Create([Bind("Id,Nome,Preco")] Produto produto)
{
if (ModelState.IsValid)
{
_context.Add(produto);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(produto));
}
public async Task <IActionResult> Create([Bind("RoupaId,Nome,Quantidade")] Roupa roupa)
{
if (ModelState.IsValid)
{
_context.Add(roupa);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(roupa));
}
public async Task <IActionResult> Create([Bind("Id,CdVend,DsNome,CdTab,DtNasc")] Vendedores vendedores)
{
if (ModelState.IsValid)
{
_context.Add(vendedores);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(vendedores));
}
public async Task <IActionResult> Create([Bind("confeccaoId,tipoProdutoId,data")] Confeccao confeccao)
{
if (ModelState.IsValid)
{
_context.Add(confeccao);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["tipoProdutoId"] = new SelectList(_context.Set <TipoProduto>(), "tipoProdutoId", "tipoProdutoId", confeccao.tipoProdutoId);
return(View(confeccao));
}
public async Task <IActionResult> Create([Bind("PedidoId,RoupaId,Data")] Pedido pedido)
{
if (ModelState.IsValid)
{
_context.Add(pedido);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["RoupaId"] = new SelectList(_context.Set <Roupa>(), "RoupaId", "RoupaId", pedido.RoupaId);
return(View(pedido));
}
public async Task <IActionResult> Create([Bind("EnrollmentID,VendedoresID,ClientesID")] Enrollment enrollment)
{
if (ModelState.IsValid)
{
_context.Add(enrollment);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ClientesID"] = new SelectList(_context.Clientes, "Id", "Id", enrollment.ClientesID);
ViewData["VendedoresID"] = new SelectList(_context.Vendedores, "Id", "Id", enrollment.VendedoresID);
return(View(enrollment));
}
public async Task <int> Handle(Command request, CancellationToken cancellationToken)
{
await _validar.ValidateAndThrowAsync(request);
Produto produto;
if (request.Id == null)
{
produto = new Produto();
_lojaContext.Add(produto);
}
else
{
produto = await _lojaContext
.Set <Produto>()
.FirstOrDefaultAsync(p => p.Id == request.Id);
ChecarSe.Encontrou(produto);
}
Mapear(produto, request);
await _lojaContext.SaveChangesAsync();
return(produto.Id);
}
public async Task RemovePhysical(T obj)
{
try
{
using (DbContext = new LojaContext())
{
DbContext.Configuration.AutoDetectChangesEnabled = false;
DbContext.Entry(obj).State = EntityState.Deleted;
await DbContext.SaveChangesAsync();
DbContext.Configuration.AutoDetectChangesEnabled = true;
}
}
catch (Exception ex)
{
if (ex.Message == "An error occurred while updating the entries. See the inner exception for details.")
{
throw new Exception("Não é possivel excluir Existem Cadastro Relacionados");
}
else
{
throw new Exception(ex.Message);
}
}
}
public async Task <IActionResult> PutCliente([FromRoute] int id, [FromBody] Cliente cliente)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != cliente.Id)
{
return(BadRequest());
}
_context.Entry(cliente).State = EntityState.Modified;
foreach (var telefone in cliente.Telefones)
{
if (telefone.Id > 0)
{
_context.Entry(telefone).State = EntityState.Modified;
}
else
{
_context.Entry(telefone).State = EntityState.Added;
}
}
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClienteExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task RemoveLogic(int id, T obj)
{
using (DbContext = new LojaContext())
{
DbContext.Configuration.AutoDetectChangesEnabled = false;
DbContext.Entry(obj).State = EntityState.Modified;
await DbContext.SaveChangesAsync();
DbContext.Configuration.AutoDetectChangesEnabled = true;
}
}
public async Task Add(T obj)
{
using (DbContext = new LojaContext())
{
DbContext.Configuration.AutoDetectChangesEnabled = false;
DbContext.Set <T>().Add(obj);
await DbContext.SaveChangesAsync();
DbContext.Configuration.AutoDetectChangesEnabled = true;
}
}
protected override async Task Handle(Command request, CancellationToken cancellationToken)
{
var produto = await _lojaContext
.Set <Produto>()
.FirstOrDefaultAsync(p => p.Id == request.Id);
ChecarSe.Encontrou(produto);
_lojaContext.Remove(produto);
await _lojaContext.SaveChangesAsync();
}
public async Task Update(T obj)
{
new Util <T>().SetUpdateObject(ref obj);
using (DbContext = new LojaContext())
{
DbContext.Configuration.AutoDetectChangesEnabled = false;
DbContext.Entry(obj).State = EntityState.Modified;
await DbContext.SaveChangesAsync();
DbContext.Configuration.AutoDetectChangesEnabled = true;
}
}
public async Task Add(List <T> obj)
{
using (DbContext = new LojaContext())
{
foreach (var item in obj)
{
DbContext.Configuration.AutoDetectChangesEnabled = false;
DbContext.Set <T>().Add(item);
await DbContext.SaveChangesAsync();
DbContext.Configuration.AutoDetectChangesEnabled = true;
}
}
}
public async Task <IActionResult> Create(Pedido pedido, int[] produtos)
{
var produtosComprados = new List <Produto>();
foreach (var produtoId in produtos)
{
var prod = _context.Produtos.Find(produtoId);
produtosComprados.Add(prod);
}
var pedidoNovo = new Pedido
{
UsuarioId = pedido.UsuarioId,
Data = DateTime.Now
};
_context.Pedidos.Add(pedidoNovo);
_context.SaveChanges();
foreach (var produto in produtosComprados)
{
var itemPedido = new ItemPedido();
}
_context.ItemPedidos.Add(itemPedido);
_context.SaveChanges();
if (ModelState.IsValid)
{
_context.Add(pedido);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["UsuarioId"] = new SelectList(_context.Usuarios, "Id", "Id", pedido.UsuarioId);
return(View(pedido));
}
public async Task <IActionResult> Inserir([FromBody] ClienteDto clienteDto)
{
if (clienteDto.Nome == null)
{
ModelState.AddModelError("Nome", "Preencha o nome");
}
if (ModelState.IsValid == false)
{
return(BadRequest(ModelState.ObterErros()));
}
//cliente.Id = GerarProximoId();
var cliente = new Cliente();
cliente.Nome = clienteDto.Nome.ToUpper();
cliente.CpfOuCnpj = clienteDto.CpfOuCnpj.Trim();
cliente.DataNascimento = clienteDto.DataNascimento;
if (clienteDto.Telefones != null)
{
foreach (var telefoneDto in clienteDto.Telefones)
{
var telefone = new ClienteTelefone();
telefone.Numero = telefoneDto.Numero;
cliente.Telefones.Add(telefone);
}
}
_lojaContext.Add(cliente);
await _lojaContext.SaveChangesAsync();
return(Json(cliente.Id));
}
public async Task Update(List <T> obj)
{
foreach (var item in obj.ToArray())
{
var itemObj = item;
new Util <T>().SetUpdateObject(ref itemObj);
using (DbContext = new LojaContext())
{
DbContext.Configuration.AutoDetectChangesEnabled = false;
DbContext.Entry(itemObj).State = EntityState.Modified;
await DbContext.SaveChangesAsync();
DbContext.Configuration.AutoDetectChangesEnabled = true;
}
}
}
public async Task <bool> CommitAsync()
{
return(await _context.SaveChangesAsync() > 0);
}
