public async Task <IActionResult> Edit(int id, [Bind("Id,Amount,Description,Tag,EntryDate,IsIncome,UserId")] ExpenseIncome expenseIncome)
{
if (id != expenseIncome.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(expenseIncome);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ExpenseIncomeExists(expenseIncome.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["UserId"] = new SelectList(_context.Users, "Id", "Id", expenseIncome.UserId);
return(View(expenseIncome));
}
public ActionResult <ExpenseIncome> Create(ExpenseIncome expenseIncome)
{
var createdExpenseIncome = _expenseIncomeService.Create(expenseIncome);
if (createdExpenseIncome == null)
{
return(BadRequest("You didn't choose Expense or Income. Please put correct value and try again!"));
}
return(Ok(createdExpenseIncome));
}
private List <ResumoCategoriaMesModel> gerarListaDespesa(string sMesAno)
{
List <ResumoCategoriaMesModel> retorno = new List <ResumoCategoriaMesModel>();
DateTime dDataInicio = new DateTime(int.Parse(sMesAno.Substring(2, 4)), int.Parse(sMesAno.Substring(0, 2)), 1);
DateTime dDataFim = dDataInicio.AddMonths(1) - (new TimeSpan(0, 0, 0, 1));
// tudo do mês sem cartão de crédito
List <ExpenseIncome> lstMesAtual = expenseIncomeBusiness.Get.Where(e => e.sUserID == AuthProvider.UserAntenticated.sID && e.dData >= dDataInicio && e.dData <= dDataFim && e.CategoryType == CategoryType.Despesa).OrderBy(e => e.sCategoryID).ToList();
foreach (ExpenseIncome exp in lstMesAtual)
{
Account conta = accountBusiness.Get.FirstOrDefault(c => c.sID == exp.sAccountID);
if (conta.AccountType != AccountType.CartaoDeCredito)
{
ResumoCategoriaMesModel resumo = new ResumoCategoriaMesModel();
resumo.dData = exp.dData;
resumo.dValor = exp.dValor;
resumo.sCategoryID = exp.sCategoryID;
resumo.sDescCategoria = categoryBusiness.Get.FirstOrDefault(c => c.sID == exp.sCategoryID).descricao;
resumo.sDescConta = accountBusiness.Get.FirstOrDefault(a => a.sID == exp.sAccountID).sNome;
resumo.sDescricao = exp.sDescricao;
if (exp.iTotalOcorrencia > 1)
{
resumo.sDescricao += " - " + exp.iNumeroOcorrencia + "/" + exp.iTotalOcorrencia;
}
retorno.Add(resumo);
}
}
// tudo do mês pago por cartão de crédito
lstMesAtual = expenseIncomeBusiness.Get.Where(e => e.sUserID == AuthProvider.UserAntenticated.sID && e.dData >= dDataInicio && e.dData <= dDataFim && e.CategoryType == CategoryType.PagamentoCartaoCredito).OrderBy(e => e.sCategoryID).ToList();
foreach (ExpenseIncome exp in lstMesAtual)
{
List <ExpenseIncomeReference> lstCartao = expenseIncomeReferenceBusiness.Get.Where(e => e.sExpenseIncomeDestinyID == exp.sID).ToList();
foreach (ExpenseIncomeReference expRef in lstCartao)
{
ExpenseIncome expPago = expenseIncomeBusiness.Get.FirstOrDefault(e => e.sID == expRef.sExpenseIncomeOriginID);
if (expPago.CategoryType == CategoryType.Despesa)
{
ResumoCategoriaMesModel resumo = new ResumoCategoriaMesModel();
resumo.dData = expPago.dData;
resumo.dValor = expPago.dValor;
resumo.sCategoryID = expPago.sCategoryID;
resumo.sDescCategoria = categoryBusiness.Get.FirstOrDefault(c => c.sID == expPago.sCategoryID).descricao;
resumo.sDescConta = accountBusiness.Get.FirstOrDefault(a => a.sID == expPago.sAccountID).sNome;
resumo.sDescricao = expPago.sDescricao;
if (expPago.iTotalOcorrencia > 1)
{
resumo.sDescricao += " - " + expPago.iNumeroOcorrencia + "/" + expPago.iTotalOcorrencia;
}
retorno.Add(resumo);
}
}
}
return(retorno);
}
public ExpenseIncome Create(ExpenseIncome expenseIncome)
{
if (expenseIncome.ExpenseOrIncome.ToString() != "Expense" && expenseIncome.ExpenseOrIncome.ToString() != "Income" && expenseIncome.ExpenseOrIncome.ToString() != "Transfer")
{
return(null);
}
expenseIncome.TransferToAccountId = 0;
_context.Add(expenseIncome);
_context.SaveChanges();
return(expenseIncome);
}
public async Task <IActionResult> Create([Bind("Amount,Description,Tag,EntryDate,IsIncome")] ExpenseIncome expenseIncome)
{
if (ModelState.IsValid)
{
expenseIncome.UserId = User.FindFirstValue(ClaimTypes.NameIdentifier);
_context.Add(expenseIncome);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["UserId"] = new SelectList(_context.Users, "Id", "Id", expenseIncome.UserId);
return(View(expenseIncome));
}
public ExpenseIncome Update(ExpenseIncome expenseIncome)
{
var ei = _context.ExpenseIncomes.FirstOrDefault(e => e.Id == expenseIncome.Id);
if (ei == null)
{
return(null);
}
_context.ExpenseIncomes.Update(expenseIncome);
_context.SaveChanges();
return(expenseIncome);
}
private List <PrevisaoMesModel> ListaPrevisao(int iMes, int iAno)
{
DateTime dInicioMes = new DateTime(iAno, iMes, 1);
DateTime dFimMes = dInicioMes.AddMonths(1).AddSeconds(-1);
List <PrevisaoMesModel> lista = new List <PrevisaoMesModel>();
#region ----------------------------------------------------------------------- Notificações -----------------------------------------------------------------------
List <Notification> lstNotification = notificationBusiness.Get.Where(n => n.sUserID == AuthProvider.UserAntenticated.sID && n.StatusType == StatusType.Ativo).ToList();
foreach (Notification not in lstNotification)
{
if (categoryBusiness.Get.FirstOrDefault(c => c.sID == not.sCategoryID).CategoryType == CategoryType.Despesa)
{
DateTime dataBaseNot = new DateTime(not.dData.Year, not.dData.Month, 1);
DateTime dataFimBaseNot = new DateTime(not.dDataFim.Year, not.dDataFim.Month, 1);
if (dataBaseNot <= dInicioMes && dataFimBaseNot >= dInicioMes)
{
PrevisaoMesModel previsao = new PrevisaoMesModel();
previsao.dData = OperacaoData.retornoDataTimeValido(iAno, iMes, not.dData.Day);
previsao.dValor = not.dValor;
Category catTemp = categoryBusiness.Get.FirstOrDefault(c => c.sID == not.sCategoryID);
if (catTemp.CategoryType == CategoryType.Receita)
{
previsao.dValor *= (-1);
}
previsao.sAccountID = string.Empty;
previsao.sCategoryID = not.sCategoryID;
previsao.sDescricao = not.sDescricao;
previsao.sAgrupadorID = string.Empty;
previsao.bPago = false;
DateTime dDataCalculo = OperacaoData.retornoDataTimeValido(iAno, iMes, not.dData.Day);
if (expenseIncomeBusiness.Get.Any(e => e.sNotificationID == not.sID && e.dDataBase.Month == dDataCalculo.Month && e.dDataBase.Year == dDataCalculo.Year))
{
ExpenseIncome expInc = expenseIncomeBusiness.Get.FirstOrDefault(e => e.sNotificationID == not.sID && e.dDataBase.Month == dDataCalculo.Month && e.dDataBase.Year == dDataCalculo.Year);
previsao.sDescricao = expInc.sDescricao;
previsao.dData = expInc.dDataBase;
previsao.dValor = expInc.dValor;
if (expInc.CategoryType == CategoryType.Receita)
{
previsao.dValor *= (-1);
}
previsao.bPago = true;
previsao.sAccountID = expInc.sAccountID;
previsao.sCategoryID = expInc.sCategoryID;
previsao.sAgrupadorID = expInc.sAgrupadorOcorrencia;
}
previsao.sDescCategoria = categoryBusiness.Get.FirstOrDefault(c => c.sID == previsao.sCategoryID).descricao;
if (!string.IsNullOrEmpty(previsao.sAccountID))
{
previsao.sDescConta = accountBusiness.Get.FirstOrDefault(a => a.sID == previsao.sAccountID).sNome;
}
else
{
previsao.sDescConta = string.Empty;
}
lista.Add(previsao);
}
}
}
#endregion
#region ----------------------------------------------------------------------- Cartão de Crédito ------------------------------------------------------------------
List <Account> lstCartoes = accountBusiness.Get.Where(a => a.sUserID == AuthProvider.UserAntenticated.sID && a.AccountType == AccountType.CartaoDeCredito && a.StatusType == StatusType.Ativo).ToList();
foreach (Account conta in lstCartoes)
{
string sExpenseIncomePagCartaoID = string.Empty;
// Verifica se o Cartão já foi pago este mês
List <ExpenseIncome> lstPagCartao = expenseIncomeBusiness.Get.Where(e => e.sUserID == AuthProvider.UserAntenticated.sID && e.CategoryType == CategoryType.PagamentoCartaoCredito && e.dData >= dInicioMes && e.dData <= dFimMes).ToList();
foreach (ExpenseIncome pagCartao in lstPagCartao)
{
ExpenseIncomeReference expRef = expenseIncomeReferenceBusiness.Get.FirstOrDefault(e => e.sExpenseIncomeDestinyID == pagCartao.sID);
if (expRef != null)
{
if (expenseIncomeBusiness.Get.FirstOrDefault(e => e.sID == expRef.sExpenseIncomeOriginID).sAccountID.Equals(conta.sID))
{
sExpenseIncomePagCartaoID = pagCartao.sID;
break;
}
}
}
// se já tem um registro de pagamento só catabiliza oque foi pago, senão pega os possíveis itens para o mês
if (string.IsNullOrEmpty(sExpenseIncomePagCartaoID))
{
DateTime dataFechamento = CadeODinheiro.Web.Infrastructure.Utils.OperacaoData.retornoDataTimeValido(iAno, iMes, conta.iDiaFechamentoCC);
//adiciona os dias de prazo para pagamento e ver se fica no mesmo mês se não um mês é reduzido
if (dataFechamento.AddDays(15).Month != iMes)
{
dataFechamento = dataFechamento.AddMonths(-1);
}
DateTime dataInicioVigencia = dataFechamento.AddMonths(-1).AddDays(1);
// pega os itens avulsos
List <ExpenseIncome> lstGastos = expenseIncomeBusiness.Get.Where(e => e.sAccountID == conta.sID && e.dData >= dataInicioVigencia && e.dData <= dataFechamento && e.iTotalOcorrencia == 1).ToList();
foreach (ExpenseIncome gasto in lstGastos)
{
PrevisaoMesModel previsao = new PrevisaoMesModel();
previsao.dData = gasto.dData;
previsao.dValor = gasto.dValor;
if (gasto.CategoryType == CategoryType.Receita)
{
previsao.dValor *= (-1);
}
previsao.sAccountID = gasto.sAccountID;
previsao.sCategoryID = gasto.sCategoryID;
previsao.sDescricao = gasto.sDescricao;
previsao.sAgrupadorID = gasto.sAgrupadorOcorrencia;
previsao.bPago = false;
previsao.sDescCategoria = categoryBusiness.Get.FirstOrDefault(c => c.sID == previsao.sCategoryID).descricao;
previsao.sDescConta = accountBusiness.Get.FirstOrDefault(a => a.sID == previsao.sAccountID).sNome;
lista.Add(previsao);
}
// calcula os parcelados
lstGastos = expenseIncomeBusiness.Get.Where(e => e.sAccountID == conta.sID && e.iTotalOcorrencia > 1).ToList();
foreach (ExpenseIncome gasto in lstGastos)
{
DateTime dataCalculada = gasto.dData.AddMonths((gasto.iNumeroOcorrencia - 1));
if (dataCalculada >= dataInicioVigencia && dataCalculada <= dataFechamento)
{
PrevisaoMesModel previsao = new PrevisaoMesModel();
previsao.dData = gasto.dData;
previsao.dValor = gasto.dValor;
if (gasto.CategoryType == CategoryType.Receita)
{
previsao.dValor *= (-1);
}
previsao.sAccountID = gasto.sAccountID;
previsao.sCategoryID = gasto.sCategoryID;
previsao.sDescricao = gasto.sDescricao + " - " + gasto.iNumeroOcorrencia + "/" + gasto.iTotalOcorrencia;
previsao.sAgrupadorID = gasto.sAgrupadorOcorrencia;
previsao.bPago = false;
previsao.sDescCategoria = categoryBusiness.Get.FirstOrDefault(c => c.sID == previsao.sCategoryID).descricao;
previsao.sDescConta = accountBusiness.Get.FirstOrDefault(a => a.sID == previsao.sAccountID).sNome;
lista.Add(previsao);
}
}
}
else
{
List <ExpenseIncomeReference> lstGastos = expenseIncomeReferenceBusiness.Get.Where(e => e.sExpenseIncomeDestinyID == sExpenseIncomePagCartaoID).ToList();
foreach (ExpenseIncomeReference gasto in lstGastos)
{
ExpenseIncome expInc = expenseIncomeBusiness.Get.FirstOrDefault(e => e.sID == gasto.sExpenseIncomeOriginID);
PrevisaoMesModel previsao = new PrevisaoMesModel();
previsao.dData = expInc.dData;
previsao.dValor = expInc.dValor;
if (expInc.CategoryType == CategoryType.Receita)
{
previsao.dValor *= (-1);
}
previsao.sAccountID = expInc.sAccountID;
previsao.sCategoryID = expInc.sCategoryID;
previsao.sDescricao = expInc.sDescricao;
if (expInc.iTotalOcorrencia > 1)
{
previsao.sDescricao += " - " + expInc.iNumeroOcorrencia + "/" + expInc.iTotalOcorrencia;
}
previsao.sAgrupadorID = expInc.sAgrupadorOcorrencia;
previsao.bPago = true;
previsao.sDescCategoria = categoryBusiness.Get.FirstOrDefault(c => c.sID == previsao.sCategoryID).descricao;
previsao.sDescConta = accountBusiness.Get.FirstOrDefault(a => a.sID == previsao.sAccountID).sNome;
lista.Add(previsao);
}
}
}
#endregion
return(lista);
}
public ActionResult Transferencia(TransferenciaModel transferModel)
{
if (ModelState.IsValid)
{
using (var scope = new TransactionScope())
{
try
{
if (transferModel.dValor <= 0)
{
throw new InvalidOperationException("Valor deve ser maior que 0 (zero)!");
}
ExpenseIncome expIncOrigem = new ExpenseIncome();
expIncOrigem.dData = transferModel.dData;
expIncOrigem.dDataBase = transferModel.dData;
expIncOrigem.dValor = transferModel.dValor;
expIncOrigem.sCategoryID = transferModel.sCategoryID;
expIncOrigem.CategoryType = categoryBusiness.Get.FirstOrDefault(c => c.sID == transferModel.sCategoryID).CategoryType;
expIncOrigem.sAccountID = transferModel.sAccountOriginID;
expIncOrigem.sDescricao = transferModel.sDescricao;
expIncOrigem.sUserID = AuthProvider.UserAntenticated.sID;
expIncOrigem.bTransferOrigem = true;
expenseIncomeBusiness.Insert(expIncOrigem);
ExpenseIncome expIncDestino = new ExpenseIncome();
expIncDestino.dData = transferModel.dData;
expIncDestino.dDataBase = transferModel.dData;
expIncDestino.dValor = transferModel.dValor;
expIncDestino.sCategoryID = transferModel.sCategoryID;
expIncDestino.CategoryType = categoryBusiness.Get.FirstOrDefault(c => c.sID == transferModel.sCategoryID).CategoryType;
expIncDestino.sAccountID = transferModel.sAccountDestinyID;
expIncDestino.sDescricao = transferModel.sDescricao;
expIncDestino.sUserID = AuthProvider.UserAntenticated.sID;
expIncDestino.bTransferOrigem = false;
expenseIncomeBusiness.Insert(expIncDestino);
ExpenseIncomeReference expIncRef = new ExpenseIncomeReference();
expIncRef.sExpenseIncomeOriginID = expIncOrigem.sID;
expIncRef.sExpenseIncomeDestinyID = expIncDestino.sID;
expenseIncomeReferenceBusiness.Insert(expIncRef);
scope.Complete();
return(Json(new
{
Sucesso = true,
Mensagem = "Transferência Gerado com Sucesso!",
Titulo = "Sucesso",
Url = "/Home/PaginaInicial"
}));
}
catch (DbEntityValidationException dbEx)
{
string sErro = string.Empty;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
sErro += string.Format(" Property: {0} Error: {1} |", validationError.PropertyName, validationError.ErrorMessage);
}
}
scope.Dispose();
return(Json(new
{
Sucesso = false,
Mensagem = sErro,
Titulo = "Erro"
}));
}
catch (Exception ex)
{
string sErro = ex.Message;
if (ex.InnerException != null)
{
sErro += " - " + ex.InnerException.Message;
}
scope.Dispose();
return(Json(new
{
Sucesso = false,
Mensagem = sErro,
Titulo = "Erro"
}));
}
}
}
else
{
transferModel.listaCategorias = getComboCategorias(new List <CategoryType>()
{
CategoryType.Transferencia
});
transferModel.listaContas = getComboContas(false, true);
return(View(transferModel));
}
}
public ActionResult PagamentoCartaoCredito(CCPaymentModel ccPayment)
{
using (var scope = new TransactionScope())
{
try
{
if (string.IsNullOrEmpty(ccPayment.sListaGastosID))
{
throw new InvalidOperationException("Os gastos devem ser selecionados.");
}
if (string.IsNullOrEmpty(ccPayment.sDescricao))
{
throw new InvalidOperationException("A descrição deve ser preenchida.");
}
if (ccPayment.dData == DateTime.MinValue)
{
throw new InvalidOperationException("A data deve ser preenchida.");
}
List <string> listaGastos = ccPayment.sListaGastosID.Split(';').ToList();
List <ExpenseIncome> listaExpenses = new List <ExpenseIncome>();
List <string> listaGastosProcessados = new List <string>();
double dTotalPagar = 0;
foreach (string gasto in listaGastos)
{
if (!string.IsNullOrEmpty(gasto) && !listaGastosProcessados.Contains(gasto))
{
ExpenseIncome exp = expenseIncomeBusiness.Get.FirstOrDefault(e => e.sID == gasto);
if (exp == null)
{
throw new InvalidOperationException("Problemas na identificação do gasto (" + gasto + ").");
}
if (exp.bPagoCartaoCredito)
{
throw new InvalidOperationException("Gasto (" + exp.sDescricao + ") já marcado como pago.");
}
double valorLancamento = exp.dValor;
if (exp.CategoryType == CategoryType.Receita)
{
valorLancamento = valorLancamento * (-1);
}
dTotalPagar += valorLancamento;
listaExpenses.Add(exp);
listaGastosProcessados.Add(gasto);
}
}
ExpenseIncome expPagCC = new ExpenseIncome();
expPagCC.bPagoCartaoCredito = false;
expPagCC.bTransferOrigem = false;
expPagCC.CategoryType = CategoryType.PagamentoCartaoCredito;
expPagCC.dData = ccPayment.dData;
expPagCC.dDataBase = ccPayment.dData;
expPagCC.dValor = dTotalPagar;
expPagCC.sAccountID = ccPayment.sAccountPaymentID;
expPagCC.sCategoryID = ccPayment.sCategoryID;
expPagCC.sDescricao = ccPayment.sDescricao;
expPagCC.sUserID = AuthProvider.UserAntenticated.sID;
expenseIncomeBusiness.Insert(expPagCC);
foreach (ExpenseIncome exp in listaExpenses)
{
expenseIncomeBusiness.RegistraExpensePagoCartaoCredito(exp);
ExpenseIncomeReference expRef = new ExpenseIncomeReference();
expRef.sExpenseIncomeOriginID = exp.sID;
expRef.sExpenseIncomeDestinyID = expPagCC.sID;
expenseIncomeReferenceBusiness.Insert(expRef);
}
scope.Complete();
return(Json(new { Sucesso = true, Mensagem = "Pagamento de Cartão de Crédito realizado com sucesso.", Titulo = "Sucesso" }, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
scope.Dispose();
return(Json(new { Sucesso = false, Mensagem = ex.Message, Titulo = "Erro" }, JsonRequestBehavior.AllowGet));
}
}
}
public ActionResult LancamentoAgrupado(ExpIncAgrupadorModel model)
{
if (ModelState.IsValid)
{
using (var scope = new TransactionScope())
{
try
{
foreach (ExpIncAgrupadorItemModel expIncAgrup in model.listaItens)
{
if (!string.IsNullOrEmpty(expIncAgrup.sID) && expenseIncomeBusiness.Get.Any(e => e.sID == expIncAgrup.sID))
{
// Alterar
ExpenseIncome expInc = expenseIncomeBusiness.Get.FirstOrDefault(e => e.sID == expIncAgrup.sID);
expInc.dData = model.dData;
expInc.dDataBase = model.bDataDiferente ? model.dDataBase : expInc.dData;
if (expIncAgrup.dValor <= 0)
{
throw new InvalidOperationException("Valor deve ser maior que 0 (zero)!");
}
expInc.dValor = expIncAgrup.dValor;
expInc.sCategoryID = model.sCategoryID;
expInc.CategoryType = categoryBusiness.Get.FirstOrDefault(c => c.sID == model.sCategoryID).CategoryType;
expInc.sDescricao = model.sDescricao;
expInc.sNotificationID = model.sNotificationID;
expenseIncomeBusiness.Update(expInc);
}
else
{
scope.Dispose();
return(Json(new
{
Sucesso = false,
Mensagem = "Erro na identificação do lançamento!",
Titulo = "Erro",
Url = "/Home/PaginaInicial"
}));
}
}
scope.Complete();
return(Json(new
{
Sucesso = true,
Mensagem = "Lançamentos Alterados com Sucesso!",
Titulo = "Sucesso",
Url = "/Home/PaginaInicial"
}));
}
catch (DbEntityValidationException dbEx)
{
scope.Dispose();
string sErro = string.Empty;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
sErro += string.Format(" Property: {0} Error: {1} |", validationError.PropertyName, validationError.ErrorMessage);
}
}
return(Json(new
{
Sucesso = false,
Mensagem = sErro,
Titulo = "Erro"
}));
}
catch (Exception ex)
{
scope.Dispose();
string sErro = ex.Message;
if (ex.InnerException != null)
{
sErro += " - " + ex.InnerException.Message;
}
return(Json(new
{
Sucesso = false,
Mensagem = sErro,
Titulo = "Erro"
}));
}
}
}
else
{
model.listaCategorias = getComboCategorias(new List <CategoryType>()
{
CategoryType.Despesa, CategoryType.Receita
});
model.listaNotifications = getComboNotificacoes();
return(View(model));
}
}
public ActionResult Lancamento(ExpenseIncomeModel model)
{
if (ModelState.IsValid)
{
try
{
if (model.dValor <= 0)
{
throw new InvalidOperationException("Valor deve ser maior que 0 (zero)!");
}
ExpenseIncome expInc = null;
if (!string.IsNullOrEmpty(model.sID) && expenseIncomeBusiness.Get.Any(e => e.sID == model.sID))
{
// Alterar
expInc = expenseIncomeBusiness.Get.FirstOrDefault(e => e.sID == model.sID);
if (!string.IsNullOrEmpty(expInc.sAgrupadorOcorrencia))
{
return(Json(new { Sucesso = false, Mensagem = "Lançamento com Agrupador não podem ser alterados pela tela de alteração individual!", Titulo = "Restrição", Url = "/Home/PaginaInicial" }));
}
expInc.dData = model.dData;
expInc.dDataBase = model.bDataDiferente ? model.dDataBase : expInc.dData;
expInc.dValor = model.dValor;
expInc.sCategoryID = model.sCategoryID;
expInc.CategoryType = categoryBusiness.Get.FirstOrDefault(c => c.sID == model.sCategoryID).CategoryType;
expInc.sAccountID = model.sAccountID;
expInc.sDescricao = model.sDescricao;
expInc.sNotificationID = model.sNotificationID;
expenseIncomeBusiness.Update(expInc);
return(Json(new
{
Sucesso = true,
Mensagem = "Lançamento Alterado com Sucesso!",
Titulo = "Sucesso",
Url = "/Home/PaginaInicial"
}));
}
else
{
// Inserir
Account conta = accountBusiness.Get.FirstOrDefault(c => c.sID == model.sAccountID);
if (conta.AccountType != AccountType.CartaoDeCredito)
{
model.iTotalParcelas = 1;
}
double dValorDivisao = model.dValor / model.iTotalParcelas;
if (dValorDivisao < 0.01)
{
throw new InvalidOperationException("Valor da divisão menor que R$ 0,01!");
}
dValorDivisao = Math.Round(dValorDivisao, 2);
double dValorSobra = model.dValor;
string sAgrupadorParcelas = sAgrupadorParcelas = Guid.NewGuid().ToString();
for (int i = 1; i <= model.iTotalParcelas; i++)
{
expInc = new ExpenseIncome();
expInc.dData = model.dData;
expInc.dDataBase = model.bDataDiferente ? model.dDataBase : expInc.dData;
expInc.sCategoryID = model.sCategoryID;
expInc.CategoryType = categoryBusiness.Get.FirstOrDefault(c => c.sID == model.sCategoryID).CategoryType;
expInc.sAccountID = model.sAccountID;
expInc.sDescricao = model.sDescricao;
expInc.sNotificationID = model.sNotificationID;
expInc.sUserID = AuthProvider.UserAntenticated.sID;
if (i == model.iTotalParcelas)
{
expInc.dValor = dValorSobra;
}
else
{
expInc.dValor = dValorDivisao;
dValorSobra -= expInc.dValor;
}
expInc.iNumeroOcorrencia = i;
expInc.iTotalOcorrencia = model.iTotalParcelas;
if (model.iTotalParcelas > 1)
{
expInc.sAgrupadorOcorrencia = sAgrupadorParcelas;
}
expenseIncomeBusiness.Insert(expInc);
}
return(Json(new
{
Sucesso = true,
Mensagem = "Lançamento Gerado com Sucesso!",
Titulo = "Sucesso",
Url = "/Home/PaginaInicial"
}));
}
}
catch (DbEntityValidationException dbEx)
{
string sErro = string.Empty;
foreach (var validationErrors in dbEx.EntityValidationErrors)
{
foreach (var validationError in validationErrors.ValidationErrors)
{
sErro += string.Format(" Property: {0} Error: {1} |", validationError.PropertyName, validationError.ErrorMessage);
}
}
return(Json(new
{
Sucesso = false,
Mensagem = sErro,
Titulo = "Erro"
}));
}
catch (Exception ex)
{
string sErro = ex.Message;
if (ex.InnerException != null)
{
sErro += " - " + ex.InnerException.Message;
}
return(Json(new
{
Sucesso = false,
Mensagem = sErro,
Titulo = "Erro"
}));
}
}
else
{
model.listaCategorias = getComboCategorias(new List <CategoryType>()
{
CategoryType.Despesa, CategoryType.Receita
});
model.sConcatCartaoCredito = getConcatCartaoCredito();
model.listaContas = getComboContas(false, true);
model.listaNotifications = getComboNotificacoes();
return(View(model));
}
}
public ActionResult Lancamento(string sNotificacaoID, string sExpenseIncomeID)
{
ExpenseIncomeModel model = new ExpenseIncomeModel();
if (!string.IsNullOrEmpty(sExpenseIncomeID) && expenseIncomeBusiness.Get.Any(e => e.sID == sExpenseIncomeID))
{
ExpenseIncome expInc = expenseIncomeBusiness.Get.FirstOrDefault(e => e.sID == sExpenseIncomeID);
// restrições -----------------------------------------------------------------------------------------------------------
//if (expInc.CategoryType == CategoryType.PagamentoCartaoCredito) return Json(new { Sucesso = false, Mensagem = "Lançamentos de Pagamento de Cartão de Crédito não podem ser alterados!", Titulo = "Restrição" }, JsonRequestBehavior.AllowGet);
if (expInc.CategoryType == CategoryType.Transferencia)
{
return(Json(new { Sucesso = false, Mensagem = "Lançamentos de Transferência não podem ser alterados!", Titulo = "Restrição" }, JsonRequestBehavior.AllowGet));
}
if (expInc.bPagoCartaoCredito)
{
return(Json(new { Sucesso = false, Mensagem = "Lançamentos já marcados como pago no Cartão de Crédito não podem ser alterados!", Titulo = "Restrição" }, JsonRequestBehavior.AllowGet));
}
//-----------------------------------------------------------------------------------------------------------------------
model.sID = expInc.sID;
model.sDescricao = expInc.sDescricao;
model.sCategoryID = expInc.sCategoryID;
model.eCategoryType = expInc.CategoryType;
model.sNotificationID = expInc.sNotificationID;
model.sAccountID = expInc.sAccountID;
model.dData = expInc.dData;
model.dDataBase = expInc.dDataBase;
model.bDataDiferente = model.dData != model.dDataBase ? true : false;
model.dValor = expInc.dValor;
}
else
{
if (!string.IsNullOrEmpty(sNotificacaoID))
{
Notification not = notificationBusiness.Get.FirstOrDefault(n => n.sID == sNotificacaoID);
if (not != null)
{
model.sNotificationID = not.sID;
model.sDescricao = not.sDescricao;
model.dValor = not.dValor;
model.sCategoryID = not.sCategoryID;
}
}
model.dData = DateTime.Now;
model.dDataBase = DateTime.Now;
model.bDataDiferente = false;
}
if (model.eCategoryType == CategoryType.PagamentoCartaoCredito)
{
model.listaCategorias = getComboCategorias(new List <CategoryType>()
{
CategoryType.PagamentoCartaoCredito
});
}
else
{
model.listaCategorias = getComboCategorias(new List <CategoryType>()
{
CategoryType.Despesa, CategoryType.Receita
});
}
model.sConcatCartaoCredito = getConcatCartaoCredito();
model.listaContas = getComboContas(false, true);
model.listaNotifications = getComboNotificacoes();
return(View(model));
}
public ActionResult ExcluirLancamento(string sLancamentoID, string sAgrupadorID)
{
if (!string.IsNullOrEmpty(sLancamentoID))
{
using (var scope = new TransactionScope())
{
try
{
List <ExpenseIncome> lstExpExcluir = new List <ExpenseIncome>();
if (string.IsNullOrEmpty(sAgrupadorID))
{
lstExpExcluir = expenseIncomeBusiness.Get.Where(e => e.sID == sLancamentoID).ToList();
}
else
{
lstExpExcluir = expenseIncomeBusiness.Get.Where(e => e.sAgrupadorOcorrencia == sAgrupadorID).ToList();
}
if (lstExpExcluir == null || lstExpExcluir.Count == 0)
{
throw new InvalidOperationException("Lançamento não identificado!");
}
foreach (ExpenseIncome expExcluir in lstExpExcluir)
{
if (expExcluir.bPagoCartaoCredito)
{
throw new InvalidOperationException("Lançamento marcado como pago, excluir primeiro o lançamento de pagamento do cartão de crédito!");
}
List <ExpenseIncomeReference> expIncRef = expenseIncomeReferenceBusiness.Get.Where(e => e.sExpenseIncomeOriginID == expExcluir.sID).ToList();
if (expIncRef == null || expIncRef.Count == 0)
{
expIncRef = expenseIncomeReferenceBusiness.Get.Where(e => e.sExpenseIncomeDestinyID == expExcluir.sID).ToList();
}
if (expIncRef != null && expIncRef.Count > 0)
{
string sDestino = string.Empty;
foreach (ExpenseIncomeReference eiRef in expIncRef)
{
string sOrigem = eiRef.sExpenseIncomeOriginID;
sDestino = eiRef.sExpenseIncomeDestinyID;
expenseIncomeReferenceBusiness.Delete(eiRef.sID);
if (expExcluir.CategoryType == CategoryType.PagamentoCartaoCredito)
{
ExpenseIncome expOrigem = expenseIncomeBusiness.Get.FirstOrDefault(e => e.sID == sOrigem);
expOrigem.bPagoCartaoCredito = false;
expenseIncomeBusiness.Update(expOrigem);
Account account = accountBusiness.Get.FirstOrDefault(a => a.sID == expOrigem.sAccountID);
account.dSaldo -= expOrigem.dValor;
accountBusiness.Update(account);
}
else
{
expenseIncomeBusiness.Delete(sOrigem);
}
}
expenseIncomeBusiness.Delete(sDestino);
}
else
{
expenseIncomeBusiness.Delete(expExcluir.sID);
}
}
scope.Complete();
return(Json(new { Sucesso = true, Titulo = "Sucesso", Mensagem = "Lançamento excluido com sucesso." }, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
scope.Dispose();
return(Json(new { Sucesso = false, Titulo = "Erro", Mensagem = ex.Message }, JsonRequestBehavior.AllowGet));
}
}
}
else
{
return(Json(new { Sucesso = false, Titulo = "Erro", Mensagem = "Lançamento não informado!" }, JsonRequestBehavior.AllowGet));
}
}
public ExpenseIncome Update(ExpenseIncome expenseIncome)
{
var updatedIncome = _expenseIncomeRepository.Update(expenseIncome);
return(updatedIncome);
}
public ExpenseIncome Create(ExpenseIncome expenseIncome)
{
var createdExpenseIncome = _expenseIncomeRepository.Create(expenseIncome);
return(createdExpenseIncome);
}
public ActionResult <ExpenseIncome> Update(ExpenseIncome expenseIncome)
{
var updatedExpenseIncome = _expenseIncomeService.Update(expenseIncome);
return(Ok(updatedExpenseIncome));
}