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