// QUITAR A PAGAR AND INSERT NEW SAIDA
//------------------------------------------------------------------------------------------------------------
public long QuitarAPagar(
objAPagar apagar,
objMovimentacao saida,
Action <int, decimal> ContaSldLocalUpdate,
Action <int, decimal> SetorSldLocalUpdate)
{
AcessoDados dbTran = null;
try
{
dbTran = new AcessoDados();
dbTran.BeginTransaction();
// Verifica CONTA SALDO
ContaBLL cBLL = new ContaBLL();
decimal saldoAtual = cBLL.ContaSaldoGet((int)saida.IDConta, dbTran);
if (Math.Abs(saida.MovValor) > saldoAtual)
{
throw new AppException("Não existe SALDO SUFICIENTE na conta para realizar esse débito...", 1);
}
// Verifica CONTA BLOQUEIO
if (!cBLL.ContaDateBlockPermit((int)saida.IDConta, saida.MovData, dbTran))
{
throw new AppException("A Data da Conta está BLOQUEADA nesta Data de Débito proposto...", 2);
}
// Inserir SAIDA
saida.DescricaoOrigem = apagar.DespesaDescricao;
long newID = new MovimentacaoBLL().InsertMovimentacao(saida, ContaSldLocalUpdate, SetorSldLocalUpdate, dbTran);
saida.IDMovimentacao = newID;
// Change APAGAR
decimal DoValor = Math.Abs(saida.MovValor) - (saida.AcrescimoValor ?? 0);
apagar.ValorAcrescimo += saida.AcrescimoValor ?? 0;
apagar.ValorPago += DoValor;
if (apagar.ValorPago >= apagar.APagarValor - apagar.ValorDesconto)
{
apagar.PagamentoData = saida.MovData;
apagar.IDSituacao = 2;
apagar.Situacao = "Quitada";
}
// Update APAGAR
UpdateAPagar(apagar, dbTran);
dbTran.CommitTransaction();
return(newID);
}
catch (Exception ex)
{
dbTran.RollBackTransaction();
throw ex;
}
}
// INSERT ENTRADA | ARECEBER CHEQUE
//------------------------------------------------------------------------------------------------------------
private objAReceber insertAReceberCheque(
objAReceber receber,
objMovimentacao entrada,
Action <int, decimal> contaSaldoUpdate,
AcessoDados dbTran)
{
// create TRANSFER SAIDA
objMovimentacao transfSaida = new objMovimentacao(null)
{
MovTipo = 3, // TRANSFERENCIA
Origem = EnumMovOrigem.AReceber, // tblAReceber
IDOrigem = (long)receber.IDAReceber,
IDConta = receber.IDContaProvisoria,
IDSetor = null,
MovData = entrada.MovData,
MovValor = entrada.MovValor * (-1),
DescricaoOrigem = "TRANSFERÊNCIA: Depósito de Cheque",
};
// create TRANSFER ENTRADA
objMovimentacao transfEntrada = new objMovimentacao(null)
{
MovTipo = 3, // TRANSFERENCIA
Origem = EnumMovOrigem.AReceber, // tblAReceber
IDOrigem = (long)receber.IDAReceber,
IDConta = entrada.IDConta,
IDSetor = null,
MovData = entrada.MovData,
MovValor = entrada.MovValor,
DescricaoOrigem = "TRANSFERÊNCIA: Compensação de Cheque",
};
try
{
MovimentacaoBLL mBLL = new MovimentacaoBLL();
// Update FIRST Entrada: CONSOLIDADO = TRUE
mBLL.UpdateConsolidado(receber.IDMovProvisoria, true, dbTran);
// Insert transf saida
mBLL.InsertMovimentacao(transfSaida, contaSaldoUpdate, null, dbTran);
// Insert transf entrada
mBLL.InsertMovimentacao(transfEntrada, contaSaldoUpdate, null, dbTran);
// update AReceber
UpdateAReceber(receber, dbTran);
}
catch (Exception ex)
{
throw ex;
}
return(receber);
}
// ESTORNA ARECEBER
//------------------------------------------------------------------------------------------------------------
public objAReceber estornaAReceber(objAReceber receber,
Action <int, decimal> contaSaldoUpdate,
Action <int, decimal> setorSaldoUpdate)
{
AcessoDados db = null;
// UPDATE CONSOLIDADO ENTRADA = FALSE
// DELETE TRANSFER ENTRADA / SAIDA
// DELETE COMISSAO SAIDA
// UPDATE A RECEBER
try
{
db = new AcessoDados();
db.BeginTransaction();
MovimentacaoBLL mBLL = new MovimentacaoBLL();
// Update FIRST Entrada: CONSOLIDADO = FALSE
mBLL.UpdateConsolidado(receber.IDMovProvisoria, false, db);
// REMOVE transf saida entrada
mBLL.DeleteMovsByOrigem(EnumMovOrigem.AReceber, (long)receber.IDAReceber, contaSaldoUpdate, setorSaldoUpdate, db);
// UPDATE Contribuicao
var cBLL = new ContribuicaoBLL();
cBLL.UpdateValorRecebidoEstorno(receber.IDContribuicao, receber.ValorRecebido, db);
// UPDATE AReceber
receber.ValorRecebido = 0;
receber.IDSituacao = 1;
receber.Situacao = "Em Aberto";
UpdateAReceber(receber, db);
// COMMIT
db.CommitTransaction();
}
catch (Exception ex)
{
db.RollBackTransaction();
throw ex;
}
return(receber);
}
private bool VerifyBeforeDelete(long IDEntrada,
ref List <objMovimentacao> listMovs,
AcessoDados dbTran)
{
try
{
bool err = false;
string errMessage = "";
// VERIFY MOVIMENTACAO ENTRADA FROM Entrada
//------------------------------------------------------------------------------------------------------------
MovimentacaoBLL mBLL = new MovimentacaoBLL();
listMovs = mBLL.GetMovimentacaoListByOrigem(EnumMovOrigem.Entrada, IDEntrada, false, dbTran);
// VERIFY RECEBIMENTOS WITH CAIXA OR BLOCKED
//------------------------------------------------------------------------------------------------------------
errMessage = "Essa Entrada possui movimentações que foram inseridas no caixa...\n";
foreach (objMovimentacao entrada in listMovs)
{
if (entrada.IDCaixa != null)
{
errMessage += $"Reg.: {entrada.IDMovimentacao:D4} | {entrada.MovData.ToShortDateString()} | Caixa: {entrada.IDCaixa:D4}\n";
err = true;
}
}
if (err == true)
{
errMessage += "Favor remover o(s) caixa(s) se desejar EXCLUIR a(s) Entrada.";
throw new AppException(errMessage);
}
return(true);
}
catch (Exception ex)
{
throw ex;
}
}
// DELETE
//------------------------------------------------------------------------------------------------------------
public bool DeleteEntrada(long IDEntrada,
Action <int, decimal> ContaSdlUpdate,
Action <int, decimal> SetorSdlUpdate)
{
AcessoDados dbTran = null;
try
{
dbTran = new AcessoDados();
dbTran.BeginTransaction();
// 1 - CHECK Movs
//------------------------------------------------------------------------------------------------------------
List <objMovimentacao> listMovs = new List <objMovimentacao>();
if (!VerifyBeforeDelete(IDEntrada, ref listMovs, dbTran))
{
return(false);
}
// 2 - delete ALL MOVIMENTACAO ENTRADA
//------------------------------------------------------------------------------------------------------------
if (listMovs.Count > 0)
{
MovimentacaoBLL mBLL = new MovimentacaoBLL();
mBLL.DeleteMovimentacaoList(listMovs, ContaSdlUpdate, SetorSdlUpdate, dbTran);
}
// 3 - delete Entrada
//------------------------------------------------------------------------------------------------------------
//--- clear Params
dbTran.LimparParametros();
//--- define Params
dbTran.AdicionarParametros("@IDEntrada", IDEntrada);
//--- convert null parameters
dbTran.ConvertNullParams();
//--- create query
string query = "DELETE tblEntrada WHERE IDEntrada = @IDEntrada";
//--- DELETE
dbTran.ExecutarManipulacao(CommandType.Text, query);
//--- COMMIT AND RETURN
dbTran.CommitTransaction();
return(true);
}
catch (AppException ex)
{
dbTran.RollBackTransaction();
throw ex;
}
catch (Exception ex)
{
dbTran.RollBackTransaction();
throw ex;
}
}
// INSERT AJUSTE
//------------------------------------------------------------------------------------------------------------
public objMovimentacao InsertAjuste(
objCaixaAjuste ajuste,
Action <int, decimal> ContaSldUpdate,
Action <int, decimal> SetorSldUpdate,
long?IDCaixa = null,
object dbTran = null)
{
AcessoDados db = dbTran == null ? new AcessoDados() : (AcessoDados)dbTran;
try
{
if (dbTran == null)
{
db.BeginTransaction();
}
// 1. INSERT AJUSTE
//------------------------------------------------------
//--- clear Params
db.LimparParametros();
//--- define Params
db.AdicionarParametros("@AjusteDescricao", ajuste.AjusteDescricao);
db.AdicionarParametros("@IDAjusteTipo", ajuste.IDAjusteTipo);
db.AdicionarParametros("@IDUserAuth", ajuste.IDUserAuth);
//--- convert null parameters
db.ConvertNullParams();
//--- create query
string query = db.CreateInsertSQL("tblCaixaAjuste");
//--- insert AJUSTE
var newID = (int)db.ExecutarInsertAndGetID(query);
ajuste.IDAjuste = newID;
// 2. INSERT MOVIMENTACAO
//------------------------------------------------------
var movimentacao = new objMovimentacao(null)
{
MovTipo = ajuste.MovValor >= 0 ? (byte)1 : (byte)2,
MovTipoDescricao = ajuste.MovValor >= 0 ? "E" : "S",
Consolidado = true,
IDConta = ajuste.IDConta,
IDSetor = ajuste.IDSetor,
Setor = ajuste.Setor,
MovData = ajuste.MovData,
MovValor = ajuste.MovValor,
IDOrigem = (long)ajuste.IDAjuste,
Origem = EnumMovOrigem.CaixaAjuste, // origem ajuste
DescricaoOrigem = ajuste.AjusteDescricao,
IDCaixa = IDCaixa,
};
//--- insert MOVIMENTACAO
var movID = new MovimentacaoBLL().InsertMovimentacao(movimentacao, ContaSldUpdate, SetorSldUpdate, dbTran);
movimentacao.IDMovimentacao = movID;
// 3. COMMIT AND RETURN
//------------------------------------------------------
if (dbTran == null)
{
db.CommitTransaction();
}
return(movimentacao);
}
catch (Exception ex)
{
if (dbTran == null)
{
db.RollBackTransaction();
}
throw ex;
}
}
// INSERT TRANSFERENCIA SETOR
//------------------------------------------------------------------------------------------------------------
public long InsertTransferenciaSetor(objTransfSetor Transf, Action <int, decimal> SetorSdlUpdate)
{
AcessoDados db = null;
try
{
db = new AcessoDados();
db.BeginTransaction();
//--- 1. INSERT TRANSF SETOR
//------------------------------------------------------------------------------------------------------------
//--- clear Params
db.LimparParametros();
//--- params
db.AdicionarParametros("@IDSetorEntrada", Transf.IDSetorEntrada);
db.AdicionarParametros("@IDSetorSaida", Transf.IDSetorSaida);
db.AdicionarParametros("@Descricao", Transf.Descricao);
db.AdicionarParametros("@TransfData", Transf.TransfData);
db.AdicionarParametros("@TransfValor", Transf.TransfValor);
//--- convert null parameters
db.ConvertNullParams();
//--- create insert string
string query = db.CreateInsertSQL("tblTransfSetor");
//--- insert and Get new ID
long newID = db.ExecutarInsertAndGetID(query);
//--- 2. INSERT TRANSF ENTRADA
//------------------------------------------------------------------------------------------------------------
MovimentacaoBLL mBLL = new MovimentacaoBLL();
//--- create transferencia de entrada
objMovimentacao entrada = new objMovimentacao(null)
{
IDSetor = Transf.IDSetorEntrada,
IDCaixa = null,
IDConta = null,
Origem = EnumMovOrigem.TransfSetor,
IDOrigem = newID,
MovData = Transf.TransfData,
MovValor = Transf.TransfValor,
DescricaoOrigem = $"TRANSFERÊNCIA: entrada de {Transf.SetorSaida}",
};
//--- execute INSERT ENTRADA MOVIMENTACAO
mBLL.InsertMovimentacao(entrada, SetorSdlUpdate, null, db);
//--- 3. INSERT TRANSF SAIDA
//------------------------------------------------------------------------------------------------------------
//--- create transferencia de entrada
objMovimentacao saida = new objMovimentacao(null)
{
IDSetor = Transf.IDSetorSaida,
IDCaixa = null,
IDConta = null,
Origem = EnumMovOrigem.TransfSetor,
IDOrigem = newID,
MovData = Transf.TransfData,
MovValor = Transf.TransfValor * (-1),
DescricaoOrigem = $"TRANSFERÊNCIA: saída para {Transf.SetorEntrada}",
};
//--- execute INSERT SAIDA MOVIMENTACAO
mBLL.InsertMovimentacao(entrada, null, SetorSdlUpdate, db);
//--- COMMIT and RETURN
db.CommitTransaction();
return(newID);
}
catch (Exception ex)
{
db.RollBackTransaction();
throw ex;
}
}
// VERIFY DESPESA BEFORE DELETE
//------------------------------------------------------------------------------------------------------------
public bool VerifyBeforeDelete(objDespesaCartao despesa,
ref List <objAPagar> listAPagar,
ref List <objMovimentacao> listMovSaidas,
AcessoDados dbTran)
{
try
{
long IDDespesa = (long)despesa.IDDespesa;
// VERIFY IMAGEM
//------------------------------------------------------------------------------------------------------------
if (despesa.Imagem != null && !string.IsNullOrEmpty(despesa.Imagem.ImagemFileName))
{
throw new AppException("A despesa não pode ser excluída pois possui uma imagem vinculada a ela...");
}
// GET APAGAR
//------------------------------------------------------------------------------------------------------------
listAPagar = new APagarBLL().GetListAPagarByDespesa(IDDespesa, dbTran);
// VERIFY APAGAR
//------------------------------------------------------------------------------------------------------------
bool err = false;
string errMessage = "Os a PAGAR abaixo possuem pagamentos...\n";
Action <objAPagar> addMessage = (pagar) =>
{
errMessage += $"Reg.: {pagar.IDAPagar:D4} {pagar.Vencimento.ToShortDateString()}\n";
err = true;
};
listAPagar.Where(x => x.IDSituacao == 2).ToList().ForEach(addMessage);
if (err == true)
{
errMessage += "Favor estornar antes os pagamentos se deseja EXCLUIR a despesa.";
throw new AppException(errMessage);
}
// VERIFY APAGAR IMAGES
//------------------------------------------------------------------------------------------------------------
errMessage = "Os APagar abaixo possuem IMAGEM associada\n";
listAPagar.Where(x => x.Imagem != null && !string.IsNullOrEmpty(x.Imagem.ImagemFileName)).ToList().ForEach(addMessage);
if (err == true)
{
errMessage += "Favor remover/desassociar as imagens do APagar se deseja EXCLUIR a despesa.";
throw new AppException(errMessage);
}
// VERIFY MOVIMENTACAO SAIDA FROM APAGAR
//------------------------------------------------------------------------------------------------------------
MovimentacaoBLL mBLL = new MovimentacaoBLL();
listMovSaidas = new List <objMovimentacao>();
if (listAPagar.Count > 0)
{
foreach (objAPagar pagar in listAPagar)
{
listMovSaidas.AddRange(mBLL.GetMovimentacaoListByOrigem(EnumMovOrigem.APagar, (long)pagar.IDAPagar, true, dbTran));
}
}
// VERIFY RECEBIMENTOS WITH CAIXA OR BLOCKED
//------------------------------------------------------------------------------------------------------------
errMessage = "Essa Despesa possui pagamentos que foram inseridas no caixa...\n";
Action <objMovimentacao> addMessageMov = (saida) =>
{
errMessage += $"Reg.: {saida.IDMovimentacao:D4} | {saida.MovData.ToShortDateString()} | Caixa: {saida.IDCaixa:D4}\n";
err = true;
};
listMovSaidas.Where(x => x.IDCaixa != null).ToList().ForEach(addMessageMov);
if (err == true)
{
errMessage += "Favor remover o(s) caixa(s) se desejar EXCLUIR a(s) DESPESA.";
throw new AppException(errMessage);
}
// VERIFY MOVIMENTACAO SAIDA IMAGES
//------------------------------------------------------------------------------------------------------------
errMessage = "As Saídas abaixo possuem IMEGEM associada\n";
listMovSaidas.Where(x => x.Imagem != null && !string.IsNullOrEmpty(x.Imagem.ImagemFileName)).ToList().ForEach(addMessageMov);
if (err == true)
{
errMessage += "Favor remover/desassociar as imagens das Saídas se deseja EXCLUIR a despesa.";
throw new AppException(errMessage);
}
return(true);
}
catch (Exception ex)
{
throw ex;
}
}
private bool VerifyBeforeDelete(long IDContribuicao,
ref List <objAReceber> listAReceber,
ref List <objMovimentacao> listEntradas,
AcessoDados dbTran)
{
try
{
// GET ARECEBER
//------------------------------------------------------------------------------------------------------------
listAReceber = new AReceberBLL().GetListAReceberByIDContribuicao(IDContribuicao, dbTran);
// VERIFY ARECEBER
//------------------------------------------------------------------------------------------------------------
bool err = false;
string errMessage = "Os ARECEBER abaixo possuem recebimentos...\n";
foreach (objAReceber receber in listAReceber)
{
if (receber.IDSituacao == 2)
{
errMessage += $"Reg.: {receber.IDAReceber:D4} {receber.CompensacaoData.ToShortDateString()}\n";
err = true;
}
}
if (err == true)
{
errMessage += "Favor estornar antes os recebimentos se deseja EXCLUIR a contribuição.";
throw new AppException(errMessage);
}
// VERIFY MOVIMENTACAO ENTRADA FROM CONTRIBUICAO
//------------------------------------------------------------------------------------------------------------
MovimentacaoBLL mBLL = new MovimentacaoBLL();
listEntradas = mBLL.GetMovimentacaoListByOrigem(EnumMovOrigem.Contribuicao, IDContribuicao, false, dbTran);
// VERIFY MOVIMENTACAO ENTRADA FROM ARECEBER
//------------------------------------------------------------------------------------------------------------
if (listAReceber.Count > 0)
{
foreach (objAReceber receber in listAReceber)
{
listEntradas.AddRange(mBLL.GetMovimentacaoListByOrigem(EnumMovOrigem.AReceber, (long)receber.IDAReceber, false, dbTran));
}
}
// VERIFY RECEBIMENTOS WITH CAIXA OR BLOCKED
//------------------------------------------------------------------------------------------------------------
errMessage = "Essa Contribuição possui entradas que foram inseridas no caixa...\n";
foreach (objMovimentacao entrada in listEntradas)
{
if (entrada.IDCaixa != null)
{
errMessage += $"Reg.: {entrada.IDMovimentacao:D4} | {entrada.MovData.ToShortDateString()} | Caixa: {entrada.IDCaixa:D4}\n";
err = true;
}
}
if (err == true)
{
errMessage += "Favor remover o(s) caixa(s) se desejar EXCLUIR a(s) contribuição.";
throw new AppException(errMessage);
}
return(true);
}
catch (Exception ex)
{
throw ex;
}
}
// DELETE
//------------------------------------------------------------------------------------------------------------
public bool DeleteContribuicao(long IDContribuicao,
Action <int, decimal> ContaSdlUpdate,
Action <int, decimal> SetorSdlUpdate)
{
AcessoDados dbTran = null;
try
{
dbTran = new AcessoDados();
dbTran.BeginTransaction();
// 1 - CHECK AReceber and Entradas
//------------------------------------------------------------------------------------------------------------
List <objAReceber> listAReceber = new List <objAReceber>();
List <objMovimentacao> listEntradas = new List <objMovimentacao>();
if (!VerifyBeforeDelete(IDContribuicao, ref listAReceber, ref listEntradas, dbTran))
{
return(false);
}
// 2 - delete ALL ARECEBER
//------------------------------------------------------------------------------------------------------------
if (listAReceber.Count > 0)
{
AReceberBLL rBLL = new AReceberBLL();
foreach (objAReceber receber in listAReceber)
{
rBLL.DeleteAReceber((long)receber.IDAReceber, dbTran);
}
}
// 3 - delete ALL MOVIMENTACAO ENTRADA
//------------------------------------------------------------------------------------------------------------
if (listEntradas.Count > 0)
{
MovimentacaoBLL mBLL = new MovimentacaoBLL();
mBLL.DeleteMovimentacaoList(listEntradas, ContaSdlUpdate, SetorSdlUpdate, dbTran);
}
// 4 - delete CONTRIBUICAO
//------------------------------------------------------------------------------------------------------------
//--- clear Params
dbTran.LimparParametros();
//--- define Params
dbTran.AdicionarParametros("@IDContribuicao", IDContribuicao);
//--- convert null parameters
dbTran.ConvertNullParams();
//--- create query
string query = "DELETE tblContribuicao WHERE IDContribuicao = @IDContribuicao";
//--- DELETE
dbTran.ExecutarManipulacao(CommandType.Text, query);
//--- COMMIT AND RETURN
dbTran.CommitTransaction();
return(true);
}
catch (AppException ex)
{
dbTran.RollBackTransaction();
throw ex;
}
catch (Exception ex)
{
dbTran.RollBackTransaction();
throw ex;
}
}
// INSERT
//------------------------------------------------------------------------------------------------------------
public long InsertContribuicao(
objContribuicao cont,
Action <int, decimal> ContaSldLocalUpdate,
Action <int, decimal> SetorSldLocalUpdate,
object forma = null)
{
AcessoDados db = new AcessoDados();
long? newID = null;
long? newMovID = null;
objMovimentacao entrada = null;
try
{
db.BeginTransaction();
//--- Check Conta Bloqueio
if (!new ContaBLL().ContaDateBlockPermit(cont.IDConta, cont.ContribuicaoData, db))
{
throw new AppException("A Data da Conta está BLOQUEADA nesta Data de Crédito proposta...", 2);
}
switch (cont.IDEntradaForma)
{
case 1: // DINHEIRO
//--- Insert Contribuicao
cont.Realizado = true;
cont.ValorRecebido = cont.ValorBruto;
newID = AddContribuicao(cont, db);
//--- Create NEW Entrada
entrada = new objMovimentacao(null)
{
MovTipo = 1,
IDConta = cont.IDConta,
IDSetor = cont.IDSetor,
IDOrigem = (long)newID,
Origem = EnumMovOrigem.Contribuicao,
MovData = cont.ContribuicaoData,
MovValor = cont.ValorBruto,
Consolidado = true,
DescricaoOrigem = "CONTRIBUIÇÃO: " + cont.OrigemDescricao,
};
//--- Insert MOVIMENTACAO Entrada
new MovimentacaoBLL().InsertMovimentacao(entrada, ContaSldLocalUpdate, SetorSldLocalUpdate, db);
break;
case 2: // CHEQUE
if (forma == null || forma.GetType() != typeof(objContribuicaoCheque))
{
throw new Exception("Não há registro de informação do cheque...");
}
//--- Insert Contribuicao
cont.Realizado = false;
cont.ValorRecebido = 0;
newID = AddContribuicao(cont, db);
cont.IDContribuicao = newID;
//--- Insert ContribuicaoCheque
objContribuicaoCheque cheque = (objContribuicaoCheque)forma;
cheque.IDContribuicao = newID;
AddContribuicaoCheque(cheque, db);
//--- Create NEW MOVIMENTACAO ENTRADA
entrada = new objMovimentacao(null)
{
MovTipo = 1,
IDConta = cont.IDConta,
IDSetor = cont.IDSetor,
IDOrigem = (long)newID,
Origem = EnumMovOrigem.Contribuicao,
MovData = cont.ContribuicaoData,
MovValor = cont.ValorBruto,
Consolidado = false,
DescricaoOrigem = $"CONTRIBUIÇÃO: Cheque no. {cheque.ChequeNumero} {cheque.Banco}",
};
//--- Insert MOVIMENTACAO Entrada
newMovID = new MovimentacaoBLL().InsertMovimentacao(entrada, ContaSldLocalUpdate, SetorSldLocalUpdate, db);
//--- Create AReceber
var areceber = new objAReceber(null)
{
CompensacaoData = cheque.DepositoData,
IDContaProvisoria = cont.IDConta,
IDContribuicao = (long)cont.IDContribuicao,
IDSituacao = 1,
Situacao = "Em Aberto",
ValorBruto = cont.ValorBruto,
ValorLiquido = cont.ValorBruto,
ValorRecebido = 0,
IDMovProvisoria = (long)newMovID,
};
//--- Insert AReceber Parcela
new AReceberBLL().InsertAReceber(areceber, db);
break;
case 3: // CARTAO
if (forma == null || forma.GetType() != typeof(objContribuicaoCartao))
{
throw new Exception("Não há registro de informação do cartão...");
}
//--- Check Conta Bloqueio
objContribuicaoCartao cartao = (objContribuicaoCartao)forma;
if (!new ContaBLL().ContaDateBlockPermit(cartao.IDContaProvisoria, cont.ContribuicaoData, db))
{
throw new AppException("A Data da Conta está BLOQUEADA nesta Data de Crédito proposta...", 2);
}
//--- Insert Contribuicao
cont.Realizado = false;
cont.ValorRecebido = 0;
newID = AddContribuicao(cont, db);
cont.IDContribuicao = newID;
//--- Insert ContribuicaoCartao
cartao.IDContribuicao = newID;
AddContribuicaoCartao(cartao, db);
//--- Insert ListOf AReceber
var listAReceber = new List <objAReceber>();
int parcelas = cartao.Parcelas == 0 ? 1 : cartao.Parcelas;
// create PARCELAS
for (int i = 0; i < parcelas; i++)
{
var parcela = new objAReceber(null)
{
CompensacaoData = cont.ContribuicaoData.AddDays(cartao.Prazo * (i + 1)),
IDContaProvisoria = cartao.IDContaProvisoria,
IDContribuicao = (long)cont.IDContribuicao,
IDSituacao = 1,
Situacao = "Em Aberto",
ValorBruto = cont.ValorBruto / parcelas,
ValorLiquido = (cont.ValorBruto / parcelas) * (100 - cartao.TaxaAplicada) / 100,
ValorRecebido = 0
};
listAReceber.Add(parcela);
}
var rBLL = new AReceberBLL();
var mBLL = new MovimentacaoBLL();
int numParcela = 1;
//--- Insert ListOf AReceber Parcelas
foreach (var parcela in listAReceber)
{
//--- Create NEW MOVIMENTACAO Entrada
entrada = new objMovimentacao(null)
{
MovTipo = 1,
IDConta = parcela.IDContaProvisoria,
IDSetor = cont.IDSetor,
IDOrigem = (long)newID,
Origem = EnumMovOrigem.Contribuicao,
MovData = cont.ContribuicaoData,
MovValor = parcela.ValorBruto,
Consolidado = false,
};
//--- define descricao origem of movimentacao
if (cartao.Parcelas == 0)
{
entrada.DescricaoOrigem = $"CONTRIBUIÇÃO: Cartão de Débito {cartao.CartaoBandeira}";
}
else if (cartao.Parcelas == 1)
{
entrada.DescricaoOrigem = $"CONTRIBUIÇÃO: Cartão de Crédito {cartao.CartaoBandeira}";
}
else
{
entrada.DescricaoOrigem = $"CONTRIBUIÇÃO: Cartão Parcelado {cartao.CartaoBandeira} parcela {numParcela:D2}";
}
//--- add Parcela
numParcela += 1;
//--- Insert Entrada
newMovID = mBLL.InsertMovimentacao(entrada, ContaSldLocalUpdate, SetorSldLocalUpdate, db);
//--- Insert AReceber
parcela.IDMovProvisoria = (long)newMovID;
rBLL.InsertAReceber(parcela, db);
}
break;
default:
break;
}
if (newID == 0)
{
throw new Exception("Não foi possível inserir um novo registro de Contribuição...");
}
db.CommitTransaction();
return((long)newID);
}
catch (Exception ex)
{
db.RollBackTransaction();
throw ex;
}
}