public DataTable GetExpenses(string pos, string id)
{
ExpenseRepository dataAccess = new ExpenseRepository();
DataTable datatable = dataAccess.GetExpenses(pos, id);
return(datatable);
}
public void FillCurrency()
{
var repo = new ExpenseRepository();
var List = repo.FillCurrency();
ViewBag.Currency = new SelectList(List, "Id", "Name");
}
public ActionResult Delete(int Id)
{
ViewBag.Title = "Delete";
var result1 = new ExpenseRepository().CHECK(Id);
if (result1 > 0)
{
TempData["error"] = "Sorry!!..Already Used!!";
TempData["SupplyOrderNo"] = null;
return(RedirectToAction("Edit", new { id = Id }));
}
else
{
var result2 = new ExpenseRepository().DeleteExpenseBillDT(Id);
var result3 = new ExpenseRepository().DeleteExpenseBillHD(Id);
if (Id > 0)
{
TempData["Success"] = "Deleted Successfully!";
//return RedirectToAction("PreviousList");
return(RedirectToAction("Create"));
}
else
{
TempData["error"] = "Oops!!..Something Went Wrong!!";
TempData["SupplyOrderNo"] = null;
return(RedirectToAction("Edit", new { id = Id }));
}
}
}
public Expense GetExpenseById(int expenseId)
{
ExpenseRepository dataAccess = new ExpenseRepository();
Expense datatable = dataAccess.GetExpenseById(expenseId);
return(datatable);
}
private BudgetSummaryModel AddBudgetSummaryModelSettings(BudgetSummaryModel model, long accountId, bool sharedAccount)
{
var categories = CategoryHelper.GetCategories();
var expenses = ExpenseRepository.GetAccountExpenses(accountId);
var settings = SettingsHelper.GetCategorySettings(accountId);
foreach (var setting in settings.Settings)
{
if (!setting.Data.IsActive)
{
continue;
}
if (setting.Data.Unlimited)
{
continue;
}
if (setting.Data.Amount <= 0)
{
continue;
}
model.AddCategoryTable(setting.Data.Duration, categories.Single(c => c.CategoryId == long.Parse(setting.ContextValue)), setting.Data.Amount, expenses, sharedAccount);
}
return(model);
}
public void GetAllExpensesForApproval()
{
var expected = new Model.Expense
{
Id = Guid.NewGuid(),
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = true,
User = new User {
UserName = "******"
},
ApproverName = "approverName"
};
var anotherExpense = new Model.Expense
{
Id = Guid.NewGuid(),
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = true,
User = new User {
UserName = "******"
},
ApproverName = "approverName"
};
var notForMeExpense = new Model.Expense
{
Id = Guid.NewGuid(),
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = true,
User = new User {
UserName = "******"
},
ApproverName = "Another approverName"
};
util.DatabaseHelper.CreateExpense(TestDatabaseConnectionString, expected);
util.DatabaseHelper.CreateExpense(TestDatabaseConnectionString, anotherExpense);
util.DatabaseHelper.CreateExpense(TestDatabaseConnectionString, notForMeExpense);
var repository = new ExpenseRepository(TestDatabaseConnectionString);
var expenses = repository.GetExpensesForApproval("approverName");
Assert.IsNotNull(expenses);
Assert.AreEqual(2, expenses.Count());
}
public void FillJC()
{
ExpenseRepository repo = new ExpenseRepository();
List <Dropdown> list = new DropdownRepository().JobCardDropdown(OrganizationId);
ViewBag.JC = new SelectList(list, "Id", "Name");
}
public ExpenseViewModel()
{
expenseRep = new ExpenseRepository();
catRep = new CategoryRepository();
CategoryList = new ObservableCollection <Category>();
var iList = catRep.GetCategoriesAsync();
foreach (Category i in iList.Result)
{
CategoryList.Add(i);
}
SaveExpenseCommand = new Command(async() =>
{
var expense = new Expense();
TheDate += TheTime;
expense.Description = TheDescription;
expense.Value = Convert.ToDouble(TheValue);
expense.Date = TheDate;
expense.CategoryId = CategoryId + 1;
await expenseRep.SaveExpenseAsync(expense);
TheDescription = string.Empty;
TheValue = "0";
CategoryId = -1;
});
}
public void CanGetExpenseForApprovalFromCache()
{
Guid expenseIdToSave = Guid.NewGuid();
Assert.IsNull(util.DatabaseHelper.GetExpenseById(TestDatabaseConnectionString, expenseIdToSave));
var stubUser = new User { UserName = "******" };
var stubManager = "the manager";
var expenseToSave = new Model.Expense
{
Id = expenseIdToSave,
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = false,
User = stubUser,
ApproverName = stubManager
};
var repository = new ExpenseRepository(TestDatabaseConnectionString, TimeSpan.MaxValue);
repository.SaveExpense(expenseToSave);
var expToApprove = repository.GetExpensesForApproval(stubManager);
DatabaseHelper.BypassRepositoryAndDeleteExpense(TestDatabaseConnectionString, expenseToSave.Id);
expToApprove = repository.GetExpensesForApproval(stubManager);
Assert.AreEqual(1, expToApprove.Count());
Assert.AreEqual(expenseIdToSave, expToApprove.First().Id);
}
public void ShouldGetZeroExpensesFromNonExistingUser()
{
var expected = new AExpense.Model.Expense
{
Id = Guid.NewGuid(),
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = true,
User = new User {
UserName = "******"
},
ApproverName = "approver name"
};
var repository = new ExpenseRepository(dataContext);
repository.SaveExpense(expected);
var expenses = repository.GetExpensesByUser("no existing user name");
Assert.AreEqual(0, expenses.Count());
}
public async Task AddExpense(string name)
{
try
{
await ThreadPool.RunAsync((workItem) =>
{
try
{
var expense = ExpenseRepository.Factory(name);
var vm = new ExpenseViewModel(expense);
Vehicle.Expenses.Add(expense);
Expenses.Add(vm);
SelectedExpense = vm;
}
catch (Exception ex)
{
App.Telemetry.TrackException(ex);
SelectedExpense = null;
}
finally
{
Vehicle.Expenses.OrderBy(x => x.Name);
Expenses.OrderBy(x => x.Expense.Name);
}
});
}
catch (Exception ex)
{
App.Telemetry.TrackException(ex);
}
}
public void GetAllExpensesForApprovalLogsActivity()
{
using (var subscription = obsListener.LogToSqlDatabase("Activity", TracingDatabaseConnectionString))
{
var repository = new ExpenseRepository(TestDatabaseConnectionString, TimeSpan.MinValue);
repository.GetExpensesForApproval("ApproverUser");
subscription.Sink.FlushAsync().Wait();
var logEntries = DatabaseHelper.GetAllLogEntries(TracingDatabaseConnectionString);
Assert.AreEqual(6, logEntries.Count());
var GetExpensesForApprovalStartedEntry = logEntries.SingleOrDefault(e => e.EventId == 320);
Assert.IsNotNull(GetExpensesForApprovalStartedEntry);
StringAssert.Contains(GetExpensesForApprovalStartedEntry.Payload, "ApproverUser");
var GetExpensesForApprovalQueryStartedEntry = logEntries.SingleOrDefault(e => e.EventId == 327);
Assert.IsNotNull(GetExpensesForApprovalQueryStartedEntry);
StringAssert.Contains(GetExpensesForApprovalQueryStartedEntry.Payload, "ApproverUser");
var GetExpensesForApprovalQueryFinishedEntry = logEntries.SingleOrDefault(e => e.EventId == 324);
Assert.IsNotNull(GetExpensesForApprovalQueryFinishedEntry);
StringAssert.Contains(GetExpensesForApprovalQueryFinishedEntry.Payload, "ApproverUser");
var GetExpensesForApprovalCacheUpdateEntry = logEntries.SingleOrDefault(e => e.EventId == 326);
Assert.IsNotNull(GetExpensesForApprovalCacheUpdateEntry);
StringAssert.Contains(GetExpensesForApprovalCacheUpdateEntry.Payload, "ApproverUser");
var GetExpensesForApprovalFinishedEntry = logEntries.SingleOrDefault(e => e.EventId == 321);
Assert.IsNotNull(GetExpensesForApprovalFinishedEntry);
StringAssert.Contains(GetExpensesForApprovalFinishedEntry.Payload, "ApproverUser");
}
}
public void CanInterceptAndTraceWithValidApprover()
{
var newExpense = new Model.Expense();
newExpense.Id = testGuid;
newExpense.Title = "testing title";
newExpense.CostCenter = "testing cost center";
newExpense.ReimbursementMethod = ReimbursementMethod.DirectDeposit;
newExpense.User = new Model.User()
{
FullName = "test user", UserName = "******"
};
newExpense.Date = System.DateTime.Today;
newExpense.ApproverName = "ADATUM\\mary";
newExpense.Details.Add(new Model.ExpenseItem()
{
Description = "test item", Amount = 10, Id = Guid.NewGuid()
});
var repository = new ExpenseRepository(TestDatabaseConnectionString);
repository.SaveExpense(newExpense);
var events = listener.EventsWritten;
Assert.IsNotNull(events);
Assert.AreEqual(6, events.Count);
}
public void ApproveExpense()
{
var expected = new Model.Expense
{
Id = Guid.NewGuid(),
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = false,
User = new User {
UserName = "******"
},
ApproverName = "approver name"
};
util.DatabaseHelper.CreateExpense(TestDatabaseConnectionString, expected);
var repository = new ExpenseRepository(TestDatabaseConnectionString);
Thread.CurrentPrincipal = new ClaimsPrincipal(new ClaimsIdentity(Thread.CurrentPrincipal.Identity, new Claim[] { new Claim(ClaimTypes.Role, "Manager") }));
repository.UpdateApproved(expected);
var actual = util.DatabaseHelper.GetExpenseById(TestDatabaseConnectionString, expected.Id);
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Approved, actual.Approved);
}
private void SaveExpense()
{
// TODO: add check for CSRF attacks (set ViewStateUserKey = Session.SessionID)
var user = (User)this.Session["LoggedUser"];
var newExpense = new Expense
{
Id = Guid.NewGuid(),
Title = this.ExpenseTitle.Text,
Description = this.ExpenseDescription.Text,
CostCenter = user.CostCenter,
Amount = Convert.ToDecimal(this.ExpenseAmount.Text, CultureInfo.CurrentUICulture),
Approved = false,
ReimbursementMethod = (ReimbursementMethod)Enum.Parse(typeof(ReimbursementMethod), this.ExpenseReimbursementMethod.SelectedItem.Value),
User = user,
Date = DateTime.Parse(this.ExpenseDate.Text, CultureInfo.CurrentUICulture)
};
var expenseRepository = new ExpenseRepository();
expenseRepository.SaveExpense(newExpense);
user.PreferredReimbursementMethod = (ReimbursementMethod)Enum.Parse(typeof(ReimbursementMethod), this.ExpenseReimbursementMethod.SelectedValue);
var userRepository = new UserRepository();
userRepository.UpdateUserPreferredReimbursementMethod(user);
}
public void FillSI()
{
ExpenseRepository repo = new ExpenseRepository();
List <Dropdown> list = repo.FillSI();
ViewBag.SI = new SelectList(list, "Id", "Name");
}
public DataSet GetStatus()
{
ExpenseRepository dataAccess = new ExpenseRepository();
DataSet dataSet = dataAccess.GetStatus();
return(dataSet);
}
private void SaveExpense()
{
var userRepository = new UserRepository();
var user = userRepository.GetUser(this.User.Identity.Name);
var approverName = this.Approver.Text;
if (string.IsNullOrEmpty(approverName))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "The approver {0} does not exists", this.Approver.Text));
}
var newExpense = new Expense
{
Id = StorageKey.Now.InvertedTicks,
Title = this.ExpenseTitle.Text,
CostCenter = user.CostCenter,
Approved = false,
ReimbursementMethod = (ReimbursementMethod)Enum.Parse(typeof(ReimbursementMethod), this.ExpenseReimbursementMethod.SelectedItem.Value),
UserName = user.UserName,
Date = DateTime.Parse(this.ExpenseDate.Text, CultureInfo.CurrentUICulture),
ApproverName = approverName
};
this.ExpenseItems.ForEach(ei => newExpense.Details.Add(ei));
var expenseRepository = new ExpenseRepository();
expenseRepository.SaveExpense(newExpense);
user.PreferredReimbursementMethod = (ReimbursementMethod)Enum.Parse(typeof(ReimbursementMethod), this.ExpenseReimbursementMethod.SelectedValue);
userRepository.UpdateUserPreferredReimbursementMethod(user);
}
public BudgetController(BudgetRepository budgetRepo, ExpenseRepository expenseRepo, BudgetConceptRepository conceptRepo, ExpenseGroupRepository groupRepo)
{
this.budgetRepo = budgetRepo;
this.expenseRepo = expenseRepo;
this.conceptRepo = conceptRepo;
this.groupRepo = groupRepo;
}
public void EnterExpense()
{
var db = new InMemoryDB();
var personRepository = new PersonRepository(db);
var expenseRepository = new ExpenseRepository(db);
var tripRepository = new TripRepository(db);
var personService = new PersonService(personRepository);
var expenseTracking = new ExpenseTracking(personRepository,
tripRepository,
expenseRepository
);
var expenseService = new ExpenseService(expenseRepository);
expenseService.CreateExpense("Lunch", "Lunch");
var Personlist = personService.CreatePerson(new string[] { "Suresh", "Sakthivel", "Saravanan" });
var trip = expenseTracking.CreateTrip("trip1", Personlist.Select(p => p.ID));
expenseTracking.EnterExpense(trip.TripID, 1, new int[] { 2, 3 }, "Lunch", 100);
var payer = Personlist.Where(p => p.ID == 1).FirstOrDefault();
var payee = Personlist.Where(p => p.ID != 1).FirstOrDefault();
Assert.AreEqual(100, payer.AmountToGet());
Assert.AreEqual(50, payee.AmountToGive());
}
public void ApproveExpense()
{
var expected = new AExpense.Model.Expense
{
Id = Guid.NewGuid(),
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = false,
User = new User {
UserName = "******"
},
ApproverName = "approver name"
};
var repository = new ExpenseRepository(dataContext);
repository.SaveExpense(expected);
Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity("test"), new string[] { "Manager" });
repository.UpdateApproved(expected);
var actual = repository.GetExpenseById(expected.Id);
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Approved, actual.Approved);
}
private decimal GetOweAmount(long accountId, long sharedAccountId, DateTime month)
{
var expenses = ExpenseRepository.GetAccountExpenses(sharedAccountId);
expenses = expenses.Where(e => e.SpentDate.Year == month.Year && e.SpentDate.Month == month.Month).ToList();
var transfers = SharedAccountRepository.GetSharedAccountMoneyTransfer(sharedAccountId);
transfers = transfers.Where(t => t.ForYear == month.Year && t.ForMonth == month.Month).ToList();
var yourIncomeTotal = IncomeRepository.GetAccountIncome(accountId).Where(i => i.IncomeDate.Year == month.Year && i.IncomeDate.Month == month.Month).Sum(i => i.Amount);
var partnerIncomeTotal = IncomeRepository.GetPartnerIncome(accountId).Where(i => i.IncomeDate.Year == month.Year && i.IncomeDate.Month == month.Month).Sum(i => i.Amount);
var yourPercentage = yourIncomeTotal + partnerIncomeTotal == 0 ? 0 : yourIncomeTotal / (yourIncomeTotal + partnerIncomeTotal);
var sharedSpentTotal = expenses.Sum(e => e.Amount);
var yourSharedSpentTotal = expenses.Where(e => e.SpentAccountId == accountId).Sum(e => e.Amount);
var yourIdealSpentTotal = yourPercentage * sharedSpentTotal;
var youPayed = transfers.Where(t => t.PayerAccountId == accountId).Sum(t => t.Amount);
var youRecieved = transfers.Where(t => t.PayedAccountId == accountId).Sum(t => t.Amount);
var finalAmount = Math.Round(yourIdealSpentTotal - yourSharedSpentTotal, 2);
finalAmount = finalAmount - youPayed + youRecieved;
return(finalAmount);
}
public InputCategoryWindow(MainWindow _mainWindow, ExpensePage _expensePage, DateTime _date)
{
InitializeComponent();
dbContext = new MonnyDbContext();
controller = _mainWindow;
expensePage = _expensePage;
date = _date;
// Set ComboBox list Item with user's custom categories
ExpenseRepository repository = new ExpenseRepository();
// List where used custom categories ids are being saved
List <int> usedId = new List <int>();
foreach (Expense e in repository.GetItems())
{
// Checks if e is current user expense
// e.CategoryId > 7 because custom categories have id greater than 7
if (e.UserId == controller.user.Id && e.CategoryId > 7)
{
// Check if category hasn't been used already
if (!usedId.Exists(i => i == e.CategoryId))
{
CategoryRepository categories = new CategoryRepository();
// Add category to ComboBox Items
customCategories.Items.Add(categories.GetItem(e.CategoryId).Name);
usedId.Add(e.CategoryId);
}
}
}
}
public void CanDeliverASingleExpeseRecord(string recordId)
{
var subject = new ExpenseRepository();
subject
.FindById(Guid.Parse(recordId))
.Should().NotBeNull();
}
public async Task DetailAsyncTest()
{
var repository = new ExpenseRepository(GetContext());
var expense = await repository.DetailAsync(1);
Assert.Equal("Alice", expense.Recipient);
}
public ActionResult EditExpense(int id)
{
var expenseRepository = new ExpenseRepository();
var expenseItem = expenseRepository.FindExpense(id);
var viewModel = new ExpenseManagingViewModel(expenseItem);
return(View(viewModel));
}
public ActionResult DeleteExpense(string id)
{
var expenseRepository = new ExpenseRepository();
expenseRepository.DeleteExpense(Convert.ToInt32(id));
return(RedirectToAction("ExpenseManager"));
}
public ActionResult ExpenseManager()
{
ViewData["Message"] = "Your expense manager page.";
var expenseRepository = new ExpenseRepository();
var expenses = expenseRepository.GetExpenses();
return(View(expenses));
}
/// <summary>
/// Get Expenses
/// </summary>
/// <returns></returns>
// GET: api/Expense
public IHttpActionResult Get(string filter)
{
ExpenseRepository ExpenseRepository = new ExpenseRepository(Convert.ToInt32(Request.Headers.GetValues("CurrentUserID").First()));
List <Expense> ExpenseList = ExpenseRepository.GetExpensesByFilter(filter);
return(Json(new { Expenses = ExpenseList }));
}
public void DoesNotFailIfRecordDoesNotExist()
{
var subject = new ExpenseRepository();
subject
.Invoking(x => x.FindById(Guid.Parse("00000000-0000-0000-0000-000000000000")))
.ShouldNotThrow();
}
/// <summary>
/// Save Expenses
/// </summary>
/// <param name="ExpenseList"></param>
/// <returns></returns>
// POST: api/Expense
public IHttpActionResult Post([FromBody] List <Expense> ExpenseList, string filter)
{
ExpenseRepository ExpenseRepository = new ExpenseRepository(Convert.ToInt32(Request.Headers.GetValues("CurrentUserID").First()));
ExpenseRepository.SaveExpenses(ExpenseList, filter);
return(Json(new { count = ExpenseList.Count.ToString() }));
}
public void GetAllExpensesLogsActivity()
{
using (var subscription = obsListener.LogToSqlDatabase("Activity", TracingDatabaseConnectionString))
{
var repository = new ExpenseRepository(TestDatabaseConnectionString, TimeSpan.MinValue);
repository.GetAllExpenses();
subscription.Sink.FlushAsync().Wait();
var logEntries = DatabaseHelper.GetAllLogEntries(TracingDatabaseConnectionString);
Assert.AreEqual(3, logEntries.Count());
var GetAllExpensesStartedEntry = logEntries.SingleOrDefault(e => e.EventId == 300);
Assert.IsNotNull(GetAllExpensesStartedEntry);
var GetAllExpensesFinishedEntry = logEntries.SingleOrDefault(e => e.EventId == 301);
Assert.IsNotNull(GetAllExpensesFinishedEntry);
}
}
public void CanInterceptAndTraceWithValidApprover()
{
var newExpense = new Model.Expense();
newExpense.Id = testGuid;
newExpense.Title = "testing title";
newExpense.CostCenter = "testing cost center";
newExpense.ReimbursementMethod = ReimbursementMethod.DirectDeposit;
newExpense.User = new Model.User() { FullName = "test user", UserName = "******" };
newExpense.Date = System.DateTime.Today;
newExpense.ApproverName = "ADATUM\\mary";
newExpense.Details.Add(new Model.ExpenseItem() { Description = "test item", Amount = 10, Id = Guid.NewGuid() });
var repository = new ExpenseRepository(TestDatabaseConnectionString);
repository.SaveExpense(newExpense);
var events = listener.EventsWritten;
Assert.IsNotNull(events);
Assert.AreEqual(6, events.Count);
}
public void SaveExpense()
{
Guid expenseIdToSave = Guid.Empty;
var stubUser = new User { UserName = "******" };
var stubManager = "the manager";
var expenseToSave = new AExpense.Model.Expense
{
Id = expenseIdToSave,
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = true,
User = stubUser,
ApproverName = stubManager
};
var repository = new ExpenseRepository(dataContext);
repository.SaveExpense(expenseToSave);
var expenseEntity = repository.GetExpenseById(expenseIdToSave);
Assert.IsNotNull(expenseEntity);
Assert.AreEqual(expenseToSave.Approved, expenseEntity.Approved);
Assert.AreEqual(expenseToSave.CostCenter, expenseEntity.CostCenter);
Assert.AreEqual(expenseToSave.Date, expenseEntity.Date);
Assert.AreEqual(expenseToSave.Description, expenseEntity.Description);
Assert.AreEqual(expenseToSave.Id, expenseEntity.Id);
Assert.AreEqual(expenseToSave.ReimbursementMethod, expenseEntity.ReimbursementMethod);
Assert.AreEqual(expenseToSave.Title, expenseEntity.Title);
Assert.AreEqual(expenseToSave.User.UserName, expenseEntity.User.UserName);
Assert.AreEqual(expenseToSave.ApproverName, expenseEntity.ApproverName);
}
public void SaveExpense()
{
Guid expenseIdToSave = Guid.Empty;
Assert.IsNull(util.DatabaseHelper.GetExpenseById(TestDatabaseConnectionString, expenseIdToSave));
var stubUser = new User { UserName = "******" };
var stubManager = "the manager";
var expenseToSave = new Model.Expense
{
Id = expenseIdToSave,
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = true,
User = stubUser,
ApproverName = stubManager
};
var repository = new ExpenseRepository(TestDatabaseConnectionString);
repository.SaveExpense(expenseToSave);
var expenseEntity = util.DatabaseHelper.GetExpenseById(TestDatabaseConnectionString, expenseIdToSave);
Assert.IsNotNull(expenseEntity);
Assert.AreEqual(expenseToSave.Total, Convert.ToDouble(expenseEntity.Amount));
Assert.AreEqual(expenseToSave.Approved, expenseEntity.Approved);
Assert.AreEqual(expenseToSave.CostCenter, expenseEntity.CostCenter);
Assert.AreEqual(expenseToSave.Date, expenseEntity.Date);
Assert.AreEqual(expenseToSave.Description, expenseEntity.Description);
Assert.AreEqual(expenseToSave.Id, expenseEntity.Id);
Assert.AreEqual(expenseToSave.ReimbursementMethod, Enum.Parse(typeof(ReimbursementMethod), expenseEntity.ReimbursementMethod));
Assert.AreEqual(expenseToSave.Title, expenseEntity.Title);
Assert.AreEqual(expenseToSave.User.UserName, expenseEntity.UserName);
Assert.AreEqual(expenseToSave.ApproverName, expenseEntity.Approver);
}
public void GetAllExpensesForApproval()
{
var expected = new AExpense.Model.Expense
{
Id = Guid.NewGuid(),
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = true,
User = new User { UserName = "******" },
ApproverName = "approverName"
};
var anotherExpense = new AExpense.Model.Expense
{
Id = Guid.NewGuid(),
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = true,
User = new User { UserName = "******" },
ApproverName = "approverName"
};
var notForMeExpense = new AExpense.Model.Expense
{
Id = Guid.NewGuid(),
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = true,
User = new User { UserName = "******" },
ApproverName = "Another approverName"
};
var repository = new ExpenseRepository(dataContext);
repository.SaveExpense(expected);
repository.SaveExpense(anotherExpense);
repository.SaveExpense(notForMeExpense);
var expenses = repository.GetExpensesForApproval("approverName");
Assert.IsNotNull(expenses);
Assert.AreEqual(2, expenses.Count());
}
public void ApproveExpense()
{
var expected = new Model.Expense
{
Id = Guid.NewGuid(),
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = false,
User = new User { UserName = "******" },
ApproverName = "approver name"
};
util.DatabaseHelper.CreateExpense(TestDatabaseConnectionString, expected);
var repository = new ExpenseRepository(TestDatabaseConnectionString);
Thread.CurrentPrincipal = new ClaimsPrincipal(new ClaimsIdentity(Thread.CurrentPrincipal.Identity, new Claim[] { new Claim(ClaimTypes.Role, "Manager") }));
repository.UpdateApproved(expected);
var actual = util.DatabaseHelper.GetExpenseById(TestDatabaseConnectionString, expected.Id);
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Approved, actual.Approved);
}
public void ShouldGetZeroExpensesFromNonExistingUser()
{
var expected = new AExpense.Model.Expense
{
Id = Guid.NewGuid(),
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = true,
User = new User { UserName = "******" },
ApproverName = "approver name"
};
var repository = new ExpenseRepository(dataContext);
repository.SaveExpense(expected);
var expenses = repository.GetExpensesByUser("no existing user name");
Assert.AreEqual(0, expenses.Count());
}
public void UpdatingAnExpenseUpdatesTheCache()
{
//Creation of expense
Guid expenseIdToSave = Guid.NewGuid();
Assert.IsNull(util.DatabaseHelper.GetExpenseById(TestDatabaseConnectionString, expenseIdToSave));
var stubUser = new User { UserName = "******" };
var stubManager = "the manager";
var expenseToSave = new Model.Expense
{
Id = expenseIdToSave,
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = false,
User = stubUser,
ApproverName = stubManager
};
//Get the repository with the highest cache expiration
var repository = new ExpenseRepository(TestDatabaseConnectionString, TimeSpan.MaxValue);
//Save expense
repository.SaveExpense(expenseToSave);
//Get expense (it also caches the expense)
var savedExpense = repository.GetExpenseById(expenseIdToSave);
//basic Assertion
Assert.IsNotNull(savedExpense);
//Approve the expense
savedExpense.Approved = true;
Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity("test"), new string[] { "Manager" });
repository.UpdateApproved(savedExpense);
//Delete expense in db so we make sure we will get expense from cache.
DatabaseHelper.BypassRepositoryAndDeleteExpense(TestDatabaseConnectionString, savedExpense.Id);
//Get expense (from cache) and verify new description
var cachedExpense = repository.GetExpenseById(expenseIdToSave);
//Assert
Assert.IsNotNull(cachedExpense);
Assert.IsTrue(cachedExpense.Approved);
}
public void GetExpenseByIdIsGoneAfterCacheExpires()
{
Guid expenseIdToSave = Guid.NewGuid();
Assert.IsNull(util.DatabaseHelper.GetExpenseById(TestDatabaseConnectionString, expenseIdToSave));
var stubUser = new User { UserName = "******" };
var stubManager = "the manager";
var expenseToSave = new Model.Expense
{
Id = expenseIdToSave,
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = true,
User = stubUser,
ApproverName = stubManager
};
var repository = new ExpenseRepository(TestDatabaseConnectionString, new TimeSpan(0, 0, 2));
repository.SaveExpense(expenseToSave);
var expense = repository.GetExpenseById(expenseToSave.Id);
DatabaseHelper.BypassRepositoryAndDeleteExpense(TestDatabaseConnectionString, expenseToSave.Id);
Thread.Sleep(3000);
expense = repository.GetExpenseById(expenseToSave.Id);
Assert.IsNull(expense);
}
public void ApproveExpense()
{
var expected = new AExpense.Model.Expense
{
Id = Guid.NewGuid(),
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = false,
User = new User { UserName = "******" },
ApproverName = "approver name"
};
var repository = new ExpenseRepository(dataContext);
repository.SaveExpense(expected);
Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity("test"), new string[] { "Manager" });
repository.UpdateApproved(expected);
var actual = repository.GetExpenseById(expected.Id);
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Approved, actual.Approved);
}
public void AddExpenseLogsActivity()
{
using(var subscription = obsListener.LogToSqlDatabase("Activity", TracingDatabaseConnectionString))
{
var repository = new ExpenseRepository(TestDatabaseConnectionString, TimeSpan.MinValue);
Guid expenseIdToSave = Guid.NewGuid();
Assert.IsNull(DatabaseHelper.GetExpenseById(TestDatabaseConnectionString, expenseIdToSave));
var stubUser = new User { UserName = "******" };
var stubManager = "the manager";
var expenseToSave = new Model.Expense
{
Id = expenseIdToSave,
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = false,
User = stubUser,
ApproverName = stubManager
};
repository.SaveExpense(expenseToSave);
subscription.Sink.FlushAsync().Wait();
var logEntries = DatabaseHelper.GetAllLogEntries(TracingDatabaseConnectionString);
Assert.AreEqual(6, logEntries.Count());
var SaveExpenseStartedEntry = logEntries.SingleOrDefault(e=> e.EventId == 290);
Assert.IsNotNull(SaveExpenseStartedEntry);
StringAssert.Contains(SaveExpenseStartedEntry.Payload, expenseToSave.Id.ToString());
var SaveExpenseInsertStartedEntry = logEntries.SingleOrDefault(e=> e.EventId == 295);
Assert.IsNotNull(SaveExpenseInsertStartedEntry);
StringAssert.Contains(SaveExpenseInsertStartedEntry.Payload, expenseToSave.Id.ToString());
var SaveExpenseInsertFinishedEntry = logEntries.SingleOrDefault(e=> e.EventId == 294);
Assert.IsNotNull(SaveExpenseInsertFinishedEntry);
StringAssert.Contains(SaveExpenseInsertFinishedEntry.Payload, expenseToSave.Id.ToString());
var SaveExpenseCacheUpdatedEntry = logEntries.SingleOrDefault(e=> e.EventId == 292);
Assert.IsNotNull(SaveExpenseCacheUpdatedEntry);
var SaveExpenseFinishedEntry = logEntries.SingleOrDefault(e => e.EventId == 291);
Assert.IsNotNull(SaveExpenseFinishedEntry);
StringAssert.Contains(SaveExpenseFinishedEntry.Payload, expenseToSave.Id.ToString());
}
}
public void GetAllExpenses()
{
var expected = new AExpense.Model.Expense
{
Id = Guid.NewGuid(),
Date = new DateTime(1900, 01, 01),
Title = "Title",
Description = "Description",
Total = 1.0,
ReimbursementMethod = ReimbursementMethod.DirectDeposit,
CostCenter = "CostCenter",
Approved = true,
User = new User { UserName = "******" },
ApproverName = "approver name"
};
var repository = new ExpenseRepository(dataContext);
repository.SaveExpense(expected);
var expenses = repository.GetAllExpenses();
Assert.IsNotNull(expenses);
var actual = expenses.ToList().Where(e => e.Id == expected.Id).FirstOrDefault();
Assert.IsNotNull(actual);
Assert.AreEqual(expected.Total, actual.Total);
Assert.AreEqual(expected.Approved, actual.Approved);
Assert.AreEqual(expected.CostCenter, actual.CostCenter);
Assert.AreEqual(expected.Date, actual.Date);
Assert.AreEqual(expected.Description, actual.Description);
Assert.AreEqual(expected.Id, actual.Id);
Assert.AreEqual(expected.ReimbursementMethod, actual.ReimbursementMethod);
Assert.AreEqual(expected.Title, actual.Title);
Assert.AreEqual(expected.User.UserName, actual.User.UserName);
}
public void GetAllExpensesForApprovalLogsActivity()
{
using (var subscription = obsListener.LogToSqlDatabase("Activity", TracingDatabaseConnectionString))
{
var repository = new ExpenseRepository(TestDatabaseConnectionString, TimeSpan.MinValue);
repository.GetExpensesForApproval("ApproverUser");
subscription.Sink.FlushAsync().Wait();
var logEntries = DatabaseHelper.GetAllLogEntries(TracingDatabaseConnectionString);
Assert.AreEqual(6, logEntries.Count());
var GetExpensesForApprovalStartedEntry = logEntries.SingleOrDefault(e => e.EventId == 320);
Assert.IsNotNull(GetExpensesForApprovalStartedEntry);
StringAssert.Contains(GetExpensesForApprovalStartedEntry.Payload, "ApproverUser");
var GetExpensesForApprovalQueryStartedEntry = logEntries.SingleOrDefault(e => e.EventId == 327);
Assert.IsNotNull(GetExpensesForApprovalQueryStartedEntry);
StringAssert.Contains(GetExpensesForApprovalQueryStartedEntry.Payload, "ApproverUser");
var GetExpensesForApprovalQueryFinishedEntry = logEntries.SingleOrDefault(e => e.EventId == 324);
Assert.IsNotNull(GetExpensesForApprovalQueryFinishedEntry);
StringAssert.Contains(GetExpensesForApprovalQueryFinishedEntry.Payload, "ApproverUser");
var GetExpensesForApprovalCacheUpdateEntry = logEntries.SingleOrDefault(e => e.EventId == 326);
Assert.IsNotNull(GetExpensesForApprovalCacheUpdateEntry);
StringAssert.Contains(GetExpensesForApprovalCacheUpdateEntry.Payload, "ApproverUser");
var GetExpensesForApprovalFinishedEntry = logEntries.SingleOrDefault(e => e.EventId == 321);
Assert.IsNotNull(GetExpensesForApprovalFinishedEntry);
StringAssert.Contains(GetExpensesForApprovalFinishedEntry.Payload, "ApproverUser");
}
}
