partial void ToDtoPostprocessing(ref BudgetModelDto dto, BudgetModel model)
{
var mapper3 = new Mapper_ExpenseDto_Expense(this.bucketRepo);
List<ExpenseDto> expenses8 = model.Expenses.Select(mapper3.ToDto).ToList();
dto.Expenses = expenses8;
var mapper4 = new Mapper_IncomeDto_Income(this.bucketRepo);
List<IncomeDto> incomes9 = model.Incomes.Select(mapper4.ToDto).ToList();
dto.Incomes = incomes9;
}
partial void ToModelPostprocessing(BudgetModelDto dto, ref BudgetModel model)
{
var modelType = model.GetType();
var mapper1 = new Mapper_ExpenseDto_Expense(this.bucketRepo);
List<Expense> expenses2 = dto.Expenses.Select(mapper1.ToModel).ToList();
model.LastModified = dto.LastModified ?? DateTime.Now;
modelType.GetProperty("Expenses").SetValue(model, expenses2);
var mapper2 = new Mapper_IncomeDto_Income(this.bucketRepo);
List<Income> incomes3 = dto.Incomes.Select(mapper2.ToModel).ToList();
modelType.GetProperty("Incomes").SetValue(model, incomes3);
}
public static BudgetModel CreateBudgetModel(string dataAreaId, string budgetModel1, global::Microsoft.Dynamics.DataEntities.BudgetRegisterEntry budgetRegisterEntryBudgetModel, global::Microsoft.Dynamics.DataEntities.BudgetRegisterEntryHeader budgetRegisterEntryHeaderBudgetModel)
{
BudgetModel budgetModel = new BudgetModel();
budgetModel.dataAreaId = dataAreaId;
budgetModel.BudgetModel1 = budgetModel1;
if ((budgetRegisterEntryBudgetModel == null))
{
throw new global::System.ArgumentNullException("budgetRegisterEntryBudgetModel");
}
budgetModel.BudgetRegisterEntryBudgetModel = budgetRegisterEntryBudgetModel;
if ((budgetRegisterEntryHeaderBudgetModel == null))
{
throw new global::System.ArgumentNullException("budgetRegisterEntryHeaderBudgetModel");
}
budgetModel.BudgetRegisterEntryHeaderBudgetModel = budgetRegisterEntryHeaderBudgetModel;
return(budgetModel);
}
public void ShowAllSpendingsByInterval_TwoSpendingsWithAmounts5And12InDifferentCategories_Return17()
{
BudgetModel model = new BudgetModel();
string category1 = "clothes";
string category2 = "travelling";
model.AddCategory(category1);
model.AddCategory(category2);
model.AddIncome(20);
model.AddSpending(category1, 5);
model.AddSpending(category2, 12);
DateTime start = new DateTime(2019, 2, 19);
DateTime end = DateTime.Today;
decimal expected = 17;
decimal actual = model.ShowAllSpendingsByInterval(start, end);
Assert.That(actual, Is.EqualTo(expected));
}
public void ShowAllSpendingsByInterval_NoSpendingsInDateInterval_Return0()
{
BudgetModel model = new BudgetModel();
string category1 = "clothes";
string category2 = "travelling";
model.AddCategory(category1);
model.AddCategory(category2);
model.AddIncome(20);
model.AddSpending(category1, 5);
model.AddSpending(category2, 12);
DateTime start = new DateTime(2019, 2, 18);
DateTime end = new DateTime(2019, 2, 19);
decimal expected = 0;
decimal actual = model.ShowAllSpendingsByInterval(start, end);
Assert.That(actual, Is.EqualTo(expected));
}
public BudgetEditorViewModel(BudgetModel budgetModel)
{
_budgetModel = budgetModel;
InitializeRelayCommands();
_addMasterCategoryEditor = new AddMasterCategoryViewModel(this);
_budget = _budgetModel.GetBudget();
_budget.MasterCategories.LoadCollection();
_monthSelector = new MonthSelectorViewModel();
_monthSelector.OnMonthSelected += MonthSelector_OnMonthSelected;
InitializeMonthViews();
_masterCategories = new TransformingObservableCollection <MasterCategory, MasterCategoryRowViewModel>(
_budget.MasterCategories,
(mc) => { return(new MasterCategoryRowViewModel(mc, this)); },
mcvm => { mcvm.Dispose(); });
_masterCategories.Sort(mcr => mcr.MasterCategory.SortOrder);
}
public ActionResult Login(UserModel model)
{
User user = model.Get(model);
if (user != null)
{
SessionManager sessionManager = new SessionManager();
bool passwordCorrect = CheckPassword(user.Password, model.Password);
if (passwordCorrect)
{
if (!user.IsActive)
{
user.IsActive = true;
model.UpdateUser(user);
}
sessionManager.Add <User>(user, PageConstant.USER_ID_I_SESSION);
ViewBag.Name = user.Name;
BudgetModel bmodel = new BudgetModel();
Budget budget = bmodel.GetCurrentBudget(user.Id);
if (budget == null)
{
return(RedirectToAction("FirstLaunch", "FirstLaunch"));
}
sessionManager.Add <Budget>(budget, PageConstant.BUDGET_ID_IN_SESSION);
bmodel.CurrentBudget = budget.CurrentBudget;
bmodel.StartBudget = budget.StartBudget;
return(View("MainPanel", bmodel));
}
}
else
{
ModelState.AddModelError("", "Error");
}
ModelState.Clear();
return(View("UserLoginView"));
}
public void TestInitialise()
{
this.bucketRepo = new BucketBucketRepoAlwaysFind();
this.subject = new RemainingSurplusWidget();
this.criteriaTestData = new GlobalFilterCriteria
{
BeginDate = new DateTime(2015, 10, 20),
EndDate = new DateTime(2015, 11, 19)
};
StatementModelTestDataForThisTest.AccountTypeRepo = new InMemoryAccountTypeRepository();
StatementModelTestDataForThisTest.BudgetBucketRepo = this.bucketRepo;
this.statementTestData = StatementModelTestDataForThisTest.TestDataGenerated();
BudgetModel budgetModel = BudgetModelTestData.CreateTestData1();
this.budgetTestData = new BudgetCurrencyContext(new BudgetCollection(budgetModel), budgetModel);
this.ledgerBookTestData = new LedgerBookBuilder
{
StorageKey = "RemainingSurplusWidgetTest.xml",
Modified = new DateTime(2015, 11, 23),
Name = "Smith Budget 2015"
}
.IncludeLedger(LedgerBookTestData.PhoneLedger, 130M)
.IncludeLedger(LedgerBookTestData.CarMtcLedger, 90M)
.IncludeLedger(LedgerBookTestData.PowerLedger)
.AppendReconciliation(
new DateTime(2015, 10, 20),
new BankBalance(LedgerBookTestData.ChequeAccount, 4502.75M))
.WithReconciliationEntries(
entryBuilder =>
{
entryBuilder.WithLedger(LedgerBookTestData.PhoneLedger).HasNoTransactions();
entryBuilder.WithLedger(LedgerBookTestData.CarMtcLedger).HasNoTransactions();
entryBuilder.WithLedger(LedgerBookTestData.PowerLedger)
.AppendTransactions(txnBuilder => { txnBuilder.WithCredit(3000M, "Oct Savings", new DateTime(2015, 10, 20), "automatchref12"); });
})
.Build();
this.ledgerCalculation = new LedgerCalculation(new FakeLogger());
}
public BudgetModel CloneBudgetModel(BudgetModel sourceBudget, DateTime newBudgetEffectiveFrom)
{
if (sourceBudget == null)
{
throw new ArgumentNullException(nameof(sourceBudget));
}
if (newBudgetEffectiveFrom <= sourceBudget.EffectiveFrom)
{
throw new ArgumentException("The effective date of the new budget must be later than the other budget.", nameof(newBudgetEffectiveFrom));
}
if (newBudgetEffectiveFrom <= DateTime.Today)
{
throw new ArgumentException("The effective date of the new budget must be a future date.", nameof(newBudgetEffectiveFrom));
}
var validationMessages = new StringBuilder();
if (!sourceBudget.Validate(validationMessages))
{
throw new ValidationWarningException(string.Format(CultureInfo.CurrentCulture, "The source budget is currently in an invalid state, unable to clone it at this time.\n{0}", validationMessages));
}
var newBudget = new BudgetModel
{
EffectiveFrom = newBudgetEffectiveFrom,
Name = string.Format(CultureInfo.CurrentCulture, "Copy of {0}", sourceBudget.Name)
};
newBudget.Update(CloneBudgetIncomes(sourceBudget), CloneBudgetExpenses(sourceBudget));
if (!newBudget.Validate(validationMessages))
{
throw new InvalidOperationException("New cloned budget is invalid but the source budget is ok. Code Error.\n" + validationMessages);
}
Budgets.Add(newBudget);
this.budgetRepository.SaveAsync();
UpdateServiceMonitor();
return(newBudget);
}
/// <summary>
/// Returns a list of budgets belonging to a given user
/// </summary>
/// <param name="UID"></param>
/// <returns></returns>
public List <BudgetModel> GetBudgetsByUID(string UID)
{
List <BudgetModel> budgets = new List <BudgetModel>();
try
{
SqlDataProvider db = new SqlDataProvider();
string query = "SELECT * FROM [dbo].[Budget] as b left join [dbo].[User_Budget] as ub on b.ID = ub.Budget_ID Where ub.UID = '" + UID + "';";
using (SqlConnection connection = (SqlConnection)db.GetConnection())
{
connection.Open();
SqlCommand command = db.CreateCommand(query, connection);
SqlDataReader reader = db.ExecuteReader(command);
while (reader.Read())
{
BudgetModel budget = new BudgetModel()
{
ID = Utilities.ParseInt(reader["ID"].ToString()),
Category_ID = Utilities.ParseInt(reader["Category_ID"].ToString()),
Description = reader["Description"].ToString(),
Account_ID = Utilities.ParseInt(reader["Account_ID"].ToString()),
Amount = Utilities.ParseDecimal(reader["Amount"].ToString()),
Frequency_ID = Utilities.ParseInt(reader["Frequency_ID"].ToString()),
};
budgets.Add(budget);
}
reader.Close();
}
}
catch (Exception ex)
{
throw ex;
}
return(budgets);
}
public IActionResult Budgets(BudgetViewModel model, string Username, string submitButton)//pass in QuizModel as a quizmodel then instantiate it and add it.
{
List <TaxModel> finances = new List <TaxModel>();
BudgetModel newItem = new BudgetModel();
List <BudgetModel> budgetItems = new List <BudgetModel>();
if (submitButton == "Search")
{
if (!String.IsNullOrEmpty(Username))
{
finances = repo.Finances.Where(f => f.User.Name == Username).ToList();
}
newItem.User = new UserModel()
{
Name = Username
};
budgetItems = repo.Budget.ToList <BudgetModel>().Where(b => b.User.Name == Username).ToList();
}
else
{
if (repo.CheckForBudget(model.NewBudgetItem.User.Name))
{
repo.AddBudgetItem(model.NewBudgetItem);
ViewBag.Saved = "This budget record has been added to the database.";
budgetItems = repo.Budget.ToList <BudgetModel>().Where(b => b.User.Name == model.NewBudgetItem.User.Name).ToList();
finances = repo.Finances.Where(f => f.User.Name == model.NewBudgetItem.User.Name).ToList();
}
else
{
ViewBag.Error = "The username you have provided does not have a salary on record.";
}
}
return(View(new BudgetViewModel()
{
Finances = finances, NewBudgetItem = newItem, BudgetItems = budgetItems
}));;
// machine gun all the
// return View(model);
//repo.AddPost(model)^
}
public async Task <bool> EditBudgets(BudgetModel budget)
{
var bug = await _context.PreSalesBudget.FindAsync(budget.Id);
bug.Actual = budget.Actual;
bug.LbHou = budget.LbHou;
bug.LbRate = budget.LbRate;
bug.MtUnit = budget.MtUnit;
bug.MtunitPr = budget.MtunitPr;
bug.Under = budget.Under;
bug.cost = budget.cost;
bug.BudgetCost = budget.BudgetCost;
bug.ProjectsID = budget.ProjectsID;
_context.Entry(bug).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(true);
}
public IHttpActionResult UpdateBudget(BudgetModel budgetModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var budgetDto = Mapper.Map <BudgetDto>(budgetModel);
_budgetAppService.Update(budgetDto, AuthHelper.GetCurrentUserId());
return(Ok("Budget Updated"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void ShouldIndicateFutureBudgetWhenOneIsGiven()
{
var budget3 = new BudgetModel {
EffectiveFrom = new DateTime(2020, 01, 30)
};
var subject = new BudgetCurrencyContext(
new BudgetCollection(
new[]
{
BudgetModelTestData.CreateTestData1(),
BudgetModelTestData.CreateTestData2(),
budget3
}),
budget3
);
Assert.IsFalse(subject.BudgetActive);
Assert.IsFalse(subject.BudgetArchived);
Assert.IsTrue(subject.BudgetInFuture);
}
public TransactionGridRowViewModel(
ObservableCollection <TransactionGridColumnViewModel> columns,
ObservableCollection <TransactionGridColumnViewModel> subTransactionColumns,
Account addToAccount,
BudgetModel model)
{
_model = model;
_columns = columns;
_subTransactionColumns = subTransactionColumns;
_transaction = new Transaction();
_transaction.PropertyChanged += Transaction_PropertyChanged;
_transaction.TransactionDate = DateTime.Today;
_addToAccount = addToAccount;
_isAdding = true;
_isEditing = true;
InitializeSubTransactions();
InitializeCommands();
InitializeCells();
}
/// <summary>
/// A budget model that is effective from 1/1/2013
/// </summary>
public static BudgetModel CreateTestData1()
{
var budget = new BudgetModel
{
EffectiveFrom = new DateTime(2013, 01, 01),
Name = TestDataConstants.Budget1Name
};
var expenses = new List <Expense>(
new[]
{
new Expense
{
Amount = 95M,
Bucket = new SavedUpForExpenseBucket(TestDataConstants.CarMtcBucketCode, "Car maintenance")
},
new Expense
{
Amount = 55M,
Bucket = new SpentMonthlyExpenseBucket(TestDataConstants.HairBucketCode, "Hair cuts")
},
new Expense
{
Amount = 175M,
Bucket = new SpentMonthlyExpenseBucket(TestDataConstants.PowerBucketCode, "Power")
}
});
var incomes = new List <Income>(
new[]
{
new Income
{
Amount = 1500M,
Bucket = new IncomeBudgetBucket(TestDataConstants.IncomeBucketCode, "Pay")
}
});
budget.Update(incomes, expenses);
return(budget);
}
public BurnDownChartAnalyserResult CreateNewCustomAggregateChart(
StatementModel statementModel,
BudgetModel budgetModel,
IEnumerable <BudgetBucket> buckets,
LedgerBook ledgerBookModel,
DateTime beginDate,
string chartTitle)
{
List <BudgetBucket> bucketsList = buckets.ToList();
var result = this.chartAnalyser.Analyse(statementModel, budgetModel, bucketsList, ledgerBookModel, beginDate);
result.ChartTitle = chartTitle;
var persistChart = new CustomAggregateBurnDownGraph
{
BucketIds = bucketsList.Select(b => b.Code).ToList(),
Name = chartTitle
};
this.chartsBuilder.CustomCharts = this.chartsBuilder.CustomCharts.Union(new[] { persistChart }).ToList();
return(result);
}
public ActionResult Save(FirstLaunchModel model)
{
BudgetModel budgetModel = new BudgetModel();
SettingsModel settingModel = new SettingsModel();
SessionManager sessionManager = new SessionManager();
int userid = sessionManager.Get <User>(PageConstant.USER_ID_I_SESSION).Id;
budgetModel = model.Budget;
settingModel = model.Settings;
budgetModel.UserId = settingModel.UserId = userid;
budgetModel.AddBudget(budgetModel);
settingModel.AddSettings(settingModel);
Budget budget = budgetModel.GetCurrentBudget(userid);
sessionManager.Add <Budget>(budget, PageConstant.BUDGET_ID_IN_SESSION);
budgetModel.CurrentBudget = budget.CurrentBudget;
budgetModel.StartBudget = budget.StartBudget;
return(View("MainPanel", budgetModel));
}
public async Task <int> AddNewBudget(BudgetModel model)
{
var newBudget = new PreSalesBudget()
{
Id = model.Id,
Actual = model.Actual,
LbHou = model.LbHou,
LbRate = model.LbRate,
MtUnit = model.MtUnit,
MtunitPr = model.MtunitPr,
Under = model.Under,
cost = model.cost,
BudgetCost = model.BudgetCost,
ProjectsID = model.ProjectsID
};
await _context.PreSalesBudget.AddAsync(newBudget);
await _context.SaveChangesAsync();
return(newBudget.Id);
}
/// <summary>
/// Returns a single budget model belonging to a given user
/// </summary>
/// <param name="UID"></param>
/// <returns></returns>
public BudgetModel GetBudgetByID(long ID)
{
BudgetModel budget = new BudgetModel();
try
{
SqlDataProvider db = new SqlDataProvider();
string query = "SELECT * FROM [dbo].[Budget] B WHERE B.ID = " + ID + ";";
using (SqlConnection connection = (SqlConnection)db.GetConnection())
{
connection.Open();
SqlCommand command = db.CreateCommand(query, connection);
SqlDataReader reader = db.ExecuteReader(command);
while (reader.Read())
{
budget = new BudgetModel()
{
ID = Utilities.ParseInt(reader["ID"].ToString()),
Category_ID = Utilities.ParseInt(reader["Category_ID"].ToString()),
Description = reader["Description"].ToString(),
Account_ID = Utilities.ParseInt(reader["Account_ID"].ToString()),
Amount = Utilities.ParseDecimal(reader["Amount"].ToString()),
Frequency_ID = Utilities.ParseInt(reader["Frequency_ID"].ToString()),
};
}
reader.Close();
}
}
catch (Exception ex)
{
throw ex;
}
return(budget);
}
public static TestBudget CreateBudget(BudgetBackends budgetBackend, Budget initialBudget = null)
{
TestBudget testBudget = null;
if (budgetBackend == BudgetBackends.Memory)
{
testBudget = new TestBudget();
testBudget.DeviceID = Guid.NewGuid();
testBudget.EventStore = new TestEventStore(new MemoryEventStore());
testBudget.BudgetStore = new MemoryBudgetStore(testBudget.EventStore);
}
else if (budgetBackend == BudgetBackends.SQLite)
{
testBudget = new TestBudget();
testBudget.DeviceID = Guid.NewGuid();
SqliteConnectionStringBuilder builder = new SqliteConnectionStringBuilder();
builder.Mode = SqliteOpenMode.Memory;
builder.Cache = SqliteCacheMode.Shared;
builder.DataSource = "BudgetTests";
testBudget.BudgetStore = new SQLiteBudgetStore(testBudget.DeviceID, builder.ToString(), (es) => new TestEventStore(es));
testBudget.EventStore = testBudget.BudgetStore.EventStore as TestEventStore;
}
if (initialBudget == null)
{
initialBudget = InitializeBudget();
}
testBudget.BudgetModel = BudgetModel.CreateNew(testBudget.DeviceID, testBudget.BudgetStore, initialBudget);
testBudget.BudgetModel.SaveChanges();
testBudget.EventStore.TestEvents.Clear();
testBudget.TestEvents = testBudget.EventStore.TestEvents;
testBudget.Budget = initialBudget;
return(testBudget);
}
public ReconciliationResult CreateNewMonthlyReconciliation(
DateTime reconciliationDateExclusive,
BudgetModel budget,
StatementModel statement,
params BankBalance[] bankBalances)
{
if (bankBalances == null)
{
throw new ArgumentNullException(nameof(bankBalances));
}
if (budget == null)
{
throw new ArgumentNullException(nameof(budget));
}
if (statement == null)
{
throw new ArgumentNullException(nameof(statement));
}
if (LedgerBook == null)
{
throw new ArgumentException("The Ledger Book property cannot be null. You must set this prior to calling this method.");
}
try
{
this.newReconciliationLine = new LedgerEntryLine(reconciliationDateExclusive, bankBalances);
AddNew(budget, statement, CalculateDateForReconcile(LedgerBook, reconciliationDateExclusive));
return(new ReconciliationResult {
Reconciliation = this.newReconciliationLine, Tasks = this.toDoList
});
}
finally
{
this.newReconciliationLine = null;
}
}
public IHttpActionResult PostBudget(BudgetModel budgetModel)
{
if (!ModelState.IsValid)
{
return(NotFound());
}
List <Bill> bills = new List <Bill>();
foreach (var billModel in budgetModel.Bills)
{
var bill = new Bill()
{
AmountPaid = billModel.AmountPaid,
BillId = billModel.BillId,
BillStatus = billModel.BillStatus,
CustomBillId = billModel.CustomBillId,
PaymentTypeId = billModel.PaymentTypeId,
PaymentDate = billModel.PaymentDate
};
bills.Add(bill);
}
var budget = new Budget()
{
BudgetId = budgetModel.BudgetId,
UserId = budgetModel.UserId,
DateReceived = budgetModel.DateReceived,
ReceivedAmount = budgetModel.ReceivedAmount,
Bills = bills
};
db.Budgets.Add(budget);
db.SaveChanges();
var budgetData = GetBudget(budget.UserId);
return(Ok(budgetData));
}
public void TestInitialise()
{
this.subject = new BudgetBucketMonitorWidget();
this.subject.BucketCode = StatementModelTestData.PhoneBucket.Code;
this.bucketRepo = new BucketBucketRepoAlwaysFind();
this.criteriaTestData = new GlobalFilterCriteria
{
BeginDate = new DateTime(2015, 10, 20),
EndDate = new DateTime(2015, 11, 19)
};
CreateStatementTestData();
BudgetModel budgetModel = BudgetModelTestData.CreateTestData5();
this.budgetTestData = new BudgetCurrencyContext(new BudgetCollection(budgetModel), budgetModel);
CreateLedgerBookTestData();
this.ledgerCalculation = new LedgerCalculation(new FakeLogger());
}
private void OpenBudget()
{
var budgetPath = _budgetLoader.GetBudgetOpenPath();
if (budgetPath == null)
{
return;
}
ValidBudgetCheck validBudgetCheck = _budgetLoader.IsBudgetValid(budgetPath);
if (!validBudgetCheck.IsValid)
{
_dialogService.ShowError(validBudgetCheck.Error);
return;
}
try
{
BudgetModel budgetModel = _budgetLoader.LoadBudget(budgetPath);
Budget budget = budgetModel.GetBudget();
BudgetStub stub = new BudgetStub()
{
BudgetName = budget.Name, BudgetPath = budgetPath, LastEdited = DateTime.Now
};
var deviceSettings = _settingsProvider.Get <Device>();
deviceSettings.AddRecentBudgetToTop(stub);
deviceSettings.Save();
_mainViewModel.MountBudget(budgetModel);
_navigationService.NavigateTo <MainBudgetViewModel>();
}
catch (Exception)
{
_dialogService.ShowError($"There was an error opening the budget {budgetPath}. It may be corrupt.");
}
}
public void Submit()
{
var endTime = DateTime.Now;
var startTime = DateTime.Parse(StartDateInput.text);
var repeatType = (ERepeatType)RepeatDropDown.value;
if (repeatType != ERepeatType.Once)
{
endTime = startTime.Add(TimeSpan.FromDays(BudgetModel.RepeatDaysLookUp[repeatType]));
}
var budget = new BudgetModel
{
Name = NameInput.text,
Amount = float.Parse(BudgetInput.text),
StartTime = startTime,
Repeat = repeatType,
EndTime = endTime,
};
_accountController.Add(budget);
StateMachine.Back();
}
public TransactionGridViewModel(BudgetModel model, string accountId)
{
_model = model;
_account = _model.FindEntity <Account>(accountId);
if (_account == null)
{
throw new ArgumentException("Cannot find Account in BudgetModel", nameof(accountId));
}
//Load collections for use in Payee/Category lookup
_budget = _account.GetParentBudget();
_budget.Accounts.LoadCollection();
_budget.MasterCategories.LoadCollection();
_budget.Payees.LoadCollection();
InitializeCommands();
_selectedRows = new ObservableCollection <TransactionGridRowViewModel>();
_selectedRows.CollectionChanged += SelectedRows_CollectionChanged;
InitializeColumns();
InitializeGrid(_account);
}
public void getByIDTest()
{
int id = 20;
Event expected = new Event();
expected.Id = id;
expected.Budget = BudgetModel.getByID(37);
expected.Capacity = 50;
expected.Description = "asdasd";
expected.End = new DateTime(2012, 4, 4, 2, 33, 3);
expected.Start = new DateTime(2012, 4, 4, 2, 33, 3);
expected.Guests.Add(StudentModel.getByMatricId("test2"));
expected.Name = "Hello World";
expected.Owner = StudentModel.getByMatricId("test");
expected.StudentMatricId = "test";
expected.SubEvents = SubEventModel.getAllByEventID(20);
expected.TimeCreated = new DateTime(2012, 4, 4, 2, 33, 3);
expected.ViewAtLoginPage = 1;
Event actual = EventModel.getByID(id);
Assert.IsTrue(PropertiesEqual(actual, expected));
}
/// <summary>
/// Calculates the appropriate budgeted amount for the given buckets.
/// This can either be the ledger balance from the ledger book or if not tracked by the ledger book, then from the
/// budget model.
/// </summary>
private decimal GetBudgetedTotal(
[NotNull] BudgetModel budgetModel,
[CanBeNull] LedgerBook ledgerBook,
[NotNull] IEnumerable <BudgetBucket> buckets,
DateTime beginDate)
{
decimal budgetTotal = 0;
List <BudgetBucket> bucketsCopy = buckets.ToList();
var applicableLine = this.ledgerCalculator.LocateApplicableLedgerLine(ledgerBook, beginDate);
if (applicableLine == null)
{
// Use budget values from budget model instead, there is no ledger book line for this month.
budgetTotal += bucketsCopy.Sum(bucket => GetBudgetModelTotalForBucket(budgetModel, bucket));
}
else
{
budgetTotal += bucketsCopy.Sum(bucket => GetLedgerBalanceForBucket(budgetModel, applicableLine, bucket));
}
return(budgetTotal);
}
public EntityBase ResolveEntityGeneric(BudgetModel budgetModel, EntityReference entityReference)
{
if (_loadedEntities.TryGetValue(entityReference, out EntityBase entity))
{
return(entity);
}
else
{
if (entityReference.IsReferenceResolved(budgetModel))
{
EntityBase referencedEntity = entityReference.ReferencedEntity;
_loadedEntities.Add(entityReference, referencedEntity);
return(referencedEntity);
}
else
{
EntityBase referencedEntity = entityReference.ResolveGeneric(budgetModel);
_loadedEntities.Add(entityReference, referencedEntity);
referencedEntity.LookupRoot = this;
return(referencedEntity);
}
}
}
public ActionResult Index(BudgetModel BudgetTryingToAdd = null)
{
ViewBag.IsNotDashboard = true;
BudgetAdapter budgetAdapter = new BudgetAdapter();
FrequencyAdapter frequencyAdapter = new FrequencyAdapter();
AccountTypeAdapter accountTypeAdapter = new AccountTypeAdapter();
BudgetModelList pageData = new BudgetModelList
{
Budgets = budgetAdapter.GetBudgetsByUID(Utilities.GetUsersUID(User.Identity.Name)),
Categories = budgetAdapter.GetUniqueCategoryByUID(Utilities.GetUsersUID(User.Identity.Name)),
Frequencies = frequencyAdapter.GetAllFrequencies(),
AccountTypes = accountTypeAdapter.GetAccountTypesByUID(Utilities.GetUsersUID(User.Identity.Name))
};
if (BudgetTryingToAdd != null)
{
pageData.NewBudget = BudgetTryingToAdd;
}
return(View(pageData));
}
public Results Create(BudgetModel model)
{
using (var connection = GetConnection())
{
try
{
connection.Open();
connection.Insert(new
{
Id = model.Id,
TypeId = model.TypeId,
Money = model.Money,
Year = model.Year,
Month = model.Month,
CreateBy = model.CreateBy
}, OPIM_Common.TableName.Budget);
return(new Results());
}
catch (Exception ex)
{
return(new Results(ex.Message));
}
}
}
