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)); }