public async Task <IActionResult> PutTituloContas([FromRoute] Guid id, [FromBody] TituloContas tituloContas)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != tituloContas.Id)
{
return(BadRequest());
}
_context.Entry(tituloContas).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TituloContasExists(id))
{
return(NotFound());
}
throw;
}
return(NoContent());
}
public async Task <IActionResult> PutProduto([FromRoute] int id, [FromBody] Produto produto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != produto.ProdutoID)
{
return(BadRequest());
}
_context.Entry(produto).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProdutoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public virtual async Task <T> Create(T item)
{
dataset.Add(item);
await _context.SaveChangesAsync();
return(item);
}
public async Task <IActionResult> PutFilial([FromRoute] Guid id, [FromBody] Filial filial)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != filial.Id)
{
return(BadRequest());
}
_context.Entry(filial).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FilialExiste(id))
{
return(NotFound());
}
throw;
}
return(NoContent());
}
public async Task SumarizarMovimentacoesDoUltimoMes()
{
var startOfTthisMonth = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1);
// First Second of first day of last month
var firstDayOfLastMonth = startOfTthisMonth.AddMonths(-1);
// Last Second of last day of last month
var lastDayOfLastMonth = startOfTthisMonth.AddTicks(-1);
var movimentacoesPorTipoNoUltimoMes = _context.Movimentacoes
.Where(m => m.Data >= firstDayOfLastMonth && m.Data <= lastDayOfLastMonth)
.Where(m => !m.IsCongelado)
.ToList();
var movimentacaoEntrada = new List <Movimento>();
var movimentacaoSaida = new List <Movimento>();
foreach (var item in movimentacoesPorTipoNoUltimoMes
.Where(m => m.MovimentacaoTipo == MovimentacaoTipo.eDevolucao)
.Where(m => m.MovimentacaoTipo == MovimentacaoTipo.eAquisicao)
.Where(m => m.MovimentacaoTipo == MovimentacaoTipo.eFabricacao)
)
{
}
var movSumarizado = (
from movimentacaoPorTipo in movimentacoesPorTipoNoUltimoMes
let somaTotalPorTipo = movimentacaoPorTipo.Sum(m => m.Valor * m.Quantidade)
select new MovimentoSumarizado {
Data = lastDayOfLastMonth, Valor = somaTotalPorTipo, MovimentacaoTipo = movimentacaoPorTipo.First().MovimentacaoTipo
}
).ToList();
await _context.MovimencoesSumarizadas.AddRangeAsync(movSumarizado);
await _context.SaveChangesAsync();
}
public async Task <IActionResult> PutVagaEstoque(int id, VagaEstoque vagaEstoque)
{
if (id != vagaEstoque.Id)
{
return(BadRequest());
}
_context.Entry(vagaEstoque).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VagaEstoqueExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutCliente(Guid id, Cliente cliente)
{
if (id != cliente.Id)
{
return(BadRequest());
}
_context.Entry(cliente).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClienteExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutTipoDeCarga(int id, TipoDeCarga tipoDeCarga)
{
if (id != tipoDeCarga.Id)
{
return(BadRequest());
}
_context.Entry(tipoDeCarga).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TipoDeCargaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutEstoqueRevista(Guid id, EstoqueRevista estoqueRevista)
{
if (id != estoqueRevista.Id)
{
return(BadRequest());
}
_context.Entry(estoqueRevista).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EstoqueRevistaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task VendaProduto(Produto produto, int quantidade, double valor)
{
// Cria um movimento de compra
var movimento = CriarMovimentoCompra(produto, quantidade, valor);
// Realiza tratamentos no produto
produto.Quantidade -= quantidade;
produto.PrecoMedio = GetProdutoPrecoMedioNovo(produto, quantidade, valor);
_context.Produtos.Update(produto);
// Cria o titulo inicial
var titulo = new TituloContas
{
Data = DateTime.Now,
ProdutoId = movimento.ProdutoId,
Saldo = movimento.Valor.Value,
Situacao = Dtos.Enums.TituloContasSituacao.Aberto,
ValorOriginal = movimento.Valor.Value,
CodigoTransacao = movimento.CodigoTransacao
};
await _context.TituloContas.AddAsync(titulo);
// Salva o movimento de compra
movimento.TituloContaId = titulo.Id;
await _context.Movimentacoes.AddAsync(movimento);
await _context.SaveChangesAsync();
}
public async Task <IActionResult> PutControle([FromRoute] Guid id, [FromBody] Controle controle)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != controle.Id)
{
return(BadRequest());
}
_context.Entry(controle).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ControleExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutFornecedor([FromRoute] int id, [FromBody] Fornecedor fornecedor)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != fornecedor.FornecedorID)
{
return(BadRequest());
}
_context.Entry(fornecedor).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FornecedorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public Task Handle(RevistaAdicionadaIntegrationEvent @event)
{
var revista = new Revista(@event.Id, @event.Ano, @event.Titulo);
var revistaEstoque = new EstoqueRevista(revista);
_estoqueContext.EstoqueRevistas.Add(revistaEstoque);
return(_estoqueContext.SaveChangesAsync());
}
public async Task <int> SaveChanges()
{
return(await _ctxDB.SaveChangesAsync());
}
public Task <int> SaveChangesAsync()
{
return(_context.SaveChangesAsync());
}
public async Task AddAsync(Produto item)
{
_context.Produtos.Add(item);
await _context.SaveChangesAsync();
}
public async Task AddAsync(Fornecedor item)
{
_context.Fornecedores.Add(item);
await _context.SaveChangesAsync();
}
public async Task AddAsync(Movimentacao item)
{
_context.Movimentacoes.Add(item);
await _context.SaveChangesAsync();
}
public async Task AddAsync(Estoque item)
{
_context.Estoques.Add(item);
await _context.SaveChangesAsync();
}
public async Task AddAsync(Cliente item)
{
_context.Clientes.Add(item);
await _context.SaveChangesAsync();
}