public void When_transferring_inside_bank_cant_take_more_money_than_balance_on_account()
{
var model = new TransferThisBankTransactionViewModel
{
Date = DateTime.Now,
Type = "Debit",
Operation = "Remittance to Another Account",
FromAccountId = 1,
OldAccountBalance = 1000,
Bank = "Bitcoin Bank",
ToAccountId = 2,
Amount = 2000
};
var expectedErrorMessage = "Insufficient funds on account to perform the transaction.";
var newModel = sut.CheckTransferThisBankModelIsOkAndReturnViewmodel(model);
Assert.AreEqual(expectedErrorMessage, newModel.ErrorMessageViewModel.ErrorMessage);
}
public TransferThisBankTransactionViewModel CreateTransferThisBankTransactionViewModel(int accountId)
{
var account = _accountsRepository.GetOneByID(accountId);
var oldBalance = _accountServices.GetBalanceOnAccount(account);
var model = new TransferThisBankTransactionViewModel()
{
Date = DateTime.Now,
Type = "Debit",
Operation = "Remittance to Another Account",
FromAccountId = accountId,
OldAccountBalance = oldBalance,
Bank = "Bitcoin Bank"
};
model.ErrorMessageViewModel = new ErrorMessageViewModel()
{
ErrorMessage = ""
};
return(model);
}
public IActionResult TransferThisBank(TransferThisBankTransactionViewModel model)
{
bool ok = true;
if (!ModelState.IsValid || !ok)
{
ModelState.AddModelError(string.Empty, "Please fill in all the required fields.");
var newModel = _viewmodelsServices.CreateTransferThisBankTransactionViewModel(model.FromAccountId);
return(View(newModel));
}
//This validation was originally in CheckTransferThisBankModelIsOkAndReturnViewmodel with the others, but because of unittesting-error I moved it here
if (!_transactionServices.ToAccountExistInThisBank(model.ToAccountId))
{
model.ErrorMessageViewModel = new ErrorMessageViewModel()
{
ErrorMessage = "No such account exists. Enter the Account ID you want to transfer to."
};
return(View(model));
}
model = _transactionServices.CheckTransferThisBankModelIsOkAndReturnViewmodel(model);
if (model.ErrorMessageViewModel.ErrorMessage != "")
{
return(View(model));
}
_transactionServices.CreateTransferThisBankFromAccountTransaction(model);
_transactionServices.CreateTransferThisBankToAccountTransaction(model);
return(View("SuccessConfirmation"));
}
public void CreateTransferThisBankToAccountTransaction(TransferThisBankTransactionViewModel model)
{
var targetAccount = _accountsRepository.GetOneByID(model.ToAccountId);
var oldTargetBalance = _accountServices.GetBalanceOnAccount(targetAccount);
var newTargetBalance = oldTargetBalance + model.Amount;
var newTargetTransaction = new Transactions()
{
AccountId = model.ToAccountId,
Date = model.Date,
Type = "Credit",
Operation = "Collection from Another Account",
Amount = model.Amount,
Balance = newTargetBalance,
Symbol = model.Symbol,
Bank = model.Bank,
Account = model.FromAccountId.ToString(),
};
_transactionsRepository.Create(newTargetTransaction);
targetAccount.Balance = newTargetBalance;
_accountsRepository.Update(targetAccount);
}
public void CreateTransferThisBankFromAccountTransaction(TransferThisBankTransactionViewModel model)
{
var account = _accountsRepository.GetOneByID(model.FromAccountId);
var oldBalance = model.OldAccountBalance;
var newBalance = oldBalance - model.Amount;
var newTransaction = new Transactions()
{
AccountId = model.FromAccountId,
Date = model.Date,
Type = model.Type,
Operation = model.Operation,
Amount = -model.Amount,
Balance = newBalance,
Symbol = model.Symbol,
Bank = model.Bank,
Account = model.ToAccountId.ToString(),
};
_transactionsRepository.Create(newTransaction);
account.Balance = newBalance;
_accountsRepository.Update(account);
}
public void Transfer_within_bank_transactions_are_created_ok()
{
List <Accounts> accounts = ctx.Accounts.ToList();
var fromAccount = accounts[0];
fromAccount.Balance = 1000;
ctx.Accounts.Update(fromAccount);
ctx.SaveChanges();
var toAccount = accounts[1];
var oldToAccountBalance = toAccount.Balance;
var model = new TransferThisBankTransactionViewModel
{
Date = DateTime.Now.Date,
OldAccountBalance = fromAccount.Balance,
Type = "Debit",
Operation = "Remittance to Another Account",
Amount = 500,
FromAccountId = fromAccount.AccountId,
Symbol = null,
Bank = "Bitcoin Bank",
ToAccountId = toAccount.AccountId
};
var expectedFromTransaction = new Transactions
{
AccountId = model.FromAccountId,
Date = model.Date,
Balance = model.OldAccountBalance - model.Amount,
Type = model.Type,
Operation = model.Operation,
Amount = -model.Amount,
Symbol = model.Symbol,
Bank = model.Bank,
Account = toAccount.AccountId.ToString()
};
var expectedToTransaction = new Transactions
{
AccountId = model.ToAccountId,
Date = model.Date,
Balance = oldToAccountBalance + model.Amount,
Type = "Credit",
Operation = "Collection from Another Account",
Amount = model.Amount,
Symbol = model.Symbol,
Bank = model.Bank,
Account = model.FromAccountId.ToString()
};
sut.CreateTransferThisBankFromAccountTransaction(model);
sut.CreateTransferThisBankToAccountTransaction(model);
IQueryable <Transactions> transactions = ctx.Transactions;
var toTransactionID = transactions.Max(x => x.TransactionId);
var createdToTransaction = transactions.Where(x => x.TransactionId == toTransactionID).FirstOrDefault();
var fromTransactionID = toTransactionID - 1;
var createdFromTransaction = transactions.Where(x => x.TransactionId == fromTransactionID).FirstOrDefault();
Assert.AreEqual(expectedFromTransaction.AccountId, createdFromTransaction.AccountId);
Assert.AreEqual(expectedFromTransaction.Date, createdFromTransaction.Date);
Assert.AreEqual(expectedFromTransaction.Balance, createdFromTransaction.Balance);
Assert.AreEqual(expectedFromTransaction.Type, createdFromTransaction.Type);
Assert.AreEqual(expectedFromTransaction.Operation, createdFromTransaction.Operation);
Assert.AreEqual(expectedFromTransaction.Amount, createdFromTransaction.Amount);
Assert.AreEqual(expectedFromTransaction.Symbol, createdFromTransaction.Symbol);
Assert.AreEqual(expectedFromTransaction.Bank, createdFromTransaction.Bank);
Assert.AreEqual(expectedFromTransaction.Account, createdFromTransaction.Account);
Assert.AreEqual(expectedToTransaction.AccountId, createdToTransaction.AccountId);
Assert.AreEqual(expectedToTransaction.Date, createdToTransaction.Date);
Assert.AreEqual(expectedToTransaction.Balance, createdToTransaction.Balance);
Assert.AreEqual(expectedToTransaction.Type, createdToTransaction.Type);
Assert.AreEqual(expectedToTransaction.Operation, createdToTransaction.Operation);
Assert.AreEqual(expectedToTransaction.Amount, createdToTransaction.Amount);
Assert.AreEqual(expectedToTransaction.Symbol, createdToTransaction.Symbol);
Assert.AreEqual(expectedToTransaction.Bank, createdToTransaction.Bank);
Assert.AreEqual(expectedToTransaction.Account, createdToTransaction.Account);
}
public TransferThisBankTransactionViewModel CheckTransferThisBankModelIsOkAndReturnViewmodel(TransferThisBankTransactionViewModel viewModel)
{
if (!IsToAccountOk(viewModel.ToAccountId, viewModel.FromAccountId))
{
viewModel.ErrorMessageViewModel = new ErrorMessageViewModel()
{
ErrorMessage = "Enter the Account ID you want to transfer money to."
};
return(viewModel);
}
if (!IsAmountOk(viewModel.Amount))
{
viewModel.ErrorMessageViewModel = new ErrorMessageViewModel()
{
ErrorMessage = "The amount entered cannot be negative or 0."
};
return(viewModel);
}
if (!IsDateOk(viewModel.Date))
{
viewModel.ErrorMessageViewModel = new ErrorMessageViewModel()
{
ErrorMessage = "You cannot make a transaction in the past."
};
return(viewModel);
}
if (!IsBalanceEnough(viewModel.Amount, viewModel.OldAccountBalance))
{
viewModel.ErrorMessageViewModel = new ErrorMessageViewModel()
{
ErrorMessage = "Insufficient funds on account to perform the transaction."
};
return(viewModel);
}
viewModel.ErrorMessageViewModel = new ErrorMessageViewModel()
{
ErrorMessage = ""
};
return(viewModel);
}
