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));
        }
Esempio n. 2
0
        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));
            }
        }
Esempio n. 14
0
        public ExpenseIncome Update(ExpenseIncome expenseIncome)
        {
            var updatedIncome = _expenseIncomeRepository.Update(expenseIncome);

            return(updatedIncome);
        }
Esempio n. 15
0
        public ExpenseIncome Create(ExpenseIncome expenseIncome)
        {
            var createdExpenseIncome = _expenseIncomeRepository.Create(expenseIncome);

            return(createdExpenseIncome);
        }
Esempio n. 16
0
        public ActionResult <ExpenseIncome> Update(ExpenseIncome expenseIncome)
        {
            var updatedExpenseIncome = _expenseIncomeService.Update(expenseIncome);

            return(Ok(updatedExpenseIncome));
        }