Ejemplo n.º 1
0
 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);
         }
     }
 }
Ejemplo n.º 2
0
        public void GeraPagamentoTorneioCliente(long idCliente)
        {
            var       torneiosCliente = ObterItensTorneioModel(TorneioClienteRepositorio.ObterTorneioClientePendente(idCliente));
            Pagamento pagamento       = null;

            //quita se valor for igual
            if (torneiosCliente.Sum(d => d.ValorTotal) == torneiosCliente.Sum(d => d.ValorPago))
            {
                pagamento = new Pagamento
                {
                    Data        = DateTime.Now,
                    IdCliente   = idCliente,
                    ValorAberto = 0,
                    ValorTotal  = torneiosCliente.Sum(d => d.ValorTotal),
                    Situacao    = SituacaoVenda.Pago
                };
            }
            //deixa pendente valor faltante
            else if (torneiosCliente.Sum(d => d.ValorTotal) > torneiosCliente.Sum(d => d.ValorPago))
            {
                pagamento = new Pagamento
                {
                    Data        = DateTime.Now,
                    IdCliente   = idCliente,
                    ValorAberto = torneiosCliente.Sum(d => d.ValorTotal) - torneiosCliente.Sum(d => d.ValorPago ?? 0),
                    ValorTotal  = torneiosCliente.Sum(d => d.ValorTotal),
                    Situacao    = SituacaoVenda.Pendente
                };
            }
            //deixa como saldo valor superior
            else if (torneiosCliente.Sum(d => d.ValorTotal) < torneiosCliente.Sum(d => d.ValorPago))
            {
                pagamento = new Pagamento
                {
                    Data        = DateTime.Now,
                    IdCliente   = idCliente,
                    ValorAberto = 0,
                    ValorTotal  = torneiosCliente.Sum(d => d.ValorTotal),
                    Situacao    = SituacaoVenda.Pago
                };
                AtualizaSaldoCliente(idCliente, torneiosCliente.Sum(d => d.ValorPago ?? 0) - torneiosCliente.Sum(d => d.ValorTotal));
            }
            if (pagamento != null)
            {
                var parcela = new ParcelamentoPagamento
                {
                    DataPagamento   = pagamento.Data,
                    IdCliente       = pagamento.IdCliente,
                    Pagamento       = pagamento,
                    TipoFinalizador = TipoFinalizador.Dinheiro,
                    ValorPago       = pagamento.ValorTotal - pagamento.ValorAberto
                };
                ParcelamentoPagamentoRepositorio.Cadastrar(parcela);
            }
            PagamentoRepositorio.Cadastrar(pagamento);
            AtualizaPendencias(new PendenciasCliente {
                TorneiosCliente = torneiosCliente, IdCliente = idCliente
            }, pagamento);
        }
        public TorneioCliente BuscarPorId(long id)
        {
            var torneioCliente = TorneioClienteRepositorio.Buscar(id);

            torneioCliente.NomeCliente = torneioCliente.Cliente.Nome;
            torneioCliente.NomeTorneio = torneioCliente?.Torneio?.Nome ?? "";
            CalculaValorTotal(torneioCliente);
            return(torneioCliente);
        }
 public void AtulizaClientesTorneio(List <TorneioCliente> torneioCliente)
 {
     foreach (var clienteModel in torneioCliente)
     {
         var cliente = TorneioClienteRepositorio.Buscar(clienteModel.Id);
         cliente.AtualizaDados(clienteModel);
         TorneioClienteRepositorio.Atualizar(cliente);
         if (clienteModel.Finalizar)
         {
             PagamentosAplicacao.GeraPagamentoTorneioCliente(clienteModel.IdCliente);
         }
         var row = Contexto.Salvar();
     }
 }
        Filtrar(PaginacaoModel <TorneioCliente, FiltroTorneioCliente> paginacao)
        {
            if (paginacao.Filtro == null)
            {
                paginacao.Filtro = new FiltroTorneioCliente(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 = TorneioClienteRepositorio.Query().Where(d => d.DataCadastro >= dataCaixa && d.Situacao != SituacaoVenda.Pago);

            paginacao.TotalJogadores = query.Count();

            if (paginacao.Filtro.CodigoCliente.TemValor())
            {
                query = query.Where(d => d.Cliente.Codigo == paginacao.Filtro.CodigoCliente);
            }
            if (paginacao.Filtro.NomeCliente.TemValor())
            {
                query = query.Where(d => d.Cliente.Nome.Contains(paginacao.Filtro.NomeCliente));
            }
            if (paginacao.Filtro.ApelidoCliente.TemValor())
            {
                query = query.Where(d => d.Cliente.Apelido.Contains(paginacao.Filtro.ApelidoCliente));
            }
            if (paginacao.Letra.TemValor())
            {
                if (!paginacao.Letra.Equals("todos"))
                {
                    query = query.Where(d => d.Cliente.Nome.StartsWith(paginacao.Letra.ToUpper()));
                }
            }
            paginacao.ListaModel = query.OrderBy(d => d.Id).ToList();
            //paginacao.ListaModel = query.OrderBy(d => d.Id).Skip(((paginacao.Pagina - 1) * 10)).Take(10).ToList();
            //paginacao.QtdPaginas = query.Count().CalculaQtdPaginas().TransformaEmLista();
            paginacao.ListaModel.ForEach(d => PreencheDados(d));
            paginacao.ListaModel.ForEach(d => CalculaValorTotal(d));
            return(paginacao);
        }
        public string AlterarTorneioCliente(TorneioCliente entidade)
        {
            var result = Validador.ValidaTorneioCliente(entidade);

            if (result != "")
            {
                return(result);
            }
            entidade.DataAlteracao      = DateTime.Now;
            entidade.IdUsuarioAlteracao = AutenticacaoAplicacao.ObterUsuarioLogado().Id;
            TorneioClienteRepositorio.Atualizar(entidade);
            var rows = Contexto.Salvar();

            return(result);
        }
Ejemplo n.º 7
0
        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());
        }
        public string CadastrarTorneioCliente(TorneioCliente entidade)
        {
            var result = Validador.ValidaTorneioCliente(entidade);

            if (result != "")
            {
                return(result);
            }
            entidade.DataCadastro      = DateTime.Now;
            entidade.IdUsuarioCadastro = AutenticacaoAplicacao.ObterUsuarioLogado().Id;
            entidade.Situacao          = SituacaoVenda.Pendente;
            entidade.ValorPago         = entidade.ValorPago ?? 0;
            TorneioClienteRepositorio.Cadastrar(entidade);
            Contexto.Salvar();
            return(result);
        }
Ejemplo n.º 9
0
        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);
        }
Ejemplo n.º 10
0
        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
            });
        }
Ejemplo n.º 11
0
        private Dictionary <string, double> ObterValorAtualTorneio(DateTime dataCaixa)
        {
            var torneiosAtivos = TorneioRepositorio.Filtrar(d => d.Ativo == Ativo.Ativo).ToList();
            Dictionary <string, double> valorTorneios = new Dictionary <string, double>();

            foreach (var torneio in torneiosAtivos)
            {
                var    entidades  = TorneioClienteRepositorio.Filtrar(d => d.DataCadastro >= dataCaixa && d.IdTorneio == torneio.Id).ToList();
                double valorTotal = 0;
                foreach (var entidade in entidades)
                {
                    valorTotal += entidade.JackPot * torneio.JackPot ?? 0;
                    valorTotal += entidade.Jantar * torneio.Jantar ?? 0;
                    valorTotal += entidade.ReBuy * torneio.ReBuy ?? 0;
                    valorTotal += entidade.TaxaAdm * torneio.TaxaAdm ?? 0;
                    valorTotal += entidade.BuyIn * torneio.BuyIn ?? 0;
                    valorTotal += entidade.Addon * torneio.Addon ?? 0;
                }

                valorTorneios.Add(torneio.Nome, valorTotal);
            }
            return(valorTorneios);
        }
Ejemplo n.º 12
0
 public void ExcluirTorneio(TorneioCliente entidade)
 {
     TorneioClienteRepositorio.Excluir(entidade);
 }