public string DeletarVenda(long idVenda)
{
try
{
var venda = VendaRepositorio.Buscar(idVenda);
if (venda.Situacao == SituacaoVenda.Pago)
{
return("Impossivel excluir uma venda paga!");
}
var preVenda = PreVendaRepositorio.Filtrar(d => d.IdVenda == idVenda).ToList();
if (preVenda != null)
{
preVenda.ForEach(d => PreVendaRepositorio.Excluir(d));
}
var itemVenda = ItemVendaRepositorio.Filtrar(d => d.IdVenda == idVenda).ToList();
if (itemVenda != null)
{
itemVenda.ForEach(d => ItemVendaRepositorio.Excluir(d));
}
if (venda != null)
{
VendaRepositorio.Excluir(venda);
}
var linhas = Contexto.Salvar();
return("");
}
catch (Exception ex)
{
return("Erro ao tentar excluir Venda. Tente novamente!");
}
}
//[Inject]
//public UsuarioAplicacao UsuarioAplicacao { get; set; }
public PaginacaoModel2 <Venda, PreVenda, FiltroVenda> ObterDetalhesVenda
(PaginacaoModel2 <Venda, PreVenda, FiltroVenda> paginacaoModel, long idVenda)
{
paginacaoModel.ListaModel2 = PreVendaRepositorio.Filtrar(d => d.IdVenda == idVenda).ToList();
paginacaoModel.NomeCliente = VendaRepositorio.Filtrar(d => d.Id == idVenda).Select(d => d.Cliente.Nome).FirstOrDefault();
return(paginacaoModel);
}
public string Buscar(int?idProduto, int?idCliente)
{
var repositorio = new VendaRepositorio();
var resultado = repositorio.BuscarVenda(idProduto, idCliente);
return(JsonConvert.SerializeObject(resultado));
}
public void AtualizaPendencias(PendenciasCliente pendenciasCliente, Pagamento pagamento)
{
if (pendenciasCliente.CashGames != null)
{
foreach (var cash in pendenciasCliente.CashGames)
{
cash.Situacao = Dominio.Enumeradores.SituacaoVenda.Pago;
cash.Pagamento = pagamento;
CashGameRepositorio.Atualizar(cash);
}
}
if (pendenciasCliente.TorneiosCliente != null)
{
foreach (var torneio in pendenciasCliente.TorneiosCliente)
{
torneio.Situacao = Dominio.Enumeradores.SituacaoVenda.Pago;
torneio.Pagamento = pagamento;
TorneioClienteRepositorio.Atualizar(torneio);
}
}
if (pendenciasCliente.Vendas != null)
{
foreach (var vendaModel in pendenciasCliente.Vendas)
{
var venda = VendaRepositorio.Buscar(vendaModel.IdVenda);
venda.Situacao = Dominio.Enumeradores.SituacaoVenda.Pago;
venda.Pagamento = pagamento;
VendaRepositorio.Atualizar(venda);
}
}
}
public string Cadastrar(int idProduto, int idCliente, int qtde)
{
var repositorio = new VendaRepositorio();
var resultado = repositorio.CadastrarVenda(idProduto, idCliente, qtde);
return(JsonConvert.SerializeObject(resultado));
}
public ActionResult Produto(VendaViewModel viewModel)
{
vendaDB = new VendaRepositorio();
return(View(new PordutoComandaViewModel()
{
Comanda = vendaDB.GetComandaPorCodigo(viewModel.Comanda.Codigo),
Produto = vendaDB.GetProdutoPorCodigo(viewModel.Produto.Codigo)
}));
}
public bool ExisteOperacaoPendente(DateTime dataCaixa)
{
var result = CashGameRepositorio.Filtrar(d => d.Situacao == Dominio.Enumeradores.SituacaoVenda.Pendente && d.DataCadastro >= dataCaixa).Any();
if (result)
{
return(result);
}
result = TorneioClienteRepositorio.Filtrar(d => d.Situacao == Dominio.Enumeradores.SituacaoVenda.Pendente && d.DataCadastro >= dataCaixa).Any();
if (result)
{
return(result);
}
return(VendaRepositorio.Filtrar(d => d.Situacao == Dominio.Enumeradores.SituacaoVenda.Pendente && d.DataVenda >= dataCaixa).Any());
}
private VendaViewModel FillViewModel()
{
vendaDB = new VendaRepositorio();
return(new VendaViewModel()
{
Caixa = vendaDB.GetCaixa,
Cliente = vendaDB.GetCliente(),
TipoPagamento = vendaDB.GetTipoPagamento(),
Permissao = vendaDB.GetPermissao,
Comanda = vendaDB.GetComanda,
Fiado = vendaDB.GetFiado,
Usuario = vendaDB.GetUsuarios,
VendaNaComanda = vendaDB.GetVendaComComandaAtiva,
Produto = vendaDB.GetProduto
});
}
private Venda GravarVenda(long idCliente, List <PreVenda> preVendas)
{
var venda = new Venda
{
Cliente = ClienteAplicacao.BuscarClientePorId(idCliente),
DataVenda = DateTime.Now,
IdUsuario = AutenticacaoAplicacao.ObterUsuarioLogado().Id,
QtdItem = RetornaQtdTotalVenda(preVendas.Select(d => d.Quantidade).ToList()),
Valor = RetornaValorTotalVenda(preVendas)
};
VendaRepositorio.Cadastrar(venda);
GravarItemVenda(preVendas, venda);
preVendas.ForEach(d => d.Venda = venda);
preVendas.ForEach(d => PreVendaRepositorio.Atualizar(d));
return(venda);
}
public PaginacaoModel2 <Venda, PreVenda, FiltroVenda> FiltrarVenda(PaginacaoModel2 <Venda, PreVenda, FiltroVenda> paginacao)
{
if (paginacao.Filtro == null)
{
paginacao.Filtro = new FiltroVenda(paginacao.Parametro1, paginacao.Parametro12, paginacao.Parametro13);
}
else
{
paginacao.Parametro1 = paginacao?.Filtro?.NomeCliente;
paginacao.Parametro12 = paginacao?.Filtro?.CodigoCliente;
paginacao.Parametro13 = paginacao?.Filtro?.ApelidoCliente;
}
var dataCaixa = CaixaAplicacao.ObterDataCaixaAtivo();
if (dataCaixa == DateTime.MinValue)
{
dataCaixa = DateTime.Now;
}
var query = VendaRepositorio.Query().Where(d => d.DataVenda >= dataCaixa);
if (paginacao.Filtro.NomeCliente.TemValor())
{
query = query.Where(d => d.Cliente.Nome.Contains(paginacao.Filtro.NomeCliente));
}
if (paginacao.Filtro.CodigoCliente.TemValor())
{
query = query.Where(d => d.Cliente.Codigo.Contains(paginacao.Filtro.CodigoCliente));
}
if (paginacao.Filtro.ApelidoCliente.TemValor())
{
query = query.Where(d => d.Cliente.Apelido.Contains(paginacao.Filtro.ApelidoCliente));
}
paginacao.ListaModel = query.OrderBy(d => d.Id).Skip(((paginacao.Pagina - 1) * 10)).Take(10).ToList();
paginacao.QtdPaginas = query.Count().CalculaQtdPaginas().TransformaEmLista();
foreach (var item in paginacao.ListaModel)
{
if (item?.Cliente == null)
{
item.Cliente = ClienteAplicacao.BuscarClientePorId(item.IdCliente);
}
}
return(paginacao);
}
public PendenciasCliente ObterPendenciaCliente(long idCliente)
{
var pendencias = new PendenciasCliente
{
CashGames = CashGameRepositorio.ObterCashGamesPendente(idCliente),
TorneiosCliente = ObterItensTorneioModel(TorneioClienteRepositorio.ObterTorneioClientePendente(idCliente)),
Vendas = VendaRepositorio.ObterVendaModelPendente(idCliente),
Pagamentos = PagamentoRepositorio.ObterPagamentosPendentes(idCliente)
};
pendencias.IdCliente = idCliente;
var cliente = ClienteRepositorio.Filtrar(d => d.Id == idCliente).Select(d => new { Nome = d.Nome, Saldo = d.Saldo }).FirstOrDefault();
pendencias.NomeCliente = cliente.Nome;
pendencias.Saldo = cliente.Saldo;
pendencias.ValorTotal = pendencias.CashGames.Sum(d => d.Valor);
pendencias.ValorTotal += pendencias.TorneiosCliente.Sum(d => d.ValorTotal - (d.ValorPago ?? 0));
pendencias.ValorTotal += pendencias.Vendas.Sum(d => d.Valor);
return(pendencias);
}
public ComprovanteModel ObterPagamentoCommpleto(long idPagamento)
{
var pagamento = ObterPagamentoCliente(idPagamento);
var cash = CashGameRepositorio.Filtrar(d => d.IdComprovantePagamento == idPagamento).ToList();
var parcelas = ParcelamentoPagamentoRepositorio.Filtrar(d => d.IdPagamento == idPagamento).ToList();
var vendas = VendaRepositorio.Filtrar(d => d.IdComprovantePagamento == idPagamento).ToList();
var torneioClientes = TorneioClienteRepositorio.Filtrar(d => d.IdComprovantePagamento == idPagamento).ToList();
torneioClientes.ForEach(t => CalculaValorTotal(t));
return(new ComprovanteModel
{
Pagamento = pagamento,
CashGames = cash,
IdCliente = pagamento.IdCliente,
NomeCliente = pagamento.Cliente.Nome,
ParcelamentoPagamentos = parcelas,
Vendas = vendas,
TorneiosCliente = torneioClientes
});
}
public PendenciasCliente ObterDetalhesPagamento(long idPagamento)
{
var detalhesPagamento = new PendenciasCliente();
detalhesPagamento.CashGames = CashGameRepositorio.Filtrar(d => d.IdComprovantePagamento == idPagamento).ToList();
detalhesPagamento.TorneiosCliente = PagamentosAplicacao.ObterItensTorneioModel(TorneiosClienteRepositorio.Filtrar(d => d.IdComprovantePagamento == idPagamento).ToList());
var idNomeCliente = PagamentoRepositorio.Filtrar(d => d.Id == idPagamento).Select(d => new { Nome = d.Cliente.Nome, Id = d.IdCliente, Saldo = d.Cliente.Saldo }).FirstOrDefault();
detalhesPagamento.IdCliente = idNomeCliente.Id;
detalhesPagamento.NomeCliente = idNomeCliente.Nome;
detalhesPagamento.Saldo = idNomeCliente.Saldo;
var vendas = VendaRepositorio.Filtrar(d => d.IdComprovantePagamento == idPagamento).ToList();
detalhesPagamento.Vendas = new List <VendaModel>();
detalhesPagamento.Parcelamentos = ParcelamentoPagamentoRepositorio.Filtrar(d => d.IdPagamento == idPagamento).ToList();
//if (detalhesPagamento.Parcelamentos.Count() == 1)
// detalhesPagamento.Parcelamentos = new List<ParcelamentoPagamento>();
foreach (var venda in vendas)
{
detalhesPagamento.Vendas.Add(new VendaModel(venda, PreVendaRepositorio));
}
return(detalhesPagamento);
}
private void InstanciarVendaRepositorio() => _vendaRepositorio = new VendaRepositorio();
public VendaController(VendaRepositorio vendaRepositorio)
{
_vendaRepositorio = vendaRepositorio;
}
public VendaServico()
{
_vendaRepositorio = new VendaRepositorio();
}
public VendaNegocio()
{
repositorio = new VendaRepositorio();
}
