public ActionResult AjaxList(WithdrawRequest request) { var create = _unityContainer.Resolve <ListWithdraws>(); var table = create.AjaxQuery(request); return(Json(new { tables = table, html = create.pageHtml })); }
public async Task <IActionResult> Withdraw( [FromBody] WithdrawRequest request, CancellationToken token) { var query = new WithdrawCommand( request.AccountNumber, request.Amount, CorrelationContext.Get()); var response = await _mediator .Send( query, token); if (!response .ValidationResult .IsValid) { var errors = string.Empty; response .ValidationResult .Errors .ToList() .ForEach(e => { errors += $"{e}//r//n"; }); return(BadRequest(errors)); } return(Ok(new WithdrawView( response.Balance))); }
public async Task Withdraw_WithIncorrectRequest_ReturnFailedTransactionsResult() { // Arrange var withdrawRequest = new WithdrawRequest { AccountIban = "TH123456", Amount = 500, }; var transactionsResult = new TransactionsResult { Success = false }; transactionsService .WithdrawAsync(Arg.Any <WithdrawRequest>()) .Returns(Task.FromResult(transactionsResult)); // Act var actionResult = await transactionsController.Withdraw(withdrawRequest); var objectResult = actionResult as OkObjectResult; // Assert Assert.NotNull(objectResult); Assert.Equal((int)System.Net.HttpStatusCode.OK, objectResult.StatusCode); Assert.False((objectResult.Value as TransactionsResult).Success); }
public IActionResult Withdraw(WithdrawRequest request) { return(this.Handle( request: request, response: _service.Withdraw(request) )); }
private static void WithdrawCurrency() { var walletClient = new WalletClient(Config.AccessKey, Config.SecretKey); _logger.Start(); var request = new WithdrawRequest { address = "" }; var result = walletClient.WithdrawCurrencyAsync(request).Result; _logger.StopAndLog(); if (result != null) { switch (result.status) { case "ok": { AppLogger.Info($"Withdraw successfully, transfer id: {result.data}"); break; } case "error": { AppLogger.Info($"Withdraw fail, error code: {result.errorCode}, error message: {result.errorMessage}"); break; } } } }
public async Task Cancel(string accountLegalEntityId, IEnumerable <ApprenticeshipIncentiveModel> apprenticeshipIncentives, string hashedAccountId, string emailAddress) { var decodedAccountLegalEntityId = _hashingService.DecodeValue(accountLegalEntityId); var url = $"withdrawals"; var serviceRequest = new ServiceRequest() { TaskId = Guid.NewGuid().ToString(), TaskCreatedDate = DateTime.UtcNow }; foreach (var apprenticeshipIncentive in apprenticeshipIncentives) { var request = new WithdrawRequest( WithdrawalType.Employer, decodedAccountLegalEntityId, apprenticeshipIncentive.Uln, serviceRequest, _hashingService.DecodeValue(hashedAccountId), emailAddress ); using var response = await _client.PostAsJsonAsync(url, request); response.EnsureSuccessStatusCode(); } }
internal WithdrawResponseContainer Withdraw(WithdrawRequest model) { var client = new RestClient { BaseUrl = new Uri(AuthInfo.BaseUrl) }; var request = new RestRequest { Resource = "Withdraw", Method = Method.POST }; var rawHash = $"{model.Amount}|{model.Currency}|{AuthInfo.MerchantId}|{model.TransactionId}|{model.Token}|{model.UserId}|{AuthInfo.PrivateKey}"; var hash = GetSha256(rawHash); model.Hash = hash; request.AddJsonBody(model); var response = client.Execute <WithdrawResponseContainer>(request); if (response.StatusCode != HttpStatusCode.OK) { throw new CantConnectToServerException(response); } return(response.Data); }
public WithdrawResponseContainer Withdraw(WithdrawRequest request) { var result = _walletRepository.Withdraw(new Internal.Wallet.DTO.WithdrawRequest() { TransactionId = request.TransactionId, UserId = request.UserId, Token = request.Token, MerchantId = _merchantAuthInfo.MerchantId, Currency = request.Currency, Amount = request.Amount }); if (200 != result.StatusCode) { return(new WithdrawResponseContainer { StatusCode = (StatusCodes)result.StatusCode }); } return(new WithdrawResponseContainer { StatusCode = (StatusCodes)result.StatusCode, Data = new WithdrawResponse { TransactionId = result.Data.TransactionId, Balance = result.Data.Balance } }); }
public WithdrawResponse Withdraw(WithdrawRequest request) { var response = new WithdrawResponse(request); try { _accountBalance.ValidateWithdraw(request.Amount); _withdrawNotesService.ValidateWithdraw(request.Amount); _accountBalance.Withdraw(request.Amount); response.Notes = _withdrawNotesService.Withdraw(request.Amount); response.IsSucceeded = true; } catch (ArgumentException ex) { response.Message = ex.Message; } catch (Exception) { throw; } return(response); }
public static TransactionModel CreateWithdrawTransaction(WithdrawRequest request, AccountModel account) => new TransactionModel( Guid.NewGuid(), DateTime.UtcNow, $"${request.Amount}.00 withdrawn from the account", account.UserID, TransactionDbEnum.Withdraw, request.Amount);
public async Task Withdraw(WithdrawRequest request) { EnsureRequestIsvalid(request); var response = await _client.PostAsJsonAsync("withdrawals", request); response.EnsureSuccessStatusCode(); }
/// <summary> /// Sends a request to withdraw to an address /// </summary> /// <param name="request"></param> /// <param name="receiveWindow"></param> /// <returns></returns> public async Task <WithdrawResponse> CreateWithdrawRequest(WithdrawRequest request, int receiveWindow = 5000) { Guard.AgainstNullOrEmpty(request.Asset); Guard.AgainstNullOrEmpty(request.Address); Guard.AgainstNull(request.Amount); return(await _apiProcessor.ProcessPostRequest <WithdrawResponse>(Endpoints.Account.Withdraw(request), receiveWindow)); }
public async Task <IActionResult> Withdraw([FromBody] WithdrawRequest message) { var request = new WithdrawCommand(message.AccountId, message.Amount); await withdrawInput.Handle(request); return(withdrawPresenter.ViewModel); }
public Task <uint256> WithdrawFundsAsync(Money amount, BitcoinAddress destination) { var req = new WithdrawRequest() { AmountSatoshi = (ulong)amount.Satoshi, DestinationAddress = destination.ToString() }; return(RequestAsync <uint256>($"/v1/wallet/{cryptoCode}/withdraw", HttpMethod.Post, req)); }
//public WithdrawRequestCreateVM(Document model) // : base(model) //{ // if (model == null) // return; // Title = model.Title; //} public virtual WithdrawRequest ToModel() { WithdrawRequest model = new WithdrawRequest() { Amount = this.amount, //StatusID = (int)WithdrawRequestStatusesEnum.Pending }; return(model); }
private void HandleWithdrawMoney(WithdrawRequest message) { if (_balance - message.Amount < 0) { throw new NegativeAccountBalanceException(); } _balance -= message.Amount; Sender.Tell(new ReceiptResponse(_balance)); }
public async Task <ActionResult <uint256> > WithdrawFunds(string cryptoCode, WithdrawRequest req, CancellationToken ct) { var n = _networkProvider.GetByCryptoCode(cryptoCode); var addr = BitcoinAddress.Create(req.DestinationAddress, n.NBitcoinNetwork); var tx = await _walletService.GetSendingTxAsync(addr, req.AmountSatoshi, n, ct); var cli = _clientProvider.GetClient(n); await cli.BroadcastAsync(tx, ct); return(CreatedAtRoute($"{cryptoCode}/withdraw", tx.GetHash())); }
public async Task <IActionResult> Withdraw([FromBody] WithdrawRequest withdrawRequest) { if (withdrawRequest == null) { return(BadRequest(ModelState)); } var transactionsResult = await transactionsService.WithdrawAsync(withdrawRequest); return(Ok(transactionsResult)); }
public WithdrawalSteps(TestContext testContext) : base(testContext) { _testContext = testContext; _fixture = new Fixture(); _withdrawRequest = new WithdrawRequest { WithdrawalType = WithdrawalType.Employer, AccountLegalEntityId = _fixture.Create <long>(), ULN = _fixture.Create <long>(), ServiceRequest = _fixture.Create <ServiceRequest>() }; }
public async Task <object> Withdraw([FromBody] WithdrawRequest request) { try { var platformId = BitcornUtils.GetPlatformId(request.Id); var user = await BitcornUtils.GetUserForPlatform(platformId, _dbContext).FirstOrDefaultAsync(); var response = new Dictionary <string, object>(); if (user != null) { var withdrawResult = await WalletUtils.Withdraw(_dbContext, _configuration, user, request.CornAddy, request.Amount, platformId.Platform); response.Add("usererror", withdrawResult.UserError); response.Add("walletavailable", withdrawResult.WalletAvailable); response.Add("txid", withdrawResult.WalletObject); if (request.Columns.Length > 0) { var columns = await UserReflection.GetColumns(_dbContext, request.Columns, new int[] { user.UserId }); if (columns.Count > 0) { foreach (var item in columns.First().Value) { response.Add(item.Key, item.Value); } } } if (withdrawResult.WalletObject != null && request.Amount > 100000) { await BitcornUtils.TxTracking(_configuration, new { txid = withdrawResult.WalletObject, time = DateTime.Now, method = "withdraw", platform = platformId.Platform, amount = request.Amount, userid = user.UserId, twitchUsername = user.UserIdentity.TwitchUsername, discordUsername = user.UserIdentity.DiscordUsername, cornaddy = request.CornAddy, }); } } return(response); } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e); throw e; } }
public async Task <TransactionsResult> WithdrawAsync(WithdrawRequest withdrawRequest) { var transactionsResult = new TransactionsResult { AccountIban = withdrawRequest.AccountIban, Amount = withdrawRequest.Amount, Success = false, ErrorMessage = string.Empty, TransactionsType = "Withdraw", TransactionsDate = DateTime.UtcNow }; if (withdrawRequest.Amount <= 0) { transactionsResult.ErrorMessage = "Withdraw amount is incorret"; return(transactionsResult); } var account = await accountRepository.GetByAccountIbanAsync(withdrawRequest.AccountIban); if (account == null) { transactionsResult.ErrorMessage = "Account does not exists"; return(transactionsResult); } if (account.Balance - withdrawRequest.Amount < 0) { transactionsResult.ErrorMessage = "Account balance less than withdraw amount"; return(transactionsResult); } account.Balance -= withdrawRequest.Amount; await accountRepository.UpdateAccountAsync(account); var withdraw = new Withdraw { WithdrawId = Guid.NewGuid(), AccountId = account.AccountId, Amount = withdrawRequest.Amount, Timestamp = DateTime.UtcNow }; await withdrawRepository.AddWithdrawAsync(withdraw); transactionsResult.Balance = account.Balance; transactionsResult.Success = true; return(transactionsResult); }
/// <summary> /// Withdraw from spot trading account to an external address. /// <para>long data // Transfer id</para> /// <para>string errorCode</para> /// <para>string errorMessage</para> /// </summary> /// <param name="request"></param> /// <returns>WithdrawCurrencyResponse</returns> public void WithdrawCurrencyAsync(WithdrawRequest request, System.Action <long, string, string> action = null) { string url = _urlBuilder.Build(POST_METHOD, "/v1/dw/withdraw/api/create"); HttpRequest.PostAsync <WithdrawCurrencyResponse>(url, request.ToJson()).ContinueWith((task) => { if (action != null) { var res = task.Result; action(res.data, res.errorCode, res.errorMessage); } }); }
public IHttpActionResult WithdrawMoney(WithdrawRequest model) { GeneralResponse oGeneralResponse = new GeneralResponse(); var claims = ClaimsPrincipal.Current.Identities.First().Claims.ToList(); string UserId = claims?.FirstOrDefault(x => x.Type.Equals(ClaimTypes.Sid, StringComparison.OrdinalIgnoreCase))?.Value; AccountManager oAccountManager = new AccountManager(); try { Account oUserAccount = oAccountManager.GetAccountById(model.AccountId); if (oUserAccount.AccountId == null) { throw new ArgumentException("El id de cuenta especificado no existe"); } if (Convert.ToString(oUserAccount.User.UserId) != UserId) { throw new ArgumentException("La cuenta especificada no pertenece al usuario logeado"); } if (model.Uncovered && model.Amount > oUserAccount.Balance * 1.1m) { throw new ArgumentException("No se puede tener un saldo descubierto mayor al 10% del saldo actual"); } if (!model.Uncovered && model.Amount > oUserAccount.Balance) { throw new ArgumentException("No tiene saldo suficiente para realizar esta transaccion"); } oAccountManager.UpdateAccountBalance(model.AccountId, -model.Amount); oGeneralResponse.Success = 1; oGeneralResponse.Message = "Exito - se ha realizado el retiro exitosamente"; return(Content(HttpStatusCode.OK, oGeneralResponse)); } catch (ArgumentException ex) { oGeneralResponse.Success = 0; oGeneralResponse.Message = "Error - " + ex.Message; return(Content(HttpStatusCode.BadRequest, oGeneralResponse)); } catch (Exception ex) { oGeneralResponse.Success = 0; oGeneralResponse.Message = "Error - " + ex.Message; return(Content(HttpStatusCode.BadRequest, oGeneralResponse)); } }
public async Task Then_WithdrawCommand_is_handled( WithdrawRequest request, [Frozen] Mock <IMediator> mockMediator, [Greedy] WithdrawalController controller) { var controllerResult = await controller.Withdraw(request) as AcceptedResult; mockMediator .Verify(mediator => mediator.Send( It.Is <WithdrawCommand>(c => c.WithdrawRequest.Equals(request)), It.IsAny <CancellationToken>())); Assert.IsNotNull(controllerResult); }
async Task FillColumns(Dictionary <string, object> response, WithdrawRequest request, User user) { if (request.Columns.Length > 0) { var columns = await UserReflection.GetColumns(_dbContext, request.Columns, new int[] { user.UserId }); if (columns.Count > 0) { foreach (var item in columns.First().Value) { response.Add(item.Key, item.Value); } } } }
public WithdrawRequestListItemForExpertAndUserVM(WithdrawRequest model) { if (model == null) { return; } id = model.ID; amount = model.Amount; amount_str = model.Amount.ToString(AppData.Configuration.NumberViewStringFormat); status = new BaseDropdownableDetailsVM(model.Status); date_created = DateTimeUtils.ConvertToString(model.DateCreated); date_completed = DateTimeUtils.ConvertToString(model.DateCompleted); }
public void WithdrawCurrencyTest(string address, string amount, string currency, string fee) { WithdrawRequest request = new WithdrawRequest() { address = address, amount = amount, currency = currency, fee = fee }; WithdrawCurrencyResponse result = client.WithdrawCurrencyAsync(request).Result; string strret = JsonConvert.SerializeObject(result, Formatting.Indented); Console.WriteLine(strret); Assert.Equal("ok", result.status); }
public async Task WithdrawAsync_WithAmountZero_ReturnTransactionsResult() { // Arrange var withdrawRequest = new WithdrawRequest { AccountIban = "TH123456", Amount = 0, }; // Act var transactionsResult = await transactionsService.WithdrawAsync(withdrawRequest); // Assert Assert.False(transactionsResult.Success); Assert.Equal("Withdraw amount is incorret", transactionsResult.ErrorMessage); }
public async Task Withdraw(WithdrawRequest withdraw) { var starting = new AccountBalance() { AccountId = this.Id.GetId(), Balance = 100m, // Start new accounts with 100, we're pretty generous. }; var balance = await this.StateManager.GetOrAddStateAsync <AccountBalance>("balance", starting); // Throws Overdraft exception if the account doesn't have enough money. var updated = this.bank.Withdraw(balance.Balance, withdraw.Amount); balance.Balance = updated; await this.StateManager.SetStateAsync("balance", balance); }
public void Query() { var request = new WithdrawRequest(); request.state = WithdrawStates.notaudit; var query = withdrawService.Query(request); if (query != null) { List = query.ModelList.Select(x => new ListWithdraw(x)).ToList(); pageHtml = MvcPage.AjaxPager((int)request.PageIndex, (int)request.PageSize, query.TotalCount); } else { List = new List <ListWithdraw>(); pageHtml = MvcPage.AjaxPager((int)request.PageIndex, (int)request.PageSize, 0); } }
/// <summary> /// <para>Withdraw a listing from Trade Me for either being sold or unsold. /// </para> /// REQUIRES AUTHENTICATION. /// </summary> /// <param name="request">The object that will be serialized into xml and then sent in a POST message.</param> /// <returns>XDocument: ListingResponse</returns> public XDocument WithdrawListedItem(WithdrawRequest request) { var query = String.Format(Constants.Culture, "{0}/{1}{2}", Constants.SELLING, Constants.WITHDRAW, Constants.XML); return _connection.Post(request, query); }
/// <summary> /// <para>Withdraw a listing from Trade Me for either being sold or unsold. /// </para> /// REQUIRES AUTHENTICATION. /// </summary> /// <param name="request">The object that will be serialized into xml and then sent in a POST message.</param> /// <returns>XDocument: ListingResponse</returns> public XDocument WithdrawListedItem(WithdrawRequest request) { if (_selling == null) { _selling = new SellingMethods(_connection); } return _selling.WithdrawListedItem(request); }