// GET: Transaction
public ActionResult Index(int Id, string Type)
{
if (Type == "D")
{
return(View("Deposit", new Transaction {
AccountId = Id
}));
}
if (Type == "W")
{
return(View("Withdrawal", new Transaction {
AccountId = Id
}));
}
if (Type == "T")
{
var userId = _context.Accounts.Where(a => a.Id == Id).Select(a => new { a.UserId }).Single();
List <Account> accounts = _context.Accounts.Where(a => a.UserId == userId.UserId).Where(a => a.Id != Id).ToList();
TransferTransactionViewModel transferTransactionViewModel = new TransferTransactionViewModel
{
Accounts = accounts,
Transaction = new Transaction {
AccountId = Id
}
};
return(View("Transfer", transferTransactionViewModel));
}
return(View());
}
public void Transfer_to_other_bank_transaction_is_created_ok()
{
List <Accounts> accounts = ctx.Accounts.ToList();
var fromAccount = accounts[0];
fromAccount.Balance = 1000;
ctx.Accounts.Update(fromAccount);
ctx.SaveChanges();
var model = new TransferTransactionViewModel
{
Date = DateTime.Now.Date,
OldAccountBalance = fromAccount.Balance,
Type = "Debit",
Operation = "Remittance to Another Bank",
Amount = 500,
FromAccountId = fromAccount.AccountId,
Symbol = null,
Bank = null,
ToAccount = null
};
var expectedTransaction = 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 = model.ToAccount
};
sut.CreateTransferToOtherBankTransaction(model);
IQueryable <Transactions> transactions = ctx.Transactions;
var transactionID = transactions.Max(x => x.TransactionId);
var createdTransaction = transactions.Where(x => x.TransactionId == transactionID).FirstOrDefault();
Assert.AreEqual(expectedTransaction.AccountId, createdTransaction.AccountId);
Assert.AreEqual(expectedTransaction.Date, createdTransaction.Date);
Assert.AreEqual(expectedTransaction.Balance, createdTransaction.Balance);
Assert.AreEqual(expectedTransaction.Type, createdTransaction.Type);
Assert.AreEqual(expectedTransaction.Operation, createdTransaction.Operation);
Assert.AreEqual(expectedTransaction.Amount, createdTransaction.Amount);
Assert.AreEqual(expectedTransaction.Symbol, createdTransaction.Symbol);
Assert.AreEqual(expectedTransaction.Bank, createdTransaction.Bank);
Assert.AreEqual(expectedTransaction.Account, createdTransaction.Account);
}
public ActionResult Transfer(TransferTransactionViewModel transferTransaction)
{
if (transferTransaction.Transfer.TargetAccount == 0 || transferTransaction.Transaction.Amount == 0)
{
badTransfer = true;
TempData["message"] = "Transfer information incomplete";
}
//Fetch account and check if funds sufficient for withdrawal
var account = _context.Accounts.Single(a => a.Id == transferTransaction.Transaction.AccountId);
//If insufficient funds give chance to try again
if (transferTransaction.Transaction.Amount > account.Balance)
{
badTransfer = true;
TempData["message"] = "Insufficient funds for a tranfer of $" + transferTransaction.Transaction.Amount;
}
if (badTransfer)
{
List <Account> accounts = _context.Accounts.Where(a => a.UserId == account.UserId).Where(a => a.Id != transferTransaction.Transaction.AccountId).ToList();
transferTransaction.Accounts = accounts;
return(View(transferTransaction));
}
transferTransaction.Transaction.Type = "T";
_context.Transactions.Add(transferTransaction.Transaction);
_context.SaveChanges();
transferTransaction.Transfer.TransactionID = transferTransaction.Transaction.Id;
_context.Transfers.Add(transferTransaction.Transfer);
_context.SaveChanges();
//Fetch source account and decrement balance by the transfer amount
var account2 = _context.Accounts.SingleOrDefault(a => a.Id == transferTransaction.Transaction.AccountId);
account2.Balance = account2.Balance - transferTransaction.Transaction.Amount;
_context.SaveChanges();
//Fetch traget account and increment balance by the transfer amount
var account3 = _context.Accounts.SingleOrDefault(a => a.Id == transferTransaction.Transfer.TargetAccount);
account3.Balance = account3.Balance + transferTransaction.Transaction.Amount;
_context.SaveChanges();
return(RedirectToAction("Index", "Account", new { Id = account.UserId }));
}
public void When_transferring_outside_bank_cant_take_more_money_than_balance_on_account()
{
var model = new TransferTransactionViewModel
{
Date = DateTime.Now,
Type = "Debit",
Operation = "Remittance to Another Bank",
FromAccountId = 1,
OldAccountBalance = 1000,
Bank = "Bitcoin Bank",
ToAccount = "1234",
Amount = 2000
};
var expectedErrorMessage = "Insufficient funds on account to perform the transaction.";
var newModel = sut.CheckTransferOtherBankModelIsOkAndReturnViewmodel(model);
Assert.AreEqual(expectedErrorMessage, newModel.ErrorMessageViewModel.ErrorMessage);
}
public TransferTransactionViewModel CreateTransferViewModel(int accountId)
{
var account = _accountsRepository.GetOneByID(accountId);
var oldBalance = _accountServices.GetBalanceOnAccount(account);
var model = new TransferTransactionViewModel()
{
Date = DateTime.Now,
Type = "Debit",
Operation = "Remittance to Another Bank",
FromAccountId = accountId,
OldAccountBalance = oldBalance,
};
model.ErrorMessageViewModel = new ErrorMessageViewModel()
{
ErrorMessage = ""
};
return(model);
}
public IActionResult TransferOtherBank(TransferTransactionViewModel model)
{
bool ok = true;
if (!ModelState.IsValid || !ok)
{
ModelState.AddModelError(string.Empty, "Please fill in all the required fields.");
var newModel = _viewmodelsServices.CreateTransferViewModel(model.FromAccountId);
return(View(newModel));
}
model = _transactionServices.CheckTransferOtherBankModelIsOkAndReturnViewmodel(model);
if (model.ErrorMessageViewModel.ErrorMessage != "")
{
return(View(model));
}
_transactionServices.CreateTransferToOtherBankTransaction(model);
return(View("SuccessConfirmation"));
}
public void CreateTransferToOtherBankTransaction(TransferTransactionViewModel 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.ToAccount,
};
_transactionsRepository.Create(newTransaction);
account.Balance = newBalance;
_accountsRepository.Update(account);
}
public TransferTransactionViewModel CheckTransferOtherBankModelIsOkAndReturnViewmodel(TransferTransactionViewModel 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);
}
