public void RecurringTransactionRepository_Delete()
{
var recurringTransactionDataAccessMock = new RecurringTransactionDataAccessMock();
var repository = new RecurringTransactionRepository(recurringTransactionDataAccessMock);
var account = new Account
{
Name = "TestAccount"
};
var transaction = new RecurringTransaction
{
ChargedAccount = account,
Amount = 20,
AmountWithoutExchange = 20
};
repository.Save(transaction);
Assert.AreSame(transaction, recurringTransactionDataAccessMock.RecurringTransactionTestList[0]);
repository.Delete(transaction);
Assert.IsFalse(recurringTransactionDataAccessMock.RecurringTransactionTestList.Any());
Assert.IsFalse(repository.Data.Any());
}
public void RecurringTransactionRepository_AddMultipleToCache()
{
var repository = new RecurringTransactionRepository(_recurringTransactionDataAccessMock);
var account = new Account {
Name = "TestAccount"
};
var transaction = new RecurringTransaction {
ChargedAccount = account,
Amount = 20,
AmountWithoutExchange = 20
};
var secondTransaction = new RecurringTransaction {
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 RecurringTransactionRepository_Update()
{
using (var db = SqlConnectionFactory.GetSqlConnection()) {
db.DeleteAll <RecurringTransaction>();
}
var repository = new RecurringTransactionRepository(new RecurringTransactionDataAccess());
var account = new Account {
Name = "TestAccount"
};
var transaction = new RecurringTransaction {
ChargedAccount = account,
Amount = 20,
AmountWithoutExchange = 20
};
repository.Save(transaction);
Assert.AreEqual(1, repository.Data.Count);
Assert.AreSame(transaction, repository.Data[0]);
transaction.Amount = 789;
repository.Save(transaction);
Assert.AreEqual(1, repository.Data.Count);
Assert.AreEqual(789, repository.Data[0].Amount);
}
public void RecurringTransactionRepository_Update()
{
var dbHelper = new DbHelper(new SQLitePlatformWinRT(), new TestDatabasePath());
using (var db = dbHelper.GetSqlConnection())
{
db.DeleteAll<RecurringTransaction>();
}
var repository = new RecurringTransactionRepository(new RecurringTransactionDataAccess(dbHelper));
var account = new Account
{
Name = "TestAccount"
};
var transaction = new RecurringTransaction
{
ChargedAccount = account,
Amount = 20,
AmountWithoutExchange = 20
};
repository.Save(transaction);
Assert.AreEqual(1, repository.Data.Count);
Assert.AreSame(transaction, repository.Data[0]);
transaction.Amount = 789;
repository.Save(transaction);
Assert.AreEqual(1, repository.Data.Count);
Assert.AreEqual(789, repository.Data[0].Amount);
}
public void RecurringTransactionRepository_AddMultipleToCache()
{
var recurringTransactionDataAccessMock = new RecurringTransactionDataAccessMock();
var repository = new RecurringTransactionRepository(recurringTransactionDataAccessMock);
var account = new Account
{
Name = "TestAccount"
};
var transaction = new RecurringTransaction
{
ChargedAccount = account,
Amount = 20,
AmountWithoutExchange = 20
};
var secondTransaction = new RecurringTransaction
{
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 ViewPrediction()
{
InitializeComponent();
transactionRepository = TransactionRepository.Instance;
recurringTransactionRepository = RecurringTransactionRepository.Instance;
dtp_date.MinDate = DateTime.Now.AddDays(1);
}
private static void CheckIfRecurringWasRemoved(FinancialTransaction transaction)
{
if (!transaction.IsRecurring && transaction.ReccuringTransactionId.HasValue)
{
RecurringTransactionRepository.Delete(transaction.RecurringTransaction);
transaction.ReccuringTransactionId = null;
}
}
public MonthlyViewController(UnitOfWork unitOfWork,
TransactionLineRepository transactionLineRepository,
RecurringTransactionRepository recurringTransactionRepository,
MontlyBudgetRepository montlyBudgetRepository) : base(unitOfWork)
{
this.transactionLineRepository = transactionLineRepository;
this.recurringTransactionRepository = recurringTransactionRepository;
this.montlyBudgetRepository = montlyBudgetRepository;
}
public async Task Create_ReturnsNewTransaction()
{
string usersJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Users.json");
var user = JsonConvert.DeserializeObject <List <User> >(usersJson).First(u => u.Id == TESTING_USER_ID);
string categoriesJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Categories.json");
var category = JsonConvert.DeserializeObject <List <Category> >(categoriesJson)
.First(c => !c.IsCustom || c.User.Id == TESTING_USER_ID);
string walletsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Wallets.json");
var wallet = JsonConvert.DeserializeObject <List <Wallet> >(walletsJson)
.First(w => !w.IsDefault && w.User.Id == TESTING_USER_ID);
const string newTitle = "Test title";
const double newAmount = 101;
string newInterval = RegularTransaction.IntervalOptions.Month.ToString();
DateTime newNextDate = DateTime.Today.AddDays(7);
var newTransaction = new RegularTransaction
{
Title = newTitle,
Amount = newAmount,
CategoryId = category.Id,
NextTransactionDate = newNextDate,
Interval = newInterval,
WalletId = wallet.Id
};
UserRepository.Setup(u => u.GetByKey(TESTING_USER_ID)).Returns(user);
CategoryRepository.Setup(c => c.GetByKey(category.Id)).Returns(category);
RecurringTransactionRepository
.Setup(t => t.Create(newTransaction))
.ReturnsAsync(newTransaction);
WalletRepository.Setup(w => w.GetByKey(wallet.Id)).Returns(wallet);
var resultTransaction = await RecurringTransactionService.Create(newTransaction);
Assert.NotNull(resultTransaction);
Assert.NotNull(resultTransaction.User);
Assert.NotNull(resultTransaction.Category);
Assert.NotNull(resultTransaction.Wallet);
Assert.Equal(TESTING_USER_ID, resultTransaction.User.Id);
Assert.Equal(category.Id, resultTransaction.Category.Id);
Assert.Equal(wallet.Id, resultTransaction.Wallet.Id);
Assert.Equal(newTitle, resultTransaction.Title);
Assert.Equal(newAmount, resultTransaction.Amount);
Assert.Equal(newInterval, resultTransaction.Interval);
Assert.Equal(DateTime.Today, resultTransaction.Date);
Assert.Equal(newNextDate, resultTransaction.NextTransactionDate);
}
public ViewTransactions(bool recurring)
{
InitializeComponent();
isRecurring = recurring;
Text = Strings.RecurringTransactions;
if (isRecurring)
{
lv_transactions.Columns.Add("Status");
lv_transactions.Columns.Add("End date");
recurringTransactionRepository = RecurringTransactionRepository.Instance;
}
ResizeColumns();
transactionRepository = TransactionRepository.Instance;
}
private async void _getRecurringTransactions()
{
RecurringTransactionRepository recurringTransactionRepository = new RecurringTransactionRepository();
List <RecurringTransaction> listOfRecurringTransaction = await Task.Run(() => recurringTransactionRepository.GetTransactions(UserSession.UserData.Id));
TransactionListView.Items.Clear();
foreach (RecurringTransaction recurringTransaction in listOfRecurringTransaction)
{
ListViewItem listView = new ListViewItem(new string[] { recurringTransaction.Name, recurringTransaction.Type, recurringTransaction.Amount.ToString("£0.00"), recurringTransaction.TransactionDate.ToString() })
{
Tag = recurringTransaction
};
TransactionListView.Items.Add(listView);
}
}
public static async Task UpdateTransaction(FinancialTransaction transaction)
{
CheckIfRecurringWasRemoved(transaction);
await AccountLogic.AddTransactionAmount(transaction);
TransactionRepository.Save(transaction);
RecurringTransaction recurringTransaction =
RecurringTransactionLogic.GetRecurringFromFinancialTransaction(transaction);
await
CheckForRecurringTransaction(transaction,
() => RecurringTransactionRepository.Save(recurringTransaction));
AccountLogic.RefreshRelatedTransactions();
}
public void RecurringTransactionRepository_Save()
{
var repository = new RecurringTransactionRepository(_recurringTransactionDataAccessMock);
var account = new Account {
Name = "TestAccount"
};
var transaction = new RecurringTransaction {
ChargedAccount = account,
Amount = 20,
AmountWithoutExchange = 20
};
repository.Save(transaction);
Assert.IsTrue(transaction == _recurringTransactionDataAccessMock.RecurringTransactionTestList[0]);
Assert.IsTrue(account == _recurringTransactionDataAccessMock.RecurringTransactionTestList[0].ChargedAccount);
}
public void RecurringTransactionRepository_LoadDataFromDbThroughRepository()
{
using (var db = SqlConnectionFactory.GetSqlConnection()) {
db.DeleteAll <RecurringTransaction>();
db.InsertWithChildren(new RecurringTransaction {
Amount = 999,
AmountWithoutExchange = 777,
ChargedAccount = new Account {
Name = "testAccount"
}
});
}
var repository = new RecurringTransactionRepository(new RecurringTransactionDataAccess());
Assert.IsTrue(repository.Data.Any());
Assert.AreEqual(999, repository.Data[0].Amount);
Assert.AreEqual(777, repository.Data[0].AmountWithoutExchange);
}
public void TransactionRepository_SaveWithouthAccount()
{
try {
var repository = new RecurringTransactionRepository(_recurringTransactionDataAccessMock);
var transaction = new RecurringTransaction {
Amount = 20,
AmountWithoutExchange = 20
};
repository.Save(transaction);
}
catch (InvalidDataException) {
return;
}
catch (Exception) {
Assert.Fail("wrong exception.");
}
Assert.Fail("No excpetion thrown");
}
public static async Task SaveTransaction(FinancialTransaction transaction, bool refreshRelatedList = false,
bool skipRecurring = false)
{
if (transaction.IsRecurring && !skipRecurring)
{
RecurringTransaction 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);
}
private async void TransactionActionForm_Load(object sender, EventArgs e)
{
ContactRepository contactRepository = new ContactRepository();
_normalTransactionRepository = new NormalTransactionRepository();
_recurringTransactionRepository = new RecurringTransactionRepository();
List <Contact> contactList = await Task.Run(() => contactRepository.GetContacts(UserSession.UserData.Id));
CmbContact.DataSource = contactList;
CmbContact.DisplayMember = "Name";
if (_recurringStatus)
{
_setContactForTransaction(contactList, _recurringTransaction);
}
else
{
_setContactForTransaction(contactList, _normalTransaction);
}
}
public void RecurringTransactionRepository_Delete()
{
var repository = new RecurringTransactionRepository(_recurringTransactionDataAccessMock);
var account = new Account {
Name = "TestAccount"
};
var transaction = new RecurringTransaction {
ChargedAccount = account,
Amount = 20,
AmountWithoutExchange = 20
};
repository.Save(transaction);
Assert.AreSame(transaction, _recurringTransactionDataAccessMock.RecurringTransactionTestList[0]);
repository.Delete(transaction);
Assert.IsFalse(_recurringTransactionDataAccessMock.RecurringTransactionTestList.Any());
Assert.IsFalse(repository.Data.Any());
}
private async void BtnPredict_Click(object sender, EventArgs e)
{
NormalTransactionRepository normalTransactionRepository = new NormalTransactionRepository();
RecurringTransactionRepository recurringTransactionRepository = new RecurringTransactionRepository();
List <Transaction> transactionList = await Task.Run(() => normalTransactionRepository.GetExpenseTransactions(UserSession.UserData.Id));
List <RecurringTransaction> recurringTransaction = await Task.Run(() => recurringTransactionRepository.GetExpenseTransactions(UserSession.UserData.Id));
double averageOfTransaction = _getAverage(transactionList);
double totalOfRecurringTransaction = _getRecurringTransactionAmount(recurringTransaction);
double prediction = 0;
if (averageOfTransaction > totalOfRecurringTransaction)
{
prediction = averageOfTransaction;
}
else
{
prediction = totalOfRecurringTransaction;
}
MessageBox.Show("Predicted Expense for " + DPickerDate.Value.ToShortDateString() + " : £" + prediction.ToString("0.00"), "INFORMATION", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
public void RecurringTransactionRepository_LoadDataFromDbThroughRepository()
{
var dbHelper = new DbHelper(new SQLitePlatformWinRT(), new TestDatabasePath());
using (var db = dbHelper.GetSqlConnection())
{
db.DeleteAll<RecurringTransaction>();
db.InsertWithChildren(new RecurringTransaction
{
Amount = 999,
AmountWithoutExchange = 777,
ChargedAccount = new Account
{
Name = "testAccount"
}
});
}
var repository = new RecurringTransactionRepository(new RecurringTransactionDataAccess(dbHelper));
Assert.IsTrue(repository.Data.Any());
Assert.AreEqual(999, repository.Data[0].Amount);
Assert.AreEqual(777, repository.Data[0].AmountWithoutExchange);
}
public async Task Delete_ReturnsDeletedTransaction()
{
string transactionsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"RegularTransactions.json");
var transaction = JsonConvert.DeserializeObject <List <RegularTransaction> >(transactionsJson)
.First(u => u.User.Id == TESTING_USER_ID);
RecurringTransactionRepository.Setup(t => t.GetByKey(transaction.Id)).Returns(transaction);
RecurringTransactionRepository
.Setup(t => t.Delete(transaction.Id))
.ReturnsAsync(transaction);
var resultTransaction = await RecurringTransactionService.Delete(transaction.Id);
Assert.NotNull(resultTransaction);
Assert.Equal(transaction.Title, resultTransaction.Title);
Assert.Equal(transaction.Amount, resultTransaction.Amount);
Assert.Equal(transaction.Interval, resultTransaction.Interval);
Assert.Equal(transaction.Date, resultTransaction.Date);
Assert.Equal(transaction.NextTransactionDate, resultTransaction.NextTransactionDate);
}
public async Task Update_ReturnsUpdatedTransaction()
{
string usersJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Users.json");
var user = JsonConvert.DeserializeObject <List <User> >(usersJson).First(u => u.Id == TESTING_USER_ID);
string categoriesJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Categories.json");
var category = JsonConvert.DeserializeObject <List <Category> >(categoriesJson)
.First(c => c.IsCustom && c.User.Id == TESTING_USER_ID);
string walletsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"Wallets.json");
var wallet = JsonConvert.DeserializeObject <List <Wallet> >(walletsJson)
.First(w => w.IsDefault);
string transactionsJson = File.ReadAllText(TestConfiguration.MockDataFolderPath + @"RegularTransactions.json");
var transaction = JsonConvert.DeserializeObject <List <RegularTransaction> >(transactionsJson)
.First(u => u.User.Id == TESTING_USER_ID && u.Category.Id == category.Id && u.Wallet.Id == wallet.Id);
const string newTitle = "Test title";
const double newAmount = 101;
// Just because "user" and "category" variables contain more relationships
transaction.User = user;
transaction.Category = category;
transaction.Wallet = wallet;
var newTransaction = new RegularTransaction
{
Id = transaction.Id,
Title = newTitle,
Amount = newAmount,
Category = transaction.Category,
Wallet = transaction.Wallet,
User = transaction.User,
NextTransactionDate = transaction.NextTransactionDate,
Interval = transaction.Interval
};
CategoryRepository.Setup(c => c.GetByKey(category.Id)).Returns(category);
RecurringTransactionRepository.Setup(t => t.GetByKey(newTransaction.Id)).Returns(transaction);
RecurringTransactionRepository
.Setup(t => t.Update(transaction))
.ReturnsAsync(transaction);
var resultTransaction = await RecurringTransactionService.Update(newTransaction);
Assert.NotNull(resultTransaction);
Assert.NotNull(resultTransaction.User);
Assert.NotNull(resultTransaction.Category);
Assert.NotNull(resultTransaction.Wallet);
Assert.Equal(TESTING_USER_ID, resultTransaction.User.Id);
Assert.Equal(category.Id, resultTransaction.Category.Id);
Assert.Equal(wallet.Id, resultTransaction.Wallet.Id);
Assert.Equal(newTitle, resultTransaction.Title);
Assert.Equal(newAmount, resultTransaction.Amount);
Assert.Equal(transaction.Interval, resultTransaction.Interval);
Assert.Equal(transaction.Date, resultTransaction.Date);
Assert.Equal(transaction.NextTransactionDate, resultTransaction.NextTransactionDate);
}
public async void _checkRecurringTransaction()
{
NormalTransactionRepository normalTransactionRepository = new NormalTransactionRepository();
RecurringTransactionRepository recurringTransactionRepository = new RecurringTransactionRepository();
List <RecurringTransaction> recurringTransactionList = recurringTransactionRepository.GetTransactions(UserSession.UserData.Id);
foreach (RecurringTransaction recurringTransaction in recurringTransactionList)
{
int noOfDays = (DateTime.Now - UserSession.UserData.LastAccessDate).Days;
DateTime recurringTime = UserSession.UserData.LastAccessDate;
TimeSpan timeSpan = new TimeSpan(recurringTransaction.TransactionDate.Hour, recurringTransaction.TransactionDate.Minute, recurringTransaction.TransactionDate.Second);
recurringTime = recurringTime.Date + timeSpan;
for (int i = 0; i <= noOfDays; i++)
{
if (recurringTransaction.Status.Equals("Weekly"))
{
if (recurringTime.DayOfWeek != recurringTransaction.TransactionDate.DayOfWeek)
{
recurringTime = recurringTime.AddDays(1);
continue;
}
}
if (recurringTransaction.Status.Equals("Monthly"))
{
if (recurringTime.Day != recurringTransaction.TransactionDate.Day)
{
recurringTime = recurringTime.AddDays(1);
continue;
}
}
if (recurringTransaction.Status.Equals("Yearly"))
{
string recurringTimeString = recurringTime.ToString("dd/MM");
string createdDateString = recurringTransaction.TransactionDate.ToString("dd/MM");
if (!recurringTimeString.Equals(createdDateString))
{
recurringTime = recurringTime.AddDays(1);
continue;
}
}
if (recurringTime > UserSession.UserData.LastAccessDate && recurringTime <= DateTime.Now && recurringTime > recurringTransaction.TransactionDate)
{
_messageStatus = await Task.Run(() => normalTransactionRepository.AddNormalTransaction(new Transaction
{
Name = recurringTransaction.Name,
Amount = recurringTransaction.Amount,
Type = recurringTransaction.Type,
TransactionDate = recurringTime,
Note = recurringTransaction.Note,
ContactId = recurringTransaction.ContactId,
UserId = recurringTransaction.UserId
}));
RecurringBackground.ReportProgress(1, "New Transaction has been Added");
}
recurringTime = recurringTime.AddDays(1);
}
}
}
private async void AddTransaction()
{
if (tbx_name.Text.Equals(""))
{
MessageBox.Show(Strings.ErrorEmptyName, Strings.Error);
return;
}
TransactionRepository transactionRepository = TransactionRepository.Instance;
transaction.Name = tbx_name.Text;
transaction.TypeName = cbx_type.Text;
transaction.Amount = nud_amount.Value;
transaction.CreatedDate = dtp_date.Value;
transaction.Note = rtbx_note.Text;
transaction.Type = transaction.TypeName.Equals("Income") ? true : false;
Contact contact = (Contact)cbx_contact.SelectedItem;
if (contact == null)
{
if (string.IsNullOrWhiteSpace(cbx_contact.Text))
{
transaction.ContactID = 0;
}
else
{
ContactRepository contactRepository = ContactRepository.Instance;
transaction.ContactID = contactRepository.AddContact(new Contact {
Name = cbx_contact.Text, UserID = Instances.User.ID
});
}
}
else
{
transaction.ContactID = contact.ID;
}
if (chbx_recurring.Checked && transaction.ID == 0)
{
RecurringTransaction temporaryRecurringTransaction = new RecurringTransaction
{
Name = transaction.Name,
Amount = transaction.Amount,
UserID = transaction.UserID,
Type = transaction.Type,
CreatedDate = transaction.CreatedDate,
Note = transaction.Note,
ContactID = transaction.ContactID
};
if (chbx_infinite.Checked)
{
temporaryRecurringTransaction.EndDate = DateTime.MinValue;
}
else
{
temporaryRecurringTransaction.EndDate = dtp_end_date.Value;
}
temporaryRecurringTransaction.Status = cbx_frequency.Text;
RecurringTransactionRepository recurringTransactionRepository = RecurringTransactionRepository.Instance;
bool i = await Task.Run(() => recurringTransactionRepository.AddTransaction(temporaryRecurringTransaction));
if (i == false)
{
MessageBox.Show(Strings.SomethingError, Strings.Error);
return;
}
}
bool result = false;
if (transaction.ID > 0)
{
result = await Task.Run(() => transactionRepository.EditTransaction(transaction));
}
else
{
result = await Task.Run(() => transactionRepository.AddTransaction(transaction));
}
if (transaction.ID > 0 && result)
{
MessageBox.Show(Strings.EditTransactionOkay, Strings.Success);
Dispose();
}
else if (result)
{
MessageBox.Show(Strings.AddTransactionOkay, Strings.Success);
Dispose();
}
else
{
MessageBox.Show(Strings.SomethingError, Strings.Error);
}
}
public void RecurringTransactionRepository_Save()
{
var recurringTransactionDataAccessMock = new RecurringTransactionDataAccessMock();
var repository = new RecurringTransactionRepository(recurringTransactionDataAccessMock);
var account = new Account
{
Name = "TestAccount"
};
var transaction = new RecurringTransaction
{
ChargedAccount = account,
Amount = 20,
AmountWithoutExchange = 20
};
repository.Save(transaction);
Assert.IsTrue(transaction == recurringTransactionDataAccessMock.RecurringTransactionTestList[0]);
Assert.IsTrue(account == recurringTransactionDataAccessMock.RecurringTransactionTestList[0].ChargedAccount);
}
private async void DoRecurringTransaction()
{
TransactionRepository transactionRepository = TransactionRepository.Instance;
RecurringTransactionRepository recurringTransactionRepository = RecurringTransactionRepository.Instance;
if (Instances.User == null)
{
return;
}
List <RecurringTransaction> recurringTransactions = recurringTransactionRepository.GetUserTransactions(Instances.User.ID);
foreach (RecurringTransaction recurringTransaction in recurringTransactions)
{
if (Instances.User == null)
{
return;
}
if (DateTime.Now > recurringTransaction.EndDate && recurringTransaction.EndDate != DateTime.MinValue)
{
continue;
}
DateTime accTime = Instances.User.LastAccessDate;
DateTime nowTime = DateTime.Now;
int days = (nowTime - accTime).Days;
DateTime recTime = Instances.User.LastAccessDate;
TimeSpan ts = new TimeSpan(
recurringTransaction.CreatedDate.Hour,
recurringTransaction.CreatedDate.Minute,
recurringTransaction.CreatedDate.Second
);
recTime = recTime.Date + ts;
for (int i = 0; i <= days; i++)
{
if (recurringTransaction.Status.Equals("Weekly"))
{
if (recTime.DayOfWeek != recurringTransaction.CreatedDate.DayOfWeek)
{
recTime = recTime.AddDays(1);
continue;
}
}
if (recurringTransaction.Status.Equals("Monthly"))
{
if (recTime.Day != recurringTransaction.CreatedDate.Day)
{
recTime = recTime.AddDays(1);
continue;
}
}
if (recurringTransaction.Status.Equals("Yearly"))
{
string recTimeString = recTime.ToString("dd/MM");
string createdDateString = recurringTransaction.CreatedDate.ToString("dd/MM");
if (!recTimeString.Equals(createdDateString))
{
recTime = recTime.AddDays(1);
continue;
}
}
if (recTime > accTime && recTime <= nowTime && recTime > recurringTransaction.CreatedDate)
{
if (Instances.User == null)
{
return;
}
await Task.Run(() => transactionRepository.AddTransaction(new Transaction
{
Name = recurringTransaction.Name,
UserID = recurringTransaction.UserID,
ContactID = recurringTransaction.ContactID,
Type = recurringTransaction.Type,
Amount = recurringTransaction.Amount,
Note = recurringTransaction.Note,
CreatedDate = recTime
}));
bw_recurring.ReportProgress(1, "New transaction has been added!");
}
recTime = recTime.AddDays(1);
}
}
}
public void TransactionRepository_SaveWithouthAccount()
{
try
{
var recurringTransactionDataAccessMock = new RecurringTransactionDataAccessMock();
var repository = new RecurringTransactionRepository(recurringTransactionDataAccessMock);
var transaction = new RecurringTransaction
{
Amount = 20,
AmountWithoutExchange = 20
};
repository.Save(transaction);
}
catch (InvalidDataException)
{
return;
}
catch (Exception)
{
Assert.Fail("wrong exception.");
}
Assert.Fail("No excpetion thrown");
}
