public ActionResult Index(PageTransactionModel model)
        {
            ViewBag.Message = "Minhas transações";

            if (ModelState.IsValid)
            {
                if (model.Filter == null)
                {
                    model.Filter = new TransactionFilterModel();
                    model.Filter.DateStart = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 01);
                    model.Filter.DateEnd = DateTime.Now.Date;
                    model.Filter.TransactionType = TransactionType.None;
                    model.Filter.OrderBy = TransactionOrder.Date; //model.Filter.OrderBy;
                    model.Filter.OrderByClassification = OrderClassification.Desc; //model.Filter.OrderByClassification;
                    model.Filter.ValueEnd = null;
                    model.Filter.ValueStart = null;
                }

                var filter = new TransactionFilter();
                filter.DateEnd = model.Filter.DateEnd;
                filter.DateStart = model.Filter.DateStart;
                filter.OrderBy = TransactionOrder.Date; //model.Filter.OrderBy;
                filter.OrderByClassification = OrderClassification.Desc; //model.Filter.OrderByClassification;
                filter.ValueEnd = model.Filter.ValueEnd;
                filter.ValueStart = model.Filter.ValueStart;
                filter.TransactionType = model.Filter.TransactionType;

                if (!string.IsNullOrWhiteSpace(model.Filter.Categories))
                {
                    filter.Categories = new List<string>();
                    filter.Categories = model.Filter.Categories.Split(',').Select(s => s.Trim()).ToList();
                }

                if (!string.IsNullOrWhiteSpace(model.Filter.SubCategories))
                {
                    filter.SubCategories = new List<string>();
                    filter.SubCategories = model.Filter.SubCategories.Split(',').Select(s => s.Trim()).ToList();
                }

                if (!string.IsNullOrWhiteSpace(model.Filter.TransactionNames))
                {
                    filter.Names = new List<string>();
                    filter.Names = model.Filter.TransactionNames.Split(',').Select(s => s.Trim()).ToList();
                }

                var transactionService = new TransactionService(new TransactionCSVUnitOfWork());
                model.Transactions = (from transaction in transactionService.GetTransactionsFiltrated(filter)
                                     select new TransactionModel
                                     {
                                         Id = transaction.Id,
                                         Name = transaction.Name,
                                         Date = transaction.Date,
                                         Value = transaction.Value,
                                         Category = transaction.Category,
                                         SubCategory = transaction.SubCategory,
                                     }).ToList();
            }
            else
            {
                model.Errors = this.ModelState.Values;
            }

            if (Request.IsAjaxRequest())
                return Json(model, JsonRequestBehavior.AllowGet);
            else
                return View(model);
        }
        public List<Transaction> GetTransactionsFiltrated(TransactionFilter filter)
        {
            var query = this.uow.Transactions.AsQueryable();

            //var a = new ResumeController();
            //var transactions = a.GetSpents();
            //query = transactions.AsQueryable();

            var onlyInputs = filter.TransactionType == TransactionType.Input;
            var onlyOutputs = filter.TransactionType == TransactionType.Output;

            if (onlyInputs)
                query = query.Where(t => t.Value > 0);

            if (onlyOutputs)
                query = query.Where(t => t.Value < 0);

            if (filter.Categories != null && filter.Categories.Count > 0)
                query = query.Where(t => filter.Categories.Contains(t.Category));

            if (filter.SubCategories != null && filter.SubCategories.Count > 0)
                query = query.Where(t => filter.SubCategories.Contains(t.SubCategory));

            if (filter.Names != null && filter.Names.Count > 0)
                query = query.Where(t => filter.Names.Contains(t.Name));

            if (filter.DateStart != null)
                query = query.Where(t => t.Date >= filter.DateStart);

            if (filter.DateEnd != null)
                query = query.Where(t => t.Date <= filter.DateEnd);

            if (filter.ValueStart != null)
                query = query.Where(t => t.Value >= filter.ValueStart);

            if (filter.ValueEnd != null)
                query = query.Where(t => t.Value <= filter.ValueEnd);

            string orderByName;
            var expressionOrderBy = filter.GetOrderByExpression(filter.OrderBy, out orderByName);

            if (filter.OrderByClassification == OrderClassification.Asc)
                query = query.OrderBy(expressionOrderBy);
            else
                query = query.OrderByDescending(expressionOrderBy);

            return query.ToList();
        }