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