public Budget(Guid id, Fund fund, BudgetPeriod period, decimal setAmount = 0) { this.Id = id; this.Fund = fund; this.BudgetPeriod = period; this.SetAmount = setAmount; }
public async Task <Fund> LoadFundTree(Fund root, BudgetPeriod budgetPeriod) { Fund rootWBudget = (await this.LoadCurrentBudgetForFunds(new Fund[] { root }, budgetPeriod)).First(); rootWBudget.SubFunds = await this.LoadFundTreeRecursive(root, budgetPeriod); return(rootWBudget); }
public void FillActualBudget(Category category, BudgetPeriod period, decimal value) { var monthlyBudget = PrepareBudgetEntity(category, period); monthlyBudget.ActualBudget = value; _repository.Update(monthlyBudget); _unitOfWork.Commit(); }
public BudgetPeriod RecalculateBudgetPeriod(BudgetPeriod period, decimal runningtotal) { period.Expenditure = period.items.Where(x => x.Item.Type == ItemType.Expense).Sum(x => x.Value); period.Income = period.items.Where(x => x.Item.Type == ItemType.Income).Sum(x => x.Value); period.Bank = (runningtotal + period.Income) - period.Expenditure; //ToDo: slightly messy here when adding a new there will be an insert and update (for now so what) _BudgetPeriodRepository.Update(period); return(period); }
public BudgetPeriod Build() { if (this.duration == null) { throw new InvalidOperationException("You must set the duration using ForDuration(BudgetDurationBase) before building the period"); } DateTime endDate = this.duration.GetEndDateFromStartDate(this.startDate); BudgetPeriod period = new BudgetPeriod(Guid.NewGuid(), this.startDate, endDate); return(period); }
private void InitRandomized() { _id = Guid.NewGuid(); _setAmount = _faker.Finance.Amount(); this.fund = this._fundBuilder.Build(); DateTime now = DateTime.Now; this.budgetPeriod = new BudgetPeriod(now, this.fund.Duration.GetEndDateFromStartDate(now)); }
private (Budget, BudgetPeriod) CreateNewUserRootBudget(User user) { BudgetDurationBase duration = new MonthlyBookEndedDuration(newUserRootBudgetDurationEndDate, newUserRootBudgetDurationShouldRollover); Fund rootFund = new Fund(newUserRootFundName, newUserRootFundBalance, duration, user.Id); DateTime startDate = DateTime.Now; DateTime endDate = duration.GetEndDateFromStartDate(startDate); BudgetPeriod firstBudgetPeriod = new BudgetPeriod(startDate, endDate); Budget firstRootBudget = new Budget(rootFund, firstBudgetPeriod); firstBudgetPeriod.RootBudget = firstRootBudget; return(firstRootBudget, firstBudgetPeriod); }
public static SelectList GetBudgetPeriod() { BPARepo repo = new BPARepo(); var budgetPeriods = new List <BudgetPeriod>(); var budgetPeriod = new BudgetPeriod() { Id = 0, Name = "Please Select", }; budgetPeriods.Add(budgetPeriod); budgetPeriods.AddRange(repo.BudgetPeriod.GetAll().ToList()); return(CreateSelectList(budgetPeriods, x => x.Id, x => x.Name)); }
private async Task <IEnumerable <Fund> > LoadFundTreeRecursive(Fund root, BudgetPeriod budgetPeriod) { IEnumerable <Fund> loadedSubFunds = await this.unitOfWork.GetRepository <Fund>() .GetAll() .Include(f => f.Duration) .Where(b => b.ParentFundId == root.Id) .ToListAsync(); loadedSubFunds = await this.LoadCurrentBudgetForFunds(loadedSubFunds, budgetPeriod); foreach (Fund subFund in loadedSubFunds) { subFund.SubFunds = await LoadFundTreeRecursive(subFund, budgetPeriod); } return(loadedSubFunds); }
public async Task <Fund> Run() { DateTime now = DateTime.Now.Date; IRepository <Fund> fundRepo = this.unitOfWork.GetRepository <Fund>(); IRepository <BudgetPeriod> periodRepo = this.unitOfWork.GetRepository <BudgetPeriod>(); Fund rootFund = await fundRepo.GetAll() .SingleAsync(f => f.UserId == this.userId && !f.ParentFundId.HasValue); IQuerySet <BudgetPeriod> usersBudgetPeriods = periodRepo.GetAll().Include(p => p.RootBudget) .Where(p => p.RootBudget.FundId == rootFund.Id); BudgetPeriod currentPeriod = await BudgetPeriodQueryUtils.GetForDate(usersBudgetPeriods, this.date); rootFund = await this.budgetLoader.LoadFundTree(rootFund, currentPeriod); return(rootFund); }
public async Task <bool> UpdateBudgetPeriod(string userId, BudgetPeriod budgetPeriod) { try { if (string.IsNullOrEmpty(userId)) { // No user Id specified, return false return(false); } var budgetPeriodToUpdate = await _context.budgetPeriods .Where(bp => bp.UserId == userId && bp.BudgetPeriodId == budgetPeriod.BudgetPeriodId) .FirstOrDefaultAsync(); if (budgetPeriodToUpdate == null) { // No existing budget period found, return false return(false); } // Else, update the budget period budgetPeriodToUpdate.BudgetPeriodTypeId = budgetPeriod.BudgetPeriodTypeId; budgetPeriodToUpdate.UserId = budgetPeriod.UserId; budgetPeriodToUpdate.StartDate = budgetPeriod.StartDate; // Save changes if (await _context.SaveChangesAsync() > 0) { return(true); } else { return(false); } } catch (Exception) { return(false); } }
public BudgetPeriod CreateNewBudgetPeriod(ClientBudget budget) { var budgetPeriod = new BudgetPeriod(budget); foreach (var item in budget.Items.Where(x => x.Active == true)) { var perioditem = new BudgetPeriodItem(budgetPeriod, item); _BudgetPeriodItemService.SaveBudgetPeriodItem(perioditem); } budgetPeriod.PeriodCaputureDate = GetNextPeriodDate(budget.Periods); _BudgetPeriodRepository.Add(budgetPeriod); RecalculateBudgetPeriod(budgetPeriod, GetRunningTotal(budget.Periods)); return(budgetPeriod); }
public static void Create(BudgetPeriodVM model, BPARepo bpaRepo) { var budgetPeriod = new BudgetPeriod() { Name = model.Name, }; budgetPeriod.Validate(); var exist = bpaRepo.BudgetPeriod.GetAll().Any(x => x.Name.Trim().ToLower() == budgetPeriod.Name.Trim().ToLower()); if (!exist) { bpaRepo.BudgetPeriod.Create(budgetPeriod); } else { throw new Exception($"{model.Name} already exist"); } }
private MonthlyBudget PrepareBudgetEntity(Category category, BudgetPeriod period) { var monthlyBudget = _repository.GetForCategory(category, period); if (monthlyBudget == null) { // TODO czy entity z EF mogą mieć niedomyślne konstruktory? monthlyBudget = new MonthlyBudget { Year = period.Year, Month = period.Month, Category = category }; _repository.Insert(monthlyBudget); } return(monthlyBudget); }
private void InsertInitialData() { var database = PetaPocoRegistry.GetDatabase(); using (var scope = database.Transaction) { var periods = database.Fetch <BudgetPeriod>(); if (!periods.Any()) { var period = new BudgetPeriod { Description = "April", FromDate = new DateTime(2011, 4, 1), ToDate = new DateTime(2011, 4, 30) }; database.Insert(period); var expense = new Expense { BudgetPeriodId = period.BudgetPeriodId, Description = "Test Expense", BudgetAmount = 20.0m }; var expense2 = new Expense { BudgetPeriodId = period.BudgetPeriodId, Description = "Extra meals", BudgetAmount = 100.0m }; database.Insert(expense); database.Insert(expense2); } scope.Complete(); } }
// GET: CategoryPieChart public ActionResult GetCategoryPieChart(BudgetPeriod period) { period = (period == BudgetPeriod.None ? BudgetPeriod.avg90Days : period); var range = GetDateRange(period); var catDVM = CategoryBudget(range.start, range.end); var incomeCategories = catDVM.IncCats.OrderByDescending(a => a.Actual); var IEPie = new IncExpPieChart(); var numCats = catDVM.IncCats.Count(); IEPie.income.labels = new string[numCats]; IEPie.income.series = new int[numCats]; IEPie.income.seriesCount = numCats; decimal sum = 0; foreach (var item in incomeCategories) { sum += item.Actual; // calculate sum in order to normalize values } if (sum == 0) sum = 1; int i = 0; foreach (var item in incomeCategories) { IEPie.income.series[i] = Decimal.ToInt32(Math.Round(100 * item.Actual / sum)); // normalize to 100 IEPie.income.labels[i] = item.Name; i++; } var expenseCategories = catDVM.ExpCats.OrderBy(a => a.Actual); numCats = catDVM.ExpCats.Count(); IEPie.expense.labels = new string[numCats]; IEPie.expense.series = new int[numCats]; IEPie.expense.seriesCount = numCats; sum = 0; foreach (var item in expenseCategories) { sum += item.Actual; // calculate sum in order to normalize values } i = 0; if (sum == 0) sum = 1; foreach (var item in expenseCategories) { IEPie.expense.series[i] = Decimal.ToInt32(Math.Round(100 * item.Actual / sum)); // normalize to 100 IEPie.expense.labels[i] = item.Name; i++; } return Content(JsonConvert.SerializeObject(IEPie), "application/json"); }
public async Task <IEnumerable <Fund> > LoadCurrentBudgetForFunds(IEnumerable <Fund> funds, BudgetPeriod budgetPeriod) { IEnumerable <Guid> loadedFundsIds = funds.Select(x => x.Id); IEnumerable <Budget> budgets = await this.unitOfWork.GetRepository <Budget>() .GetAll() .Include(b => b.BudgetPeriod) .Where(b => loadedFundsIds.Contains(b.FundId)) .ToListAsync(); budgets = budgets.Where(b => b.BudgetPeriod.StartDate.Date == budgetPeriod.StartDate.Date && b.BudgetPeriod.EndDate.Date == budgetPeriod.EndDate.Date); // .ToListAsync(); // Put the budgets on their corresponding fund. This is equivelant to: // loadedSubFunds = loadedSubFunds inner join budgets on budget.FundId = fund.Id // There should only be one budget per fund, otherwise, this will bug out. funds = funds.Join( budgets, f => f.Id, b => b.FundId, (f, b) => { b.Fund = f; f.HistoricalBudgets = new List <Budget>() { b }; return(f); }); return(funds); }
public ActionResult Index(BudgetPeriod? period) { BudgetPeriod actualDates = period ?? BudgetPeriod.currentMonth; var range = GetDateRange(actualDates); ViewBag.Period = actualDates; var hh = db.Households.Find(Convert.ToInt32(User.Identity.GetHouseholdId())); @ViewBag.ActiveHousehold = hh.Name; var catDVM = CategoryBudget(range.start, range.end); return View(catDVM); }
public ActionResult _Index(BudgetPeriod? period) { BudgetPeriod actualDates = period ?? BudgetPeriod.currentMonth; var range = GetDateRange(actualDates); ViewBag.Period = actualDates; var hh = db.Households.Find(Convert.ToInt32(User.Identity.GetHouseholdId())); @ViewBag.ActiveHousehold = hh.Name; var catDVM = CategoryBudget(range.start, range.end); //if (actualDates > BudgetPeriod.avg90Days) //{ return PartialView(catDVM); //} //else { // return View("Index", "Categories", catDVM); //} }
public BudgetTreeBuilder SetBudgetPeriod(BudgetPeriod budgetPeriod) { this.rootBudgetBuilder.SetBudgetPeriod(budgetPeriod); return(this); }
public IBudgetBuilder SetBudgetPeriod(BudgetPeriod budgetPeriod) { this.budgetPeriod = budgetPeriod; return(this); }
public static void MapDtoToEntityForUpdating(BudgetPeriodDto budgetPeriodDto, BudgetPeriod budgetPeriod) { budgetPeriod.IsActive = budgetPeriodDto.IsActive; budgetPeriod.StartDate = budgetPeriodDto.StartDate; budgetPeriod.EndDate = budgetPeriodDto.EndDate; budgetPeriod.Amount = budgetPeriodDto.Amount; budgetPeriod.ForecastTotal = budgetPeriodDto.ForecastTotal; budgetPeriod.ActualSpendTotal = budgetPeriodDto.ActualSpendTotal; }
public CurrentBudgetPeriodResponse(BudgetPeriod budgetPeriod) { this.StartDate = budgetPeriod.StartDate; this.EndDate = budgetPeriod.EndDate; }
public MonthlyBudget GetForCategory(Category category, BudgetPeriod period) { return(Query() .SingleOrDefault(x => x.Category.Equals(category) && x.Year == period.Year && x.Month == period.Month)); }
public UserRootBudgetRelationship(User user, Budget rootBudget, BudgetPeriod firstPeriod) { this.User = user; this.RootBudget = rootBudget; this.FirstPeriod = firstPeriod; }
public startEndDates GetDateRange(BudgetPeriod? period) { BudgetPeriod actualDates = period ?? BudgetPeriod.currentMonth; // ViewBag.Period = actualDates; DateTime endDate = System.DateTime.Now; var startDate = new DateTime(); var firstOfMonth = new DateTime(endDate.Year, endDate.Month, 1); switch (actualDates) { case BudgetPeriod.currentMonth: case BudgetPeriod.currentMonthPartial: startDate = firstOfMonth; ViewBag.Period = "Current Month"; break; case BudgetPeriod.priorMonth: case BudgetPeriod.priorMonthPartial: startDate = firstOfMonth.AddMonths(-1); endDate = firstOfMonth.AddDays(-1); ViewBag.Period = "Prior Month"; break; case BudgetPeriod.last30Days: case BudgetPeriod.last30DaysPartial: startDate = endDate.AddDays(-30); ViewBag.Period = "Last 30 Days"; break; case BudgetPeriod.avg90Days: case BudgetPeriod.avg90DaysPartial: startDate = endDate.AddDays(-90); ViewBag.Period = "90 day Average"; break; default: startDate = firstOfMonth; break; } var range = new startEndDates(); range.start = startDate; range.end = endDate; return range; }