public async Task <ActionResult> TransferFundsOperation(TransferFundsViewModel transferData)
{
if (!ModelState.IsValid)
{
TempData["isError"] = true;
return(View("TransferFunds"));
}
try
{
await Task.Run(() => _accountService.TransferFunds(
sourceAccountId: transferData.FromAccountNumber,
destinationAccountId: transferData.ToAccountNumber,
transferSum: transferData.Sum));
TempData["isError"] = false;
return(RedirectToAction(nameof(this.AccountOperations)));
}
catch (Exception e)
{
ModelState.AddModelError(string.Empty, e.Message);
TempData["isError"] = true;
return(View("_TransferFunds"));
}
}
public ActionResult Transfer(TransferFundsViewModel viewModel)
{
using (var _context = new ApplicationDbContext()) {
var uId = User.Identity.GetUserId();
//creating return viewmodel
TransferFundsViewModel backViewModel = new TransferFundsViewModel {
FromAccount = _context.Accounts.Single(a => a.Id == viewModel.FromAccountId),
};
//validation
if (!ModelState.IsValid)
{
return(View("TransferFunds", backViewModel));
}
//checking balance
decimal currentBalance = _context.Accounts.Single(a => a.Id == viewModel.FromAccountId).Balance;
if (viewModel.Amount > currentBalance || viewModel.Amount < 0)
{
return(View("TransferFunds", backViewModel));
}
//making the transaction
var fromAccount = _context.Accounts.Single(a => a.Id == viewModel.FromAccountId);
var toAccount = _context.Accounts.Where(a => a.SortCode == viewModel.ToAccountSC)
.First(a => a.AccountNumber == viewModel.ToAccountAcNum);
//can only transfer to debit accounts
if (toAccount is CurrentAccount || toAccount is SavingsAccount)
{
fromAccount.Balance -= viewModel.Amount;
toAccount.Balance += viewModel.Amount;
}
else
{
return(View("TransferFunds", backViewModel));
}
//creating and adding transaction
var transaction = new Transfer {
Amount = viewModel.Amount,
BankAccountBaseId = viewModel.FromAccountId,
ToAccountId = toAccount.Id,
TransactionTimeStamp = DateTime.Now,
ToCurrentBalance = toAccount.Balance,
FromCurrentBalance = fromAccount.Balance,
Description = $"Transfer from {fromAccount.AccountNumber} to {toAccount.AccountNumber}"
};
_context.Transactions.Add(transaction);
_context.SaveChanges();
//string uId = User.Identity.GetUserId();
//user = _context.Users.Single(c => c.Id == uId);
}
return(RedirectToAction("Index", "LoggedIn"));
}
public ActionResult TransferFunds(int excludedAccountId)
{
TransferFundsViewModel tf = new TransferFundsViewModel();
tf.SourceAccountId = excludedAccountId;
return(View(tf));
}
public async Task <IActionResult> TransferTransaction(TransferFundsViewModel transferFundsModel)
{
var response = await _httpClient.PostAsync <TransactionResponse>("api/Transaction/Transfer", transferFundsModel);
if (!response.IsSuccess)
{
var errorMessage = ErrorMessageResolver.GetErrorMessage(response.ErrorCode);
return(RedirectToAction("Transfer", new { id = transferFundsModel.AccountId, err = errorMessage }));
}
return(RedirectToAction("Detail", "Account", new { id = transferFundsModel.AccountId }));
}
public ActionResult Pay(TransferFundsViewModel model)
{
using (var _context = new ApplicationDbContext()) {
//creating backviewmodel
var uId = User.Identity.GetUserId();
int aId = model.FromAccountId;
var fromAccount = _context.Accounts.Single(a => a.Id == aId);
var toAccount = _context.Accounts.Where(a => a.SortCode == model.ToAccountSC).Single(a => a.AccountNumber == model.ToAccountAcNum);
var backViewModel = new TransferFundsViewModel {
FromAccount = fromAccount,
FromAccountId = aId,
ToAccountAcNum = toAccount.AccountNumber,
ToAccountSC = toAccount.SortCode
};
//validating
if (!ModelState.IsValid)
{
return(View("PayCredit", backViewModel));
}
//checking balance
decimal currentBalance = _context.Accounts.Single(a => a.Id == model.FromAccountId).Balance;
if (model.Amount > currentBalance)
{
return(View("PayCredit", backViewModel));
}
//make the transaction
fromAccount.Balance -= model.Amount;
toAccount.Balance += model.Amount;
//creating and adding transaction
var transaction = new Transfer {
Amount = model.Amount,
BankAccountBaseId = model.FromAccountId,
ToAccountId = toAccount.Id,
TransactionTimeStamp = DateTime.Now,
ToCurrentBalance = toAccount.Balance,
FromCurrentBalance = fromAccount.Balance,
Description = $"Payment from {fromAccount.AccountNumber}"
};
_context.Transactions.Add(transaction);
_context.SaveChanges();
}
return(RedirectToAction("Index", "LoggedIn"));
}
public ActionResult TransferFunds(int accountId)
{
using (var _context = new ApplicationDbContext()) {
var fromAccount = _context.Accounts.Single(a => a.Id == accountId);
//var transfer = new Transfer {
// BankAccountBaseId = accountId
//};
var viewModel = new TransferFundsViewModel {
FromAccount = fromAccount,
FromAccountId = accountId
};
return(View(viewModel));
}
}
public ActionResult TransferFunds(TransferFundsViewModel transferFunds)
{
//Check for available funds
CheckingAccount sourceAccount = db.CheckingAccounts.Find(transferFunds.SourceAccountId);
if (sourceAccount.Balance < transferFunds.Amount)
{
ModelState.AddModelError("Amount", "Insufficient funds in source account");
}
//Check if destination account exists
CheckingAccount destAccount = db.CheckingAccounts.Where(
c => c.Id == transferFunds.DestinationAccountId).FirstOrDefault();
if (destAccount == null)
{
ModelState.AddModelError("DestinationAccountId", "Destination account does not exist");
}
if (ModelState.IsValid)
{
//Add source account transaction
Transaction srcTransaction = new Transaction();
srcTransaction.Account = sourceAccount;
srcTransaction.CheckingAccountId = sourceAccount.Id;
srcTransaction.Amount = -transferFunds.Amount; //amount to deduct
db.Transactions.Add(srcTransaction);
//Add destination account transaction
Transaction destTransaction = new Transaction();
destTransaction.Account = destAccount;
destTransaction.CheckingAccountId = destAccount.Id;
destTransaction.Amount = transferFunds.Amount;
db.Transactions.Add(destTransaction);
//Save to db and update balance for both accounts
db.SaveChanges();
var service = new CheckingAccountServices(db);
service.UpdateBalance(srcTransaction);
service.UpdateBalance(destTransaction);
return(PartialView("_TransferSuccess", transferFunds));
}
return(PartialView("_TransferForm", transferFunds));
}
public ActionResult TransferFunds()
{
//Get logged in user
var studentProfile = db.UserProfiles.Local.SingleOrDefault(u => u.UserName == User.Identity.Name)
?? db.UserProfiles.SingleOrDefault(u => u.UserName == User.Identity.Name);
//Get student account associated with logged in user
var student = db.Students.Find(studentProfile.UserId);
//Get accounts associated with student account
var accounts = db.Accounts.Where(x => x.StudentID == student.UserId);
var selectionList = new SelectList(accounts, "AccountID", "AccountName");
var vm = new TransferFundsViewModel {
ListOfSourceAccounts = selectionList, ListOfDestinationAccounts = selectionList
};
return(View(vm));
}
public ActionResult TransferFunds(TransferFundsViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
AccountManager manager = new AccountManager();
Account srcAccount = db.Accounts.Find(viewModel.SelectedSourceAccountId);
Account destAccount = db.Accounts.Find(viewModel.SelectedDestinationAccountId);
manager.TransferMoney(srcAccount, destAccount, viewModel.TransferAmount);
db.SaveChanges();
}
catch (DataException)
{
ModelState.AddModelError("", "Something went wrong, transfer could not be completed.");
}
}
return(RedirectToAction("AccountSummary"));
}
public ActionResult PayMortgage(int accountId)
{
using (var _context = new ApplicationDbContext()) {
var uId = User.Identity.GetUserId();
var fromAccount = _context.Accounts.Single(a => a.Id == accountId);
var toACcount = _context.Accounts.Where(a => a.Type == "Mortgage Account").Single(a => a.ApplicationUserId == uId);
//var transfer = new Transfer {
// BankAccountBaseId = accountId
//};
var viewModel = new TransferFundsViewModel {
FromAccount = fromAccount,
FromAccountId = accountId,
ToAccountAcNum = toACcount.AccountNumber,
ToAccountSC = toACcount.SortCode
};
return(View("PayCredit", viewModel));
}
}
