/// <summary>
/// Metodo responsavel por salvar o orgao
/// </summary>
/// <param name="OrdemCompra"></param>
/// <returns></returns>
public OrdemCompra SalvaOrdemCompra(OrdemCompra ordemCompra)
{
db.OrdensCompras.Add(ordemCompra);
db.SaveChanges();
return ordemCompra;
}
public async Task <int> Editar(OrdemCompraVM ordemVM)
{
try
{
var itemsOrdem = new List <ItemOrdemCompra>();
foreach (var item in ordemVM.ItemsOrdemCompraVM)
{
Guid idItemOrdemCompra;
if (item.Id == Guid.Empty || item.Id == null)
{
idItemOrdemCompra = Guid.NewGuid();
}
else
{
idItemOrdemCompra = item.Id.GetValueOrDefault();
}
itemsOrdem.Add(new ItemOrdemCompra(idItemOrdemCompra, item.Quantidade, item.Preco, item.SubTotal, item.IdProduto, ordemVM.Id));
}
var ordemParaEdicao = new OrdemCompra(ordemVM.Id, ordemVM.DataEntrada, ordemVM.IdFornecedor, itemsOrdem, ordemVM.ValorTotal, Guid.NewGuid());
return(await _repository.Editar(ordemParaEdicao));
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public void AtualizarStatus(OrdemCompra ordem)
{
try
{
AtivarCliente();
var comando = @"UPDATE [dbo].[OrdemCompra]
SET [Status] = @status
WHERE Id = @id";
var @ordemParam = new
{
ordem.Id,
Status = ordem.Status.ToString()
};
var result = _clienteSQL.Execute(comando, @ordemParam);
}
catch (Exception ex)
{
throw ex;
}
finally
{
DesativarCliente();
}
}
private void Buscar_Click(object sender, EventArgs e)
{
string col = "";
string valor = txtPesquisa.Text;
bool like = false;
switch (selecCampo.SelectedItem.ToString())
{
case "Número":
col = "Numero";
break;
case "Nome":
col = "nome";
like = true;
break;
case "Todos":
Recarrega();
break;
}
if (selecCampo.SelectedItem.ToString() != "Todos" && txtPesquisa.Text != "")
{
OrdemCompra comp = new OrdemCompra();
comp.Buscar(dataGridViewComp, col, valor, like);
}
}
public async Task <int> Inserir(OrdemCompra ordem)
{
try
{
OrdemCompra ordemCompra = new OrdemCompra(
ordem.DataEntrada,
ordem.IdFornecedor,
ordem.ItemsOrdemCompra,
ordem.ValorTotal,
ordem.IdUsuarioLogado
);
var itemsOrdem = ordem.ItemsOrdemCompra.Select(i => new ItemOrdemCompra
{
Id = Guid.NewGuid(),
Quantidade = i.Quantidade,
Preco = i.Preco,
SubTotal = i.SubTotal,
IdProduto = i.IdProduto,
IdOrdemCompra = ordemCompra.Id
}).ToList();
ordemCompra.ItemsOrdemCompra = itemsOrdem;
_context.OrdemCompras.Add(ordemCompra);
return(await SalvarCommit());
}
catch (MySqlException e)
{
_context.Dispose();
throw new Exception(e.Message);
}
}
/// <summary>
/// Metodo responsavel por alterar o orgao
/// </summary>
/// <param name="orgao"></param>
public OrdemCompra AlteraOrdemCompra(OrdemCompra ordemCompra)
{
db.Entry<OrdemCompra>(ordemCompra).State = EntityState.Modified;
db.SaveChanges();
return ordemCompra;
}
// GET: OrdemCompra/Create
public ActionResult Create()
{
ViewBag.IdFornecedor = new SelectList(db.Fornecedor, "Id", "Nome");
var oc = new OrdemCompra();
oc.DataCriacao = DateTime.Now;
return(View(oc));
}
public ActionResult DeleteConfirmed(int id)
{
OrdemCompra ordemCompra = db.OrdemCompra.Find(id);
db.OrdemCompra.Remove(ordemCompra);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "Id,DescricaoCurta,DescricaoLonga,DataCriacao,DataEdicao,IdFornecedor")] OrdemCompra ordemCompra)
{
if (ModelState.IsValid)
{
db.Entry(ordemCompra).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.IdFornecedor = new SelectList(db.Fornecedor, "Id", "Nome", ordemCompra.IdFornecedor);
return(View(ordemCompra));
}
private void btnConfirmar_Click(object sender, EventArgs e)
{
if (MessageBox.Show(("Tem certeza que deseja realizar as alterações?"), "Atualizar Compra", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation) == DialogResult.Yes)
{
OrdemCompra compra = new OrdemCompra();
compra.Atendida = radioButton1.Checked;
compra.Atualizar(id);
}
panel4.Visible = true;
btnAtualizar.Visible = true;
}
private Cliente ObterClienteInformadoNaOrdem(OrdemCompra novaOrdemCompra)
{
var cliente = _repositorioObterClientesPorId.Obter(novaOrdemCompra.Cliente.Id);
if (cliente == null)
{
throw new Exception("Cliente informado não encontrado");
}
return(cliente);
}
public void Recarrega()
{
try
{
OrdemCompra comp = new OrdemCompra();
comp.Listar(dataGridViewComp);
}
catch (Exception errosel)
{
MessageBox.Show("Erro ao Buscar: " + errosel);
}
}
private void ProcessarEnvioOrdem(OrdemCompra ordem, Produto produtoOrdem)
{
_repositorioEnviarOrdemParaProcessadora.Enviar(ordem);
produtoOrdem.AtualizarEstoque(ordem.QuantidadeSolicitada);
_repositorioAtualizarEstoqueProduto.AtualizarEstoque(produtoOrdem);
ordem.FecharOrdem();
_repositorioAtualizarStatusOrdem.AtualizarStatus(ordem);
}
public async Task <bool> AlterarOrdemDeCompra(OrdemCompra ordemCompra)
{
var index = await GetIndexOrdemCompra(
await ConsultarPorId(ordemCompra.Id));
await Task.Run(() => _dataStore.OrdensCompras[index] = ordemCompra);
return(await Task.Run(() =>
_dataStore
.OrdensCompras
.Any(a => a.Equals(ordemCompra))));
}
/// <summary>
/// Altera a ordem de compra. Por ser mockado, remove o item anterior e insere um novo, simulando uma substituição.
/// </summary>
/// <param name="ordemCompra">Ordem de compra com os novos dados</param>
/// <returns>true se sucesso, false se não encontrou o item com mesmo ID para atualizar.</returns>
public async Task <bool> AlterarOrdemCompra(OrdemCompra ordemCompra)
{
var ordemCompraDb = await ConsultarPorId(ordemCompra.Id).ConfigureAwait(false);
if (ordemCompraDb == null)
{
return(false);
}
_dataStore.OrdensCompras.Remove(ordemCompraDb);
_dataStore.OrdensCompras.Add(ordemCompra);
return(true);
}
public async Task <IActionResult> Post([FromBody] OrdemCompra ordemCompra)
{
try
{
var result = await _ordemCompraServico.RegistrarOrdemCompra(ordemCompra.ClienteId, ordemCompra.ProdutoId, ordemCompra.QuantidadeSolicitada);
return(Created(string.Empty, result));
}
catch (Exception ex)
{
return(BadRequest(new { message = ex.ToString() }));
}
}
public bool ExisteOrdemCompra(Guid id)
{
OrdemCompra ordemCompra = null;
try
{
ordemCompra = _context.OrdemCompras.Where(x => x.Id == id).FirstOrDefault();
return(ordemCompra != null);
}
catch (MySqlException ex)
{
throw new Exception(ex.Message);
}
}
// GET: OrdemCompra/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
OrdemCompra ordemCompra = db.OrdemCompra.Find(id);
if (ordemCompra == null)
{
return(HttpNotFound());
}
return(View(ordemCompra));
}
private void GravarOrdemCompra()
{
var oc = new OrdemCompra();
oc.DataCriacao = this.DataCriacao;
oc.DataEdicao = this.DataEdicao;
oc.DescricaoCurta = this.Descricao;
oc.DescricaoLonga = this.DescricaoLonga;
oc.IdFornecedor = this.IdFornecedor;
db.OrdemCompra.Add(oc);
db.SaveChanges();
this.Id = oc.Id;
}
// GET: OrdemCompra/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
OrdemCompra ordemCompra = db.OrdemCompra.Find(id);
if (ordemCompra == null)
{
return(HttpNotFound());
}
ViewBag.IdFornecedor = new SelectList(db.Fornecedor, "Id", "Nome", ordemCompra.IdFornecedor);
return(View(ordemCompra));
}
public void CriarOrdem(OrdemCompra novaOrdemCompra)
{
try
{
AtivarCliente();
var comando = @"INSERT INTO [dbo].[OrdemCompra]
([Id]
,[DataOperacao]
,[QuantidadeSolicitada]
,[ValorOperacao]
,[PrecoUnitario]
,[ClienteID]
,[ProdutoID]
,[Status])
VALUES
(@Id
,@DataOperacao
,@QuantidadeSolicitada
,@ValorOperacao
,@PrecoUnitario
,@ClienteID
,@ProdutoID
,@Status)";
var @ordem = new
{
novaOrdemCompra.Id,
novaOrdemCompra.DataOperacao,
novaOrdemCompra.QuantidadeSolicitada,
novaOrdemCompra.ValorOperacao,
novaOrdemCompra.PrecoUnitario,
ClienteID = novaOrdemCompra.Cliente.Id,
ProdutoID = novaOrdemCompra.Produto.Id,
Status = novaOrdemCompra.Status.ToString()
};
var result = _clienteSQL.Execute(comando, @ordem);
}
catch (Exception ex)
{
throw ex;
}
finally
{
DesativarCliente();
}
}
public void CriarOrdem(OrdemCompra novaOrdemCompra)
{
try
{
CarregarProdutoInformadoNaOrdem(novaOrdemCompra);
var cliente = ObterClienteInformadoNaOrdem(novaOrdemCompra);
novaOrdemCompra.AtribuirCliente(cliente);
_repositorioCriarOrdemCompra.CriarOrdem(novaOrdemCompra);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <string> RegistrarOrdemCompra(string clienteId, int produtoId, int quantidadeCompra)
{
var cliente = await _clienteRepositorio.ConsultarPorId(clienteId).ConfigureAwait(false);
var produto = await _produtoRepositorio.ConsultarPorId(produtoId).ConfigureAwait(false);
if (quantidadeCompra <= 0)
{
throw new InvalidOperationException("Quantidade solicitada não suficiente para compra.");
}
if (produto.Estoque <= 0)
{
throw new InvalidOperationException("Quantidade em estoque não suficiente para compra.");
}
var valorOperacao = Math.Round(decimal.Parse(produto.PrecoUnitario) * quantidadeCompra, 2);
if (valorOperacao > cliente.Saldo)
{
throw new InvalidOperationException("Cliente não possui saldo suficiente para compra.");
}
if (Math.Round(quantidadeCompra * decimal.Parse(produto.PrecoUnitario), 2) < produto.ValorMinimoDeCompra)
{
throw new InvalidOperationException("Quantidade mínima não atendida para compra.");
}
if (valorOperacao > produto.Estoque)
{
throw new InvalidOperationException("Quantidade em estoque não suficiente para compra.");
}
var novaOrdemDeCompra = new OrdemCompra
{
ClienteId = cliente.Id,
ProdutoId = produto.Id,
DataOperacao = DateTime.Now,
PrecoUnitario = decimal.Parse(produto.PrecoUnitario),
ValorOperacao = valorOperacao,
QuantidadeSolicitada = quantidadeCompra
};
return(await _ordemCompraRepositorio.RegistrarOrdemCompra(novaOrdemDeCompra).ConfigureAwait(false));
}
public async Task <int> Excluir(Guid id)
{
try
{
OrdemCompra ordemCompra = null;
ordemCompra = await BuscarPorId(id);
if (ordemCompra != null)
{
_context.Remove(ordemCompra);
}
return(await SalvarCommit());
}
catch (MySqlException e)
{
throw new Exception(e.Message);
}
}
public async Task <ActionResult <string> > Post([FromBody] OrdemCompra ordemCompra)
{
try
{
var id = await _ordemCompraServico.RegistrarOrdemCompra(ordemCompra.ClienteId, ordemCompra.ProdutoId, ordemCompra.QuantidadeSolicitada);
return(Created(string.Empty, id));
}
catch (InvalidOperationException ex)
{
_logger.Log($"Erro ao criar ordem de compra. {ex}", EventLevel.Warning);
return(BadRequest(ex.Message));
}
catch (Exception ex)
{
_logger.Log($"Erro ao criar ordem de compra. {ex}", EventLevel.Error);
throw; //deixar subir o erro para retornar 500
}
}
private void CarregarProdutoInformadoNaOrdem(OrdemCompra novaOrdemCompra)
{
var produto = _repositorioObterProdutosPorId.Obter(novaOrdemCompra.Produto.Id);
if (produto != null)
{
if (!produto.ExisteEstoque(novaOrdemCompra.QuantidadeSolicitada))
{
throw new Exception("O produto informado não disponível para compra");
}
novaOrdemCompra.AtribuirProduto(produto);
if (!produto.CompraPossuiValorMinimo(novaOrdemCompra.ValorOperacao))
{
throw new Exception("O produto informado não disponível");
}
}
else
{
throw new Exception("O produto informado não encontrado");
}
}
public async Task <Result> RegistrarOrdemCompra(int clienteId, int produtoId, int quantidadeCompra)
{
var cliente = await _clienteRepositorio.ConsultarPorId(clienteId).ConfigureAwait(false);
var produto = await _produtoRepositorio.ConsultarPorId(produtoId).ConfigureAwait(false);
var novaOrdemDeCompra = OrdemCompra.CriarSolicitacaoOrdemDeCompra(
produto,
cliente,
quantidadeCompra);
if (!novaOrdemDeCompra.EhValido)
{
return(Result <string>
.Fail(novaOrdemDeCompra
.Notifications
.Select(s => s.Message)));
}
var id = await _ordemCompraRepositorio.RegistrarOrdemCompra(novaOrdemDeCompra).ConfigureAwait(false);
return(Result <Guid> .Ok(id));
}
public async Task <bool> AlterarOrdemCompra(OrdemCompra ordemCompra)
{
throw await Task.Run(() => new NotImplementedException());
}
public async Task <string> RegistrarOrdemCompra(OrdemCompra ordemCompra)
{
await Task.Run(() => _dataStore.OrdensCompras.Add(ordemCompra)).ConfigureAwait(false);
return(ordemCompra.Id);
}
public Task <bool> AlterarOrdemCompra(OrdemCompra ordemCompra)
{
throw new NotImplementedException();
}
