public void Transact_Sucess()
{
//Arrange
_transactionController.ControllerContext.HttpContext = new DefaultHttpContext();
_transactionController.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, "1")
}, "someAuthTypeName"))
}
};
TransactionRequestViewModel request = new TransactionRequestViewModel()
{
Amount = 10,
TransactionType = 1
};
_transactionManagerMock.Setup(x => x.Deposit(request));
//Act
var result = _transactionController.Transact(request);
var redirectResult = (RedirectToActionResult)result;
//Assert
Assert.True(redirectResult.ControllerName == "Home");
Assert.True(redirectResult.ActionName == "Index");
}
public IActionResult Transact(TransactionRequestViewModel model)
{
model.AccountId = long.Parse(((System.Security.Claims.ClaimsIdentity)User.Identity).FindFirst(ClaimTypes.NameIdentifier).Value);
if (ModelState.IsValid)
{
try
{
if (model.TransactionType == (int)TransactionType.Deposit)
{
_transactionManager.Deposit(model);
}
if (model.TransactionType == (int)TransactionType.Withdraw)
{
_transactionManager.Withdraw(model);
}
if (model.TransactionType == (int)TransactionType.Transfer)
{
_transactionManager.Transfer(model);
}
return(RedirectToAction("Index", "Home"));
}
catch (AppException app)
{
ModelState.AddModelError(string.Empty, app.Message);
}
}
return(RedirectToAction("Index", "Transaction"));
}
public void Deposit(TransactionRequestViewModel request)
{
Log.Information("Start - Deposit request to Account Id {0}", request.AccountId);
TransactionOptions options = new TransactionOptions
{
IsolationLevel = IsolationLevel.ReadCommitted
};
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
{
var account = _accountRepository.GetById(request.AccountId);
account.Balance += request.Amount;
_accountRepository.Update(account);
_transactionRepository.Insert(new TransactionLogEntity()
{
Amount = request.Amount,
TransactionDate = DateTime.Now,
TransactionType = request.TransactionType,
AccountId = request.AccountId,
});
scope.Complete();
}
Log.Information("End - Deposit request to Account Id {0}", request.AccountId);
}
public void Withdraw(TransactionRequestViewModel request)
{
Log.Information("Start - Withdraw request to Account Id {0}", request.AccountId);
var accountEntity = _accountRepository.GetById(request.AccountId);
if (accountEntity.Balance < request.Amount)
{
CommonHelper.ThrowAppException("Insufficient funds");
}
TransactionOptions options = new TransactionOptions
{
IsolationLevel = IsolationLevel.ReadCommitted
};
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
{
accountEntity.Balance -= request.Amount;
_accountRepository.Update(accountEntity);
_transactionRepository.Insert(new TransactionLogEntity()
{
Amount = request.Amount,
TransactionDate = DateTime.Now,
TransactionType = request.TransactionType,
AccountId = request.AccountId,
});
scope.Complete();
}
Log.Information("End - Withdraw request to Account Id {0}", request.AccountId);
}
public void Transfer(TransactionRequestViewModel request)
{
Log.Information("Start - Transfer request from Account Id {0} to Account Number {1} ", request.AccountId, request.ReceiverAccountNumber);
AccountEntity destinationAccount = new AccountEntity();
if (!string.IsNullOrEmpty(request.ReceiverAccountNumber))
{
destinationAccount = _accountRepository.GetByAccountNumber(request.ReceiverAccountNumber);
}
if (destinationAccount == null || destinationAccount.Id == 0)
{
CommonHelper.ThrowAppException("Destination account number does not exist.");
}
if (destinationAccount.Id == request.AccountId)
{
CommonHelper.ThrowAppException("Invalid destination account.");
}
var sourceAccount = _accountRepository.GetById(request.AccountId);
if (sourceAccount.Balance < request.Amount)
{
CommonHelper.ThrowAppException("Insufficient funds");
}
sourceAccount.Balance -= request.Amount;
destinationAccount.Balance += request.Amount;
TransactionOptions options = new TransactionOptions
{
IsolationLevel = IsolationLevel.ReadCommitted
};
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, options))
{
_accountRepository.Update(sourceAccount);
_accountRepository.Update(destinationAccount);
_transactionRepository.Insert(new TransactionLogEntity()
{
Amount = request.Amount,
TransactionDate = DateTime.Now,
TransactionType = request.TransactionType,
AccountId = request.AccountId,
DestinationAccountId = destinationAccount.Id
});
scope.Complete();
}
Log.Information("End - Transfer request from Account Id {0} to Account Number {1} ", request.AccountId, request.ReceiverAccountNumber);
}
public static Models.Transaction ToTransaction(this TransactionRequestViewModel transactionRequestViewModel)
{
return(new Models.Transaction()
{
To = transactionRequestViewModel.To,
From = transactionRequestViewModel.From,
Id = transactionRequestViewModel.Id,
UserId = transactionRequestViewModel.UserId,
Validated = transactionRequestViewModel.Validated,
Value = transactionRequestViewModel.Value,
AddedAt = DateTime.Now,
InvoiceId = transactionRequestViewModel.InvoiceId
});
}
public async Task <IActionResult> AddTransaction(TransactionRequestViewModel transactionRequestViewModel)
{
try
{
await _transactionRepository.AddTransaction(transactionRequestViewModel.ToTransaction());
}
catch (Exception)
{
return(BadRequest(new ErrorResponseViewModel()
{
Id = (int)ErrorResponseIds.InvalidTransaction, Message = "Invalid Transaction"
}));
}
return(Ok(true));
}
public async Task <ActionResult> PayInvoice(PayInvoiceRequestViewModel payInvoiceRequestViewModel)
{
try
{
var userId = User.Claims.Where(x => x.Type.Contains("primarysid")).Select(x => x).First().Value;
await _userService.ModifyBalance(new UpdateBalanceRequestViewModel()
{
Id = userId,
Value = -payInvoiceRequestViewModel.Value
});
switch (payInvoiceRequestViewModel.Provider)
{
case PaymentUserType.InternEON:
await _utilityService.PayEON(payInvoiceRequestViewModel);
break;
case PaymentUserType.InternElectrica:
await _utilityService.PayElectrica(payInvoiceRequestViewModel);
break;
default:
throw new ArgumentOutOfRangeException();
}
var transaction = new TransactionRequestViewModel()
{
From = PaymentUserType.Me.ToString(),
To = payInvoiceRequestViewModel.Provider.ToString(),
UserId = userId,
Validated = false,
Value = payInvoiceRequestViewModel.Value,
InvoiceId = payInvoiceRequestViewModel.InvoiceId
};
var ok = await _transactionService.AddTransaction(transaction);
return(RedirectToAction("Index", "Home"));
}
catch (Exception e)
{
ModelState.AddModelError("error", e.Message);
return(View("Pay"));
}
}
public IActionResult GetTransaction([FromBody] TransactionRequestViewModel viewModel)
{
if (viewModel.Token.Equals("xr::ETH"))
{
var getTransactionETHResponse = xrouterService.xrGetTransaction <BlocknetLib.Services.Coins.Blocknet.Xrouter.Ethereum.GetTransactionResponse>
(viewModel.Token, viewModel.TxId, viewModel.NodeCount);
return(Ok(mapper.Map <ViewModels.Ethereum.GetTransactionResponseViewModel>(getTransactionETHResponse)));
}
if (viewModel.Token.Equals("xr::ETC"))
{
var getTransactionETCResponse = xrouterService.xrGetTransaction <BlocknetLib.Services.Coins.Blocknet.Xrouter.EthereumClassic.GetTransactionResponse>
(viewModel.Token, viewModel.TxId, viewModel.NodeCount);
return(Ok(mapper.Map <ViewModels.EthereumClassic.GetTransactionResponseViewModel>(getTransactionETCResponse)));
}
if (viewModel.Token.Equals("xr::NEO"))
{
var getTransactionNEOResponse = xrouterService.xrGetTransaction <BlocknetLib.Services.Coins.Blocknet.Xrouter.Neo.GetTransactionResponse>
(viewModel.Token, viewModel.TxId, viewModel.NodeCount);
return(Ok(mapper.Map <ViewModels.Neo.GetTransactionResponseViewModel>(getTransactionNEOResponse)));
}
if (viewModel.Token.Equals("xr::XMR"))
{
var getTransactionXMRResponse = xrouterService.xrGetTransaction <BlocknetLib.Services.Coins.Blocknet.Xrouter.Monero.GetTransactionResponse>
(viewModel.Token, viewModel.TxId, viewModel.NodeCount);
return(Ok(mapper.Map <ViewModels.Monero.GetTransactionResponseViewModel>(getTransactionXMRResponse)));
}
var transactionResponse = xrouterService.xrGetTransaction <BlocknetLib.Services.Coins.Blocknet.Xrouter.BitcoinBased.GetTransactionsResponse>
(viewModel.Token, viewModel.TxId, viewModel.NodeCount);
return(Ok(mapper.Map <ViewModels.BitcoinBased.TransactionResponseViewModel>(transactionResponse)));
}
public async Task <ActionResult> Deposit(PaymentRequestViewModel paymentRequestViewModel)
{
try
{
var userId = User.Claims.Where(x => x.Type.Contains("primarysid")).Select(x => x).First().Value;
var transaction = new TransactionRequestViewModel()
{
From = PaymentUserType.ExternalAccount.ToString(),
To = PaymentUserType.Me.ToString(),
UserId = userId,
Validated = true,
Value = paymentRequestViewModel.Value
};
var ok = await _transactionService.AddTransaction(transaction);
if (!ok)
{
return(View());
}
var model = new UpdateBalanceRequestViewModel()
{
Value = paymentRequestViewModel.Value,
Id = userId
};
await _userService.ModifyBalance(model);
return(RedirectToAction("Index", "Home"));
}
catch (Exception e)
{
ModelState.AddModelError("error", e.Message);
return(View());
}
}
public async Task <bool> AddTransaction(TransactionRequestViewModel transactionRequestViewModel)
{
var url = $"{_configuration["TransactionAPIUrl"]}/api/Transaction";
try
{
var responseString = await HTTPRequestSender.PostAsync(url, transactionRequestViewModel);
var responseUser = JsonConvert.DeserializeObject <bool>(responseString);
return(responseUser);
}
catch (Exception e)
{
var errorResponse = JsonConvert.DeserializeObject <ErrorResponseViewModel>(e.Message);
if (errorResponse.Id == (int)ErrorResponseIds.UserInvalid)
{
throw new UserNotFoundException();
}
throw;
}
}
public IActionResult Index()
{
TransactionRequestViewModel model = new TransactionRequestViewModel();
return(View(model));
}
