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));
            }
        }
        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 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));
                }
            }
        }