/// <summary>
/// Remover um determinado pagamento de uma saída
/// </summary>
/// <param name="codSaidaPagamento"></param>
/// <param name="saida"></param>
public void Remover(Int64 codSaidaPagamento, Saida saida)
{
try
{
if ((saida.TipoSaida == Saida.TIPO_PRE_VENDA) || (saida.TipoSaida == Saida.TIPO_VENDA))
{
List <Conta> contas = GerenciadorConta.GetInstance(saceContext).ObterPorSaidaPagamento(saida.CodSaida, codSaidaPagamento).ToList();
foreach (Conta conta in contas)
{
GerenciadorMovimentacaoConta.GetInstance(saceContext).RemoverPorConta(conta.CodConta);
GerenciadorConta.GetInstance(saceContext).Remover(conta.CodConta);
}
}
var query = from saidaPagamentoSet in saceContext.SaidaFormaPagamentoSet
where saidaPagamentoSet.codSaidaFormaPagamento == codSaidaPagamento
select saidaPagamentoSet;
foreach (SaidaFormaPagamentoE _saidaPagamentoE in query)
{
repSaidaPagamento.Remover(_saidaPagamentoE);
}
repSaidaPagamento.SaveChanges();
saida.TotalPago = ObterPorSaida(saida.CodSaida).Sum(sp => sp.Valor);
saida.Troco = saida.TotalPago - saida.TotalAVista;
saida.Desconto = 100 - ((saida.TotalAVista / saida.Total) * 100);
GerenciadorSaida.GetInstance(saceContext).Atualizar(saida);
}
catch (Exception e)
{
throw new DadosException("Pagamentos", e.Message, e);
}
}
/// <summary>
/// Verifica se um cliente possui limite suficiente para realizar uma nova compra
/// </summary>
/// <param name="cliente"></param>
/// <param name="totalNovaCompra"></param>
/// <returns></returns>
public decimal ObterLimiteCompraDisponivel(Pessoa cliente)
{
IEnumerable <Conta> listaContasAberto = GerenciadorConta.GetInstance(null).ObterPorSituacaoPessoa(SituacaoConta.SITUACAO_ABERTA, cliente.CodPessoa);
IEnumerable <long> listaCodContas = listaContasAberto.Select(p => p.CodConta);
IEnumerable <MovimentacaoConta> listaPagamentos = GerenciadorMovimentacaoConta.GetInstance(null).ObterPorContas(new List <long>(listaCodContas));
decimal totalValorPagar = listaContasAberto.Sum(c => c.ValorPagar);
decimal totalValorPago = listaPagamentos.Sum(m => m.Valor);
return(cliente.LimiteCompra - totalValorPagar + totalValorPago);
}
/// <summary>
/// Atualiza Situacao dos pagamentos da saída para quitado quando todas as contas estão quitadas
/// </summary>
/// <param name="_contaE"></param>
private void AtualizaSituacaoPagamentosSaida(ContaE contaE, MovimentacaoContaE movimentacaoContaE, bool removeuMovimento)
{
if (!contaE.codSaida.Equals(Global.SAIDA_PADRAO))
{
var query = from saida in saceContext.tb_saida
where saida.codSaida == contaE.codSaida
select saida;
tb_saida _saidaE = query.FirstOrDefault();
if (_saidaE != null)
{
if (_saidaE.totalAVista == movimentacaoContaE.valor)
{
if (removeuMovimento)
{
_saidaE.codSituacaoPagamentos = SituacaoPagamentos.LANCADOS;
}
else
{
_saidaE.codSituacaoPagamentos = SituacaoPagamentos.QUITADA;
}
}
else
{
if (GerenciadorConta.GetInstance(saceContext).ObterPorSituacaoSaida(SituacaoConta.SITUACAO_ABERTA, (long)contaE.codSaida).ToList().Count == 0)
{
_saidaE.codSituacaoPagamentos = SituacaoPagamentos.QUITADA;
IEnumerable <Conta> contas = GerenciadorConta.GetInstance(saceContext).ObterPorSaida(_saidaE.codSaida);
List <long> listaCodContas = new List <long>();
foreach (Conta conta in contas)
{
listaCodContas.Add(conta.CodConta);
}
decimal somaMovimentacoes = 0;
IEnumerable <MovimentacaoConta> listaMovimentacoes = ObterPorContas(listaCodContas);
foreach (MovimentacaoConta movimentacao in listaMovimentacoes)
{
somaMovimentacoes += movimentacao.Valor;
}
GerenciadorSaida.GetInstance(saceContext).AtualizarTipoPedidoGeradoPorSaida(_saidaE.codTipoSaida, _saidaE.pedidoGerado, _saidaE.tipoDocumentoFiscal, somaMovimentacoes, _saidaE.codSaida);
//_saidaE.totalAVista = somaMovimentacoes;
}
else
{
_saidaE.codSituacaoPagamentos = SituacaoPagamentos.LANCADOS;
}
}
saceContext.SaveChanges();
}
}
}
public static GerenciadorConta GetInstance(SaceEntities context)
{
if (gConta == null)
{
gConta = new GerenciadorConta();
}
if (context == null)
{
repConta = new RepositorioGenerico <ContaE>();
}
else
{
repConta = new RepositorioGenerico <ContaE>(context);
}
saceContext = (SaceEntities)repConta.ObterContexto();
return(gConta);
}
private void AtualizaFormaPagamentoUnica(tb_autorizacao_cartao autorizacaoAprovada, CartaoCredito cartao, SaidaPagamento saidaPagamento, IEnumerable <Conta> listaContas)
{
saidaPagamento.CodCartaoCredito = cartao.CodCartao;
saidaPagamento.CodFormaPagamento = FormaPagamento.CARTAO;
saidaPagamento.Data = (DateTime)autorizacaoAprovada.dataHoraAutorizacao;
saidaPagamento.NumeroControle = autorizacaoAprovada.nsuTransacao.ToString();
saidaPagamento.Parcelas = (int)autorizacaoAprovada.quantidadeParcelas;
saidaPagamento.Valor = autorizacaoAprovada.valor;
GerenciadorSaidaPagamento.GetInstance(null).Atualizar(saidaPagamento);
int parcela = 1;
foreach (Conta conta in listaContas)
{
GerenciadorConta.GetInstance(null).Atualizar(cartao.CodPessoa,
autorizacaoAprovada.dataHoraAutorizacao.Value.AddDays(cartao.DiaBase * parcela),
Conta.FORMATO_CONTA_CARTAO,
autorizacaoAprovada.nsuTransacao.ToString(),
autorizacaoAprovada.valor, conta.CodConta);
parcela++;
}
}
public void InserirRespostaCartao(Cartao.ResultadoProcessamento resultado)
{
List <tb_solicitacao_saida> listaSolicitacaoSaida;
if (resultado.Aprovado)
{
listaSolicitacaoSaida = ObterSolicitacaoSaida(resultado.CodSolicitacao).ToList();
// Pode passar mais de um cartão de crédito
if (listaSolicitacaoSaida.Count == 1)
{
tb_solicitacao_saida solicitacaoSaida = listaSolicitacaoSaida.FirstOrDefault();
IEnumerable <Conta> listaContas = GerenciadorConta.GetInstance(null).ObterPorSaida(solicitacaoSaida.codSaida);
List <Cartao.RespostaAprovada> listaAprovadas = resultado.ListaRespostaAprovada;
foreach (Cartao.RespostaAprovada aprovada in listaAprovadas)
{
String tipoCartaoString = Enum.GetName(typeof(Cartao.TipoCartao), aprovada.TipoCartao);
CartaoCredito cartao = GerenciadorCartaoCredito.GetInstance().ObterPorMapeamentoCappta(aprovada.NomeBandeiraCartao).Where(c => c.TipoCartao.Equals(tipoCartaoString)).ElementAtOrDefault(0);
Conta conta = listaContas.Where(c => c.ValorPagar == (decimal)aprovada.Valor && String.IsNullOrWhiteSpace(c.NumeroDocumento)).FirstOrDefault();
GerenciadorSaidaPagamento.GetInstance(null).AtualizarPorAutorizacaoCartao(conta.CodSaida, cartao.CodCartao, aprovada.NumeroControle);
conta.CodPessoa = cartao.CodPessoa;
conta.NumeroDocumento = aprovada.NumeroControle;
conta.DataVencimento = DateTime.Now.AddDays(cartao.DiaBase);
GerenciadorConta.GetInstance(null).AtualizarDadosCartaoCredito(conta);
}
}
//else
//{
// foreach (tb_solicitacao_saida solicitacaoSaida in listaSolicitacaoSaida)
// {
// IEnumerable<Conta> contas = GerenciadorConta.GetInstance(null).ObterPorSaida(solicitacaoSaida.codSaida);
// }
//}
InserirAutorizacaoCartao(resultado, listaSolicitacaoSaida);
}
AtualizarSolicitacaoDocumentoCartao(resultado);
}
private void AtualizaFormaPagamentoMultipla(tb_autorizacao_cartao autorizacaoAprovada, CartaoCredito cartao, IEnumerable <SaidaPagamento> pagamentos, IEnumerable <Conta> listaContas)
{
SaidaPagamento saidaPagamento = pagamentos.Where(p => p.CodFormaPagamento == FormaPagamento.CARTAO).FirstOrDefault();
if (saidaPagamento == null)
{
saidaPagamento = new SaidaPagamento();
}
saidaPagamento.CodCartaoCredito = cartao.CodCartao;
saidaPagamento.CodFormaPagamento = FormaPagamento.CARTAO;
saidaPagamento.Data = (DateTime)autorizacaoAprovada.dataHoraAutorizacao;
saidaPagamento.NumeroControle = autorizacaoAprovada.nsuTransacao.ToString();
saidaPagamento.Parcelas = (int)autorizacaoAprovada.quantidadeParcelas;
saidaPagamento.Valor = autorizacaoAprovada.valor;
if (pagamentos.Where(p => p.CodFormaPagamento == FormaPagamento.CARTAO).Count() == 1)
{
GerenciadorSaidaPagamento.GetInstance(null).Atualizar(saidaPagamento);
}
foreach (Conta conta in listaContas)
{
GerenciadorConta.GetInstance(null).Remover(conta.CodConta);
}
List <SaidaPagamento> listaPagamentos = new List <SaidaPagamento>()
{
saidaPagamento
};
List <SaidaPesquisa> listaSaidas = GerenciadorSaida.GetInstance(null).ObterPorCupomFiscal(autorizacaoAprovada.cupomFiscal);
foreach (SaidaPesquisa saidaPesquisa in listaSaidas)
{
Saida saida = GerenciadorSaida.GetInstance(null).Obter(saidaPesquisa.CodSaida);
GerenciadorSaidaPagamento.GetInstance(null).RemoverPorSaida(saida);
GerenciadorSaida.GetInstance(null).RegistrarPagamentosSaida(listaPagamentos, saida);
}
}
/// <summary>
/// Atualiza Situacao dos pagamentos da entrada para quitado quando todas as contas estão quitadas
/// </summary>
/// <param name="_contaE"></param>
private void AtualizaSituacaoPagamentosEntrada(ContaE _contaE)
{
var query = from entrada in saceContext.EntradaSet
where entrada.codEntrada == _contaE.codEntrada
select entrada;
EntradaE _entradaE = query.ToList().ElementAtOrDefault(0);
if (_entradaE != null)
{
if (!_contaE.codEntrada.Equals(Global.ENTRADA_PADRAO))
{
if (GerenciadorConta.GetInstance(saceContext).ObterPorSituacaoEntrada(SituacaoConta.SITUACAO_ABERTA, (long)_contaE.codEntrada).ToList().Count == 0)
{
_entradaE.codSituacaoPagamentos = SituacaoPagamentos.QUITADA;
}
else
{
_entradaE.codSituacaoPagamentos = SituacaoPagamentos.LANCADOS;
}
}
}
saceContext.SaveChanges();
}
/// <summary>
/// Encerra o cadastramento da entrada lançando todas as contas a pagar
/// </summary>
/// <param name="entrada"></param>
public void Encerrar(Entrada entrada)
{
var repEntrada = new RepositorioGenerico <EntradaE>();
SaceEntities saceContext = (SaceEntities)repEntrada.ObterContexto();
DbTransaction transaction = null;
try
{
if (saceContext.Connection.State == System.Data.ConnectionState.Closed)
{
saceContext.Connection.Open();
}
transaction = saceContext.Connection.BeginTransaction();
if (GerenciadorConta.GetInstance(saceContext).ObterPorEntrada(entrada.CodEntrada).ToList().Count == 0)
{
List <EntradaPagamento> entradaPagamentos = (List <EntradaPagamento>)GerenciadorEntradaPagamento.GetInstance().ObterPorEntrada(entrada.CodEntrada);
RegistrarPagamentosEntrada(entradaPagamentos, entrada, saceContext);
}
else
{
throw new NegocioException("Existem contas associadas a essa entrada. Ela não pode ser encerrada novamente.");
}
entrada.CodSituacaoPagamentos = SituacaoPagamentos.LANCADOS;
Atualizar(entrada, saceContext);
transaction.Commit();
}
catch (Exception e)
{
transaction.Rollback();
throw e;
}
finally
{
saceContext.Connection.Close();
}
}
/// <summary>
/// REgistra os pagamentos associando para cada um dele uma conta a pagar
/// </summary>
/// <param name="pagamentos"></param>
/// <param name="entrada"></param>
private void RegistrarPagamentosEntrada(List <EntradaPagamento> pagamentos, Entrada entrada, SaceEntities saceContext)
{
foreach (EntradaPagamento pagamento in pagamentos)
{
// Para cada pagamento é criada uma nova conta
Conta conta = new Conta();
if (pagamento.PagamentoDoFrete)
{
conta.CodPessoa = entrada.CodEmpresaFrete;
}
else
{
conta.CodPessoa = entrada.CodFornecedor;
}
conta.CodPlanoConta = PlanoConta.ENTRADA_PRODUTOS;
conta.CodEntrada = entrada.CodEntrada;
conta.CodSaida = Global.SAIDA_PADRAO; // saída não válida
conta.CodPagamento = pagamento.CodEntradaFormaPagamento;
conta.Desconto = 0;
// Quando o pagamento é realizado em dinheiro a conta já é inserido quitada
if (pagamento.CodFormaPagamento == FormaPagamento.DINHEIRO)
{
conta.CodSituacao = SituacaoConta.SITUACAO_QUITADA.ToString();
}
else
{
conta.CodSituacao = SituacaoConta.SITUACAO_ABERTA.ToString();
}
conta.TipoConta = Conta.CONTA_PAGAR.ToString();
conta.Valor = pagamento.Valor;
if (pagamento.CodFormaPagamento == FormaPagamento.BOLETO)
{
conta.FormatoConta = Conta.FORMATO_CONTA_BOLETO;
}
else
{
conta.FormatoConta = Conta.FORMATO_CONTA_FICHA;
}
conta.DataVencimento = pagamento.Data;
conta.CodConta = GerenciadorConta.GetInstance(saceContext).Inserir(conta);
if (pagamento.CodFormaPagamento == FormaPagamento.DINHEIRO)
{
MovimentacaoConta movimentacao = new MovimentacaoConta();
movimentacao.CodContaBanco = pagamento.CodContaBanco;
movimentacao.CodConta = conta.CodConta;
movimentacao.CodResponsavel = GerenciadorLoja.GetInstance().Obter(Global.LOJA_PADRAO).ElementAt(0).CodPessoa;
movimentacao.CodTipoMovimentacao = MovimentacaoConta.PAGAMENTO_FORNECEDOR;
movimentacao.DataHora = DateTime.Now;
movimentacao.Valor = pagamento.Valor;
GerenciadorMovimentacaoConta.GetInstance(saceContext).Inserir(movimentacao);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="resultado"></param>
public void AtualizarPedidosComAutorizacaoCartao()
{
var repAutorizacao = new RepositorioGenerico <tb_autorizacao_cartao>();
var saceEntities = (SaceEntities)repAutorizacao.ObterContexto();
var query = from autorizacao in saceEntities.tb_autorizacao_cartao
where autorizacao.processado.Equals(false)
select autorizacao;
List <tb_autorizacao_cartao> listaAutorizacoes = query.ToList();
if (listaAutorizacoes.Count > 0)
{
var repConta = new RepositorioGenerico <ContaE>();
var repSaidaPagamento = new RepositorioGenerico <SaidaFormaPagamentoE>();
List <CartaoCredito> listaCartoes = GerenciadorCartaoCredito.GetInstance().ObterTodos().ToList();
// Varre todas as transações ainda não processadas
foreach (tb_autorizacao_cartao autorizacaoCartaoE in listaAutorizacoes)
{
if (!autorizacaoCartaoE.processado)
{
IEnumerable <tb_autorizacao_cartao> listaAprovadas = listaAutorizacoes.Where(aut => aut.statusTransacao.Equals("0") && aut.cupomFiscal.Equals(autorizacaoCartaoE.cupomFiscal));
IEnumerable <tb_autorizacao_cartao> listaNegadas = listaAutorizacoes.Where(aut => !aut.statusTransacao.Equals("0") && aut.cupomFiscal.Equals(autorizacaoCartaoE.cupomFiscal));
if (listaAprovadas.Count() > 0)
{
foreach (tb_autorizacao_cartao autorizacaoAprovada in listaAprovadas)
{
autorizacaoAprovada.processado = true;
List <tb_saida> listaSaidas = null;
if (autorizacaoAprovada.tb_saida.Count() == 0)
{
var query2 = from saida in saceEntities.tb_saida
where saida.pedidoGerado.Equals(autorizacaoAprovada.cupomFiscal)
select saida;
listaSaidas = query2.ToList();
if (listaSaidas.Count == 0)
{
autorizacaoAprovada.processado = false;
}
else
{
foreach (tb_saida saidaE in listaSaidas)
{
autorizacaoAprovada.tb_saida.Add(saidaE);
}
}
}
repAutorizacao.SaveChanges();
foreach (tb_saida saidaE in autorizacaoAprovada.tb_saida)
{
String tipoCartaoString = "CREDITO";
if (autorizacaoAprovada.tipoTransacao.Equals(20))
{
tipoCartaoString = "DEBITO";
}
if (autorizacaoAprovada.nomeBandeiraCartao == null)
{
autorizacaoAprovada.nomeBandeiraCartao = "BANESE";
}
CartaoCredito cartao = listaCartoes.Where(c => c.TipoCartao.Equals(tipoCartaoString) && autorizacaoAprovada.nomeBandeiraCartao.Equals(c.MapeamentoCappta)).ElementAtOrDefault(0);
if (cartao == null)
{
// ajustes nos nomes dos cartões recuperados para que possa ser associado a um cartão cadastrado
if (autorizacaoAprovada.nomeBandeiraCartao.ToUpper().Equals("HIPER"))
{
autorizacaoAprovada.nomeBandeiraCartao = "HIPERCARD";
}
else if (autorizacaoAprovada.nomeBandeiraCartao.ToUpper().Equals("BANESE"))
{
autorizacaoAprovada.nomeBandeiraCartao = "BANESECARD";
}
else if (autorizacaoAprovada.nomeBandeiraCartao.ToUpper().Equals("MASTER"))
{
autorizacaoAprovada.nomeBandeiraCartao = "MASTERCARD";
}
if (autorizacaoAprovada.nomeBandeiraCartao.ToUpper().Equals("HIPERCARD") && tipoCartaoString.Equals("DEBITO"))
{
autorizacaoAprovada.nomeBandeiraCartao = "MASTERCARD";
}
cartao = listaCartoes.Where(c => c.TipoCartao.Equals(tipoCartaoString) && autorizacaoAprovada.nomeBandeiraCartao.Equals(c.MapeamentoCappta)).ElementAtOrDefault(0);
// cartões autorizados não cadastro são processados pela mastercard
if (cartao == null)
{
cartao = listaCartoes.Where(c => c.TipoCartao.Equals(tipoCartaoString) && c.MapeamentoCappta.Equals("MASTERCARD")).ElementAtOrDefault(0);
}
}
IEnumerable <SaidaPagamento> listaSaidaPagamento = GerenciadorSaidaPagamento.GetInstance(null).ObterPorSaida(saidaE.codSaida).Where(sp => sp.CodFormaPagamento.Equals(FormaPagamento.CARTAO));
IEnumerable <Conta> listaConta = GerenciadorConta.GetInstance(null).ObterPorSaida(saidaE.codSaida).Where(c => c.FormatoConta.Equals(Conta.FORMATO_CONTA_CARTAO));
if ((listaAprovadas.Count() == 1) && (listaSaidaPagamento.Count() == 1) && (listaConta.Count() == autorizacaoAprovada.quantidadeParcelas))
{
AtualizaFormaPagamentoUnica(autorizacaoAprovada, cartao, listaSaidaPagamento.First(), listaConta);
}
else if (listaAprovadas.Count() == 1)
{
// quando existe mais de uma forma de pagamento associada na saida
AtualizaFormaPagamentoMultipla(autorizacaoAprovada, cartao, listaSaidaPagamento, listaConta);
}
}
autorizacaoAprovada.processado = true;
}
}
else
{
if (listaNegadas.Count() > 0)
{
String cupomFiscal = listaNegadas.First().cupomFiscal;
IEnumerable <SaidaPesquisa> listaSaidas = GerenciadorSaida.GetInstance(null).ObterPorCupomFiscal(cupomFiscal);
// Cupom Fiscal foi emitido com venda em dinheiro
if (listaSaidas.Count() > 0)
{
foreach (SaidaPesquisa saidaPesquisa in listaSaidas)
{
Saida saida = GerenciadorSaida.GetInstance(null).Obter(saidaPesquisa.CodSaida);
GerenciadorSaidaPagamento.GetInstance(null).RemoverPorSaida(saida);
SaidaPagamento saidaPagamento = new SaidaPagamento();
saidaPagamento.CodCartaoCredito = Global.CARTAO_LOJA;
saidaPagamento.CodFormaPagamento = FormaPagamento.DINHEIRO;
saidaPagamento.CodSaida = saida.CodSaida;
saidaPagamento.Data = saida.DataSaida;
saidaPagamento.Valor = saida.TotalAVista;
saidaPagamento.CodContaBanco = Global.CAIXA_PADRAO;
saidaPagamento.Parcelas = 1;
List <SaidaPagamento> listaPagamentos = new List <SaidaPagamento>()
{
saidaPagamento
};
GerenciadorSaida.GetInstance(null).RegistrarPagamentosSaida(listaPagamentos, saida);
}
}
// Cupom Fiscal não foi emitido
else
{
foreach (SaidaPesquisa saidaPesquisa in listaSaidas)
{
Saida saida = GerenciadorSaida.GetInstance(null).Obter(saidaPesquisa.CodSaida);
if (!saida.TipoSaida.Equals(Saida.TIPO_ORCAMENTO))
{
GerenciadorSaidaPagamento.GetInstance(null).RemoverPorSaida(saida);
GerenciadorSaida.GetInstance(null).RegistrarEstornoEstoque(saida, null);
saida.TipoSaida = Saida.TIPO_ORCAMENTO;
saida.CodSituacaoPagamentos = SituacaoPagamentos.ABERTA;
saida.CupomFiscal = "";
saida.TotalPago = 0;
GerenciadorSaida.GetInstance(null).Atualizar(saida);
}
}
}
}
}
foreach (tb_autorizacao_cartao negada in listaNegadas)
{
negada.processado = true;
}
}
repAutorizacao.SaveChanges();
}
}
}
