public void Save_DifferentTransactionTypes_CorrectlySaved(TransactionType type) { var accountRepoSetup = new Mock<IDataAccess<Account>>(); accountRepoSetup.Setup(x => x.LoadList(null)).Returns(new List<Account>()); var transactionDataAccessMock = new TransactionDataAccessMock(); var repository = new TransactionRepository(transactionDataAccessMock, new RecurringTransactionDataAccessMock()); var account = new Account { Name = "TestAccount" }; var transaction = new FinancialTransaction { ChargedAccount = account, TargetAccount = null, Amount = 20, Type = (int) type }; repository.Save(transaction); transactionDataAccessMock.FinancialTransactionTestList[0].ShouldBeSameAs(transaction); transactionDataAccessMock.FinancialTransactionTestList[0].ChargedAccount.ShouldBeSameAs(account); transactionDataAccessMock.FinancialTransactionTestList[0].TargetAccount.ShouldBeNull(); transactionDataAccessMock.FinancialTransactionTestList[0].Type.ShouldBe((int) type); }
public void TransactionRepository_Update() { var dbHelper = new DbHelper(new SQLitePlatformWinRT(), new TestDatabasePath()); using (var db = dbHelper.GetSqlConnection()) { db.DeleteAll<FinancialTransaction>(); } var repository = new TransactionRepository(new TransactionDataAccess(dbHelper)); var account = new Account { Name = "TestAccount" }; var transaction = new FinancialTransaction { ChargedAccount = account, Amount = 20, AmountWithoutExchange = 20 }; repository.Save(transaction); Assert.AreEqual(1, repository.Data.Count); Assert.AreSame(transaction, repository.Data[0]); transaction.Amount = 30; repository.Save(transaction); Assert.AreEqual(1, repository.Data.Count); Assert.AreEqual(30, repository.Data[0].Amount); }
/// <summary> /// Checks if the recurring Transaction is up for a repetition based on the passed Financial Transaction /// </summary> /// <param name="recTrans">RecurringTransaction to check.</param> /// <param name="relTransaction">Reference Transaction</param> /// <returns>True or False if the transaction have to be repeated.</returns> public static bool CheckIfRepeatable(RecurringTransaction recTrans, FinancialTransaction relTransaction) { if (!relTransaction.IsCleared) return false; switch (recTrans.Recurrence) { case (int) TransactionRecurrence.Daily: return DateTime.Today.Date != relTransaction.Date.Date; case (int) TransactionRecurrence.DailyWithoutWeekend: return DateTime.Today.Date != relTransaction.Date.Date && DateTime.Today.DayOfWeek != DayOfWeek.Saturday && DateTime.Today.DayOfWeek != DayOfWeek.Sunday; case (int) TransactionRecurrence.Weekly: var daysWeekly = DateTime.Now - relTransaction.Date; return daysWeekly.Days >= 7; case (int) TransactionRecurrence.Biweekly: var daysBiweekly = DateTime.Now - relTransaction.Date; return daysBiweekly.Days >= 14; case (int) TransactionRecurrence.Monthly: return DateTime.Now.Month != relTransaction.Date.Month; case (int) TransactionRecurrence.Yearly: return (DateTime.Now.Year != relTransaction.Date.Year && DateTime.Now.Month >= relTransaction.Date.Month) || (DateTime.Now.Year - relTransaction.Date.Year) > 1; default: return false; } }
public void TransactionRepository_AddMultipleToCache() { var repository = new TransactionRepository(new TransactionDataAccessMock()); var account = new Account { Name = "TestAccount" }; var transaction = new FinancialTransaction { ChargedAccount = account, Amount = 20, AmountWithoutExchange = 20 }; var secondTransaction = new FinancialTransaction { ChargedAccount = account, Amount = 60, AmountWithoutExchange = 60 }; repository.Save(transaction); repository.Save(secondTransaction); Assert.AreEqual(2, repository.Data.Count); Assert.AreSame(transaction, repository.Data[0]); Assert.AreSame(secondTransaction, repository.Data[1]); }
public void Save_TransferTransaction_CorrectlySaved() { var transactionDataAccessMock = new TransactionDataAccessMock(); var repository = new TransactionRepository(transactionDataAccessMock, new RecurringTransactionDataAccessMock()); var account = new Account { Name = "TestAccount" }; var targetAccount = new Account { Name = "targetAccount" }; var transaction = new FinancialTransaction { ChargedAccount = account, TargetAccount = targetAccount, Amount = 20, Type = (int) TransactionType.Transfer }; repository.Save(transaction); transactionDataAccessMock.FinancialTransactionTestList[0].ShouldBeSameAs(transaction); transactionDataAccessMock.FinancialTransactionTestList[0].ChargedAccount.ShouldBeSameAs(account); transactionDataAccessMock.FinancialTransactionTestList[0].TargetAccount.ShouldBeSameAs(targetAccount); transactionDataAccessMock.FinancialTransactionTestList[0].Type.ShouldBe((int) TransactionType.Transfer); }
public void GetRecurringFromFinancialTransaction(int recurrence, string date, bool isEndless, int type) { var startDate = new DateTime(2015, 03, 12); var enddate = Convert.ToDateTime(date); var transaction = new FinancialTransaction { ChargedAccount = new Account {Id = 3}, TargetAccount = new Account {Id = 8}, Category = new Category {Id = 16}, Date = startDate, Amount = 2135, IsCleared = false, Type = type, IsRecurring = true }; var recurring = RecurringTransactionHelper.GetRecurringFromFinancialTransaction(transaction, isEndless, recurrence, enddate); recurring.ChargedAccount.Id.ShouldBe(3); recurring.TargetAccount.Id.ShouldBe(8); recurring.StartDate.ShouldBe(startDate); recurring.EndDate.ShouldBe(enddate); recurring.IsEndless.ShouldBe(isEndless); recurring.Amount.ShouldBe(transaction.Amount); recurring.Category.Id.ShouldBe(transaction.Category.Id); recurring.Type.ShouldBe(type); recurring.Recurrence.ShouldBe(recurrence); recurring.Note.ShouldBe(transaction.Note); }
private static async Task HandleTransactionAmount(FinancialTransaction transaction, Func<double, double> amountFunc, Func<FinancialTransaction, Account> getAccountFunc) { if (transaction.ClearTransactionNow) { var account = getAccountFunc(transaction); if (account == null) { return; } var amountWithoutExchange = amountFunc(transaction.Amount); //Currently there is no support for currency exchanges var amount = amountWithoutExchange; account.CurrentBalanceWithoutExchange += amountWithoutExchange; account.CurrentBalance += amount; transaction.Cleared = true; AccountRepository.Save(account); TransactionData.Save(transaction); } else { transaction.Cleared = false; TransactionData.Save(transaction); } }
public void TransactionRepository_Update() { var dbHelper = new SqliteConnectionCreator(new WindowsSqliteConnectionFactory()); using (var db = dbHelper.GetConnection()) { db.DeleteAll<FinancialTransaction>(); } var repository = new TransactionRepository(new TransactionDataAccess(dbHelper), new RecurringTransactionDataAccess(dbHelper)); var account = new Account { Name = "TestAccount" }; var transaction = new FinancialTransaction { ChargedAccount = account, Amount = 20 }; repository.Save(transaction); repository.Data.Count.ShouldBe(1); repository.Data[0].ShouldBeSameAs(transaction); transaction.Amount = 30; repository.Save(transaction); repository.Data.Count.ShouldBe(1); repository.Data[0].Amount.ShouldBe(30); }
/// <summary> /// Checks if the recurring Transaction is up for a repetition based on the passed Financial Transaction /// </summary> /// <param name="recTrans">RecurringTransaction to check.</param> /// <param name="relTransaction">Reference Transaction</param> /// <returns>True or False if the transaction have to be repeated.</returns> public static bool CheckIfRepeatable(RecurringTransaction recTrans, FinancialTransaction relTransaction) { switch (recTrans.Recurrence) { case (int) TransactionRecurrence.Daily: return DateTime.Today.Date != relTransaction.Date.Date; case (int) TransactionRecurrence.DailyWithoutWeekend: return DateTime.Today.Date != relTransaction.Date.Date && DateTime.Today.DayOfWeek != DayOfWeek.Saturday && DateTime.Today.DayOfWeek != DayOfWeek.Sunday; case (int) TransactionRecurrence.Weekly: var days = DateTime.Now - relTransaction.Date; return days.Days >= 7; case (int) TransactionRecurrence.Monthly: return DateTime.Now.Month != relTransaction.Date.Month; case (int) TransactionRecurrence.Yearly: return DateTime.Now.Year != relTransaction.Date.Year && DateTime.Now.Month == relTransaction.Date.Month; default: return false; } }
private static async void PrehandleRemoveIfTransfer(FinancialTransaction transaction) { if (transaction.Type == (int) TransactionType.Transfer) { Func<double, double> amountFunc = x => -x; await HandleTransactionAmount(transaction, amountFunc, GetTargetAccountFunc()); } }
private FinancialTransaction GetLastOccurence(FinancialTransaction transaction) { var transcationList = transactionRepository.Data .Where(x => x.ReccuringTransactionId == transaction.ReccuringTransactionId) .OrderBy(x => x.Date) .ToList(); return transcationList.LastOrDefault(); }
public static async Task AddTransactionAmount(FinancialTransaction transaction) { PrehandleAddIfTransfer(transaction); Func<double, double> amountFunc = x => transaction.Type == (int) TransactionType.Income ? x : -x; await HandleTransactionAmount(transaction, amountFunc, GetChargedAccountFunc()); }
public void DeleteTransaction(FinancialTransaction transaction) { var relatedTrans = transactionRepository.Data.Where(x => x.Id == transaction.Id).ToList(); foreach (var trans in relatedTrans) { transactionRepository.Delete(trans); } RemoveTransactionAmount(transaction); }
private double HandleTransferAmount(FinancialTransaction transaction, double balance) { if (accountRepository.Selected == transaction.ChargedAccount) { balance -= transaction.Amount; } else { balance += transaction.Amount; } return balance; }
public void SaveWithouthAccount_NoAccount_InvalidDataException() { var repository = new TransactionRepository(new TransactionDataAccessMock(), new RecurringTransactionDataAccessMock()); var transaction = new FinancialTransaction { Amount = 20 }; Assert.Throws<InvalidDataException>(() => repository.Save(transaction)); }
private void LoadTransactions() { //Refresh balance control with the current account balanceViewModel.IsTransactionView = true; balanceViewModel.UpdateBalance(); SelectedTransaction = null; RelatedTransactions = new ObservableCollection<FinancialTransaction>(transactionRepository .GetRelatedTransactions(accountRepository.Selected) .OrderByDescending(x => x.Date) .ToList()); }
public async Task<bool> CheckForRecurringTransaction(FinancialTransaction transaction) { if (!transaction.IsRecurring) { return false; } return await dialogService.ShowConfirmMessage(Strings.ChangeSubsequentTransactionsTitle, Strings.ChangeSubsequentTransactionsMessage, Strings.RecurringLabel, Strings.JustThisLabel); }
public static async Task RemoveTransactionAmount(FinancialTransaction transaction) { if (transaction.Cleared) { PrehandleRemoveIfTransfer(transaction); Func<double, double> amountFunc = x => transaction.Type == (int) TransactionType.Income ? -x : x; await HandleTransactionAmount(transaction, amountFunc, GetChargedAccountFunc()); } }
public static async Task DeleteTransaction(FinancialTransaction transaction, bool skipConfirmation = false) { //TODO: refactor if (skipConfirmation) //|| await Utilities.IsDeletionConfirmed()) { await CheckForRecurringTransaction(transaction, () => RecurringTransactionLogic.Delete(transaction.RecurringTransaction)); TransactionRepository.Delete(transaction); await AccountLogic.RemoveTransactionAmount(transaction); AccountLogic.RefreshRelatedTransactions(); ServiceLocator.Current.GetInstance<BalanceViewModel>().UpdateBalance(); } }
public void SaveWithouthAccount_NoAccount_InvalidDataException() { var accountRepoSetup = new Mock<IDataAccess<Account>>(); accountRepoSetup.Setup(x => x.LoadList(null)).Returns(new List<Account>()); var repository = new TransactionRepository(new TransactionDataAccessMock(), new RecurringTransactionDataAccessMock()); var transaction = new FinancialTransaction { Amount = 20 }; Assert.Throws<AccountMissingException>(() => repository.Save(transaction)); }
public void ResetCategoryCommand_FilledProperty_PropertyIsNull() { var transactionSetup = new Mock<ITransactionRepository>(); var transaction = new FinancialTransaction { Category = new Category() }; transactionSetup.SetupGet(x => x.Selected).Returns(transaction); var transactionRepository = transactionSetup.Object; new SelectCategoryTextBoxViewModel(transactionRepository).ResetCategoryCommand.Execute(); Assert.Null(transaction.Category); }
public static void PrepareEdit(FinancialTransaction transaction) { ServiceLocator.Current.GetInstance<CategoryListViewModel>().IsSettingCall = false; AddTransactionView.IsEdit = true; AddTransactionView.IsTransfer = transaction.Type == (int) TransactionType.Transfer; if (transaction.ReccuringTransactionId.HasValue && transaction.RecurringTransaction != null) { AddTransactionView.IsEndless = transaction.RecurringTransaction.IsEndless; AddTransactionView.Recurrence = transaction.RecurringTransaction.Recurrence; } //Ultra dirty monkey patch for a problem with displaying the selected account. //TODO: Do this in a nicer way! transaction.ChargedAccount = AccountRepository.Data.First(x => x.Id == transaction.ChargedAccountId); TransactionRepository.Selected = transaction; }
public static RecurringTransaction GetRecurringFromFinancialTransaction(FinancialTransaction transaction) { return new RecurringTransaction { ChargedAccount = transaction.ChargedAccount, TargetAccount = transaction.TargetAccount, StartDate = transaction.Date, EndDate = addTransactionView.EndDate, IsEndless = addTransactionView.IsEndless, Amount = transaction.Amount, AmountWithoutExchange = transaction.AmountWithoutExchange, Currency = transaction.Currency, CategoryId = transaction.CategoryId, Type = transaction.Type, Recurrence = addTransactionView.Recurrence, Note = transaction.Note }; }
public void DeleteAssociatedTransactionsFromDatabase_Account_DeleteRightTransactions() { var resultList = new List<int>(); var account1 = new Account { Id = 3, Name = "just an account", CurrentBalance = 500 }; var account2 = new Account { Id = 4, Name = "just an account", CurrentBalance = 900 }; var trans1 = new FinancialTransaction { Id = 1, ChargedAccount = account1, ChargedAccountId = account1.Id }; var transRepoSetup = new Mock<ITransactionRepository>(); transRepoSetup.SetupAllProperties(); transRepoSetup.Setup(x => x.Delete(It.IsAny<FinancialTransaction>())) .Callback((FinancialTransaction trans) => resultList.Add(trans.Id)); transRepoSetup.Setup(x => x.GetRelatedTransactions(It.IsAny<Account>())) .Returns(new List<FinancialTransaction> { trans1 }); var repo = transRepoSetup.Object; repo.Data = new ObservableCollection<FinancialTransaction>(); new TransactionManager(repo, new Mock<IAccountRepository>().Object, new Mock<IDialogService>().Object) .DeleteAssociatedTransactionsFromDatabase(account1); resultList.Count.ShouldBe(1); resultList.First().ShouldBe(trans1.Id); }
public void TransactionRepository_AddItemToDataList() { var repository = new TransactionRepository(new TransactionDataAccessMock()); var account = new Account { Name = "TestAccount" }; var transaction = new FinancialTransaction { ChargedAccount = account, Amount = 20, AmountWithoutExchange = 20, Type = (int) TransactionType.Transfer }; repository.Save(transaction); Assert.IsTrue(repository.Data.Contains(transaction)); }
public static async Task SaveTransaction(FinancialTransaction transaction, bool refreshRelatedList = false, bool skipRecurring = false) { if (transaction.IsRecurring && !skipRecurring) { var recurringTransaction = RecurringTransactionLogic.GetRecurringFromFinancialTransaction(transaction); RecurringTransactionRepository.Save(recurringTransaction); TransactionRepository.Save(transaction); transaction.RecurringTransaction = recurringTransaction; } TransactionRepository.Save(transaction); if (refreshRelatedList) { ServiceLocator.Current.GetInstance<TransactionListViewModel>() .SetRelatedTransactions(AccountRepository.Selected); } await AccountLogic.AddTransactionAmount(transaction); }
/// <summary> /// SaveItem a new item or update an existin one. /// </summary> /// <param name="item">item to save</param> public void Save(FinancialTransaction item) { if (item.ChargedAccount == null) { throw new InvalidDataException("charged accout is missing"); } if (item.Id == 0) { data.Add(item); } //delete recurring transaction if isRecurring is no longer set. if (!item.IsRecurring && item.ReccuringTransactionId != 0) { recurringDataAccess.DeleteItem(item.RecurringTransaction); item.ReccuringTransactionId = 0; } dataAccess.SaveItem(item); }
public void TransactionDataAccess_CrudTransaction() { var transactionDataAccess = new TransactionDataAccess(new SqliteConnectionCreator(new WindowsSqliteConnectionFactory())); const double firstAmount = 76.30; const double secondAmount = 22.90; var transaction = new FinancialTransaction { ChargedAccount = new Account {Id = 4}, Amount = firstAmount, Date = DateTime.Today, Note = "this is a note!!!", IsCleared = false }; transactionDataAccess.SaveItem(transaction); var list = transactionDataAccess.LoadList(); Assert.Equal(1, list.Count); Assert.Equal(firstAmount, list.First().Amount); transaction.Amount = secondAmount; transactionDataAccess.SaveItem(transaction); transactionDataAccess.LoadList(); list = transactionDataAccess.LoadList(); Assert.Equal(1, list.Count); Assert.Equal(secondAmount, list.First().Amount); transactionDataAccess.DeleteItem(transaction); transactionDataAccess.LoadList(); list = transactionDataAccess.LoadList(); Assert.False(list.Any()); }
public void TransactionDataAccess_CrudTransaction() { var transactionDataAccess = new TransactionDataAccess(new DbHelper(new SQLitePlatformWinRT(), new TestDatabasePath())); const double firstAmount = 76.30; const double secondAmount = 22.90; var transaction = new FinancialTransaction { ChargedAccount = new Account {Id = 4}, Amount = firstAmount, Date = DateTime.Today, Note = "this is a note!!!", Cleared = false }; transactionDataAccess.Save(transaction); var list = transactionDataAccess.LoadList(); Assert.AreEqual(1, list.Count); Assert.AreEqual(firstAmount, list.First().Amount); transaction.Amount = secondAmount; transactionDataAccess.Save(transaction); transactionDataAccess.LoadList(); list = transactionDataAccess.LoadList(); Assert.AreEqual(1, list.Count); Assert.AreEqual(secondAmount, list.First().Amount); transactionDataAccess.Delete(transaction); transactionDataAccess.LoadList(); list = transactionDataAccess.LoadList(); Assert.IsFalse(list.Any()); }
private void LoadTransactions() { EditCommand = null; //Refresh balance control with the current account balanceViewModel.UpdateBalance(true); SelectedTransaction = null; RelatedTransactions = new ObservableCollection<FinancialTransaction>(transactionRepository .GetRelatedTransactions(accountRepository.Selected) .OrderByDescending(x => x.Date) .ToList()); Source = new ObservableCollection<DateListGroup<FinancialTransaction>>( DateListGroup<FinancialTransaction>.CreateGroups(RelatedTransactions, CultureInfo.CurrentUICulture, s => s.Date.ToString("MMMM", CultureInfo.InvariantCulture) + " " + s.Date.Year, s => s.Date, true)); SelectedTransaction = null; //We have to set the command here to ensure that the selection changed event is triggered earlier EditCommand = new MvxCommand(Edit); }