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