public void Serialization()
{
const string id = "1234567890";
var asset = Asset.BTC;
const decimal amount = 1.23m;
const long timestamp = 1234567890;
const WithdrawalStatus status = WithdrawalStatus.Completed;
const string address = "0x12345678901234567890";
const string addressTag = "ABCDEF";
const string txId = "21436587092143658709";
var withdrawal = new Withdrawal(id, asset, amount, timestamp, status, address, addressTag, txId);
var json = JsonConvert.SerializeObject(withdrawal);
withdrawal = JsonConvert.DeserializeObject <Withdrawal>(json);
Assert.Equal(id, withdrawal.Id);
Assert.Equal(asset, withdrawal.Asset);
Assert.Equal(amount, withdrawal.Amount);
Assert.Equal(timestamp, withdrawal.Timestamp);
Assert.Equal(status, withdrawal.Status);
Assert.Equal(address, withdrawal.Address);
Assert.Equal(addressTag, withdrawal.AddressTag);
Assert.Equal(txId, withdrawal.TxId);
}
public void Serialization()
{
const string id = "1234567890";
var asset = Asset.BTC;
const decimal amount = 1.23m;
var time = DateTimeOffset.FromUnixTimeMilliseconds(DateTime.UtcNow.ToTimestamp()).UtcDateTime;
const WithdrawalStatus status = WithdrawalStatus.Completed;
const string address = "0x12345678901234567890";
const string addressTag = "ABCDEF";
const string txId = "21436587092143658709";
var withdrawal = new Withdrawal(id, asset, amount, time, status, address, addressTag, txId);
var json = JsonConvert.SerializeObject(withdrawal);
withdrawal = JsonConvert.DeserializeObject <Withdrawal>(json);
Assert.Equal(id, withdrawal.Id);
Assert.Equal(asset, withdrawal.Asset);
Assert.Equal(amount, withdrawal.Amount);
Assert.Equal(time, withdrawal.Time);
Assert.Equal(status, withdrawal.Status);
Assert.Equal(address, withdrawal.Address);
Assert.Equal(addressTag, withdrawal.AddressTag);
Assert.Equal(txId, withdrawal.TxId);
}
/// <summary>
/// Get withdrawal history for an asset
/// </summary>
/// <param name="asset">string of asset</param>
/// <param name="status">withdrawal status (default all)</param>
/// <param name="startTime">Start of date range</param>
/// <param name="endTime">End of date range</param>
/// <returns>Array of withdrawal</returns>
public async Task <Withdrawal[]> GetWithdrawalHistory(string asset, WithdrawalStatus status, DateTime startTime, DateTime endTime)
{
var start = _dtHelper.UTCtoUnixTime(startTime);
var end = _dtHelper.UTCtoUnixTime(endTime);
return(await OnGetWithdrawalHistory(asset, (int)status, start, end, 0));
}
private string GetEnumDescription(WithdrawalStatus status)
{
var type = typeof(WithdrawalStatus);
var memInfo = type.GetMember(status.ToString());
var attributes = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
if (attributes.Any())
{
return(((DescriptionAttribute)attributes[0]).Description);
}
return("");
}
public WithdrawalReverted(
Guid wdId,
decimal amount,
DateTimeOffset dtCrated,
Guid uId,
Guid wdmadeBy,
WithdrawalStatus status,
string remark,
string transactionNumb,
string actorname = null) : base(wdId, amount, dtCrated, uId, wdmadeBy, status, remark, transactionNumb, actorname)
{
}
public WithdrawalResponseData(string paymentMethod, string asset, List <LedgerEntryData> ledgerEntries, string withdrawalId, string accountId,
string custodianCode, WithdrawalStatus status, DateTimeOffset createdTime, string targetAddress, string transactionId)
{
PaymentMethod = paymentMethod;
Asset = asset;
LedgerEntries = ledgerEntries;
WithdrawalId = withdrawalId;
AccountId = accountId;
CustodianCode = custodianCode;
TargetAddress = targetAddress;
TransactionId = transactionId;
Status = status;
CreatedTime = createdTime;
}
private void SetWithdrawalProperties(OfflineWithdraw withdrawal, WithdrawalStatus status)
{
_paymentRepository.OfflineWithdraws.Add(withdrawal);
withdrawal.Amount = 1000;
withdrawal.Id = _observedWithdrawalId;
withdrawal.PlayerBankAccount =
_paymentRepository.PlayerBankAccounts
.Include(x => x.Player)
.First(x => x.Player.Id == _player.Id);
withdrawal.Status = status;
_paymentRepository.SaveChanges();
}
public void Throws()
{
const string id = "1234567890";
var asset = Asset.BTC;
const decimal amount = 1.23m;
var time = DateTimeOffset.FromUnixTimeMilliseconds(DateTime.UtcNow.ToTimestamp()).UtcDateTime;
const WithdrawalStatus status = WithdrawalStatus.Completed;
const string address = "0x12345678901234567890";
Assert.Throws <ArgumentNullException>("id", () => new Withdrawal(null, asset, amount, time, status, address));
Assert.Throws <ArgumentNullException>("asset", () => new Withdrawal(id, null, amount, time, status, address));
Assert.Throws <ArgumentException>("amount", () => new Withdrawal(id, asset, -1, time, status, address));
Assert.Throws <ArgumentException>("amount", () => new Withdrawal(id, asset, 0, time, status, address));
Assert.Throws <ArgumentNullException>("address", () => new Withdrawal(id, asset, amount, time, status, null));
Assert.Throws <ArgumentNullException>("address", () => new Withdrawal(id, asset, amount, time, status, string.Empty));
}
public Withdrawal(long id, string brokerId, string clientId, string walletId, string transactionId,
decimal amount,
string assetSymbol, string comment, string integration, string txid, WithdrawalStatus status,
string matchingEngineId, string lastError, int retriesCount, DateTime eventDate, string toAddress,
string clientIp, string clientLang, DateTime notificationTime, WithdrawalWorkflowState workflowState,
decimal feeAmount, string feeAssetSymbol, decimal actualFee, string actualFeeAssetSymbol, bool isInternal,
string destinationWalletId, string destinationClientId, MEErrorCode meErrorCode, string refundTransactionId,
bool cancelling, string feeRefundTransactionId, string blockchain, string externalSystemId, string toTag, decimal assetIndexPrice, string signature, long signaturedIssuedAt)
{
Id = id;
BrokerId = brokerId;
ClientId = clientId;
WalletId = walletId;
TransactionId = transactionId;
Amount = amount;
AssetSymbol = assetSymbol;
Comment = comment;
Integration = integration;
Txid = txid;
Status = status;
MatchingEngineId = matchingEngineId;
LastError = lastError;
RetriesCount = retriesCount;
EventDate = eventDate;
ToAddress = toAddress;
ClientIp = clientIp;
ClientLang = clientLang;
NotificationTime = notificationTime;
WorkflowState = workflowState;
FeeAmount = feeAmount;
FeeAssetSymbol = feeAssetSymbol;
ActualFee = actualFee;
ActualFeeAssetSymbol = actualFeeAssetSymbol;
IsInternal = isInternal;
DestinationWalletId = destinationWalletId;
DestinationClientId = destinationClientId;
MeErrorCode = meErrorCode;
RefundTransactionId = refundTransactionId;
Cancelling = cancelling;
FeeRefundTransactionId = feeRefundTransactionId;
Blockchain = blockchain;
ExternalSystemId = externalSystemId;
ToTag = toTag;
AssetIndexPrice = assetIndexPrice;
Signature = signature;
SignatureIssuedAt = signaturedIssuedAt;
}
public void Throws()
{
const string id = "1234567890";
var asset = Asset.BTC;
const decimal amount = 1.23m;
const long timestamp = 1234567890;
const WithdrawalStatus status = WithdrawalStatus.Completed;
const string address = "0x12345678901234567890";
Assert.Throws <ArgumentNullException>("id", () => new Withdrawal(null, asset, amount, timestamp, status, address));
Assert.Throws <ArgumentNullException>("asset", () => new Withdrawal(id, null, amount, timestamp, status, address));
Assert.Throws <ArgumentException>("amount", () => new Withdrawal(id, asset, -1, timestamp, status, address));
Assert.Throws <ArgumentException>("amount", () => new Withdrawal(id, asset, 0, timestamp, status, address));
Assert.Throws <ArgumentException>("timestamp", () => new Withdrawal(id, asset, amount, -1, status, address));
Assert.Throws <ArgumentException>("timestamp", () => new Withdrawal(id, asset, amount, 0, status, address));
Assert.Throws <ArgumentNullException>("address", () => new Withdrawal(id, asset, amount, timestamp, status, null));
Assert.Throws <ArgumentNullException>("address", () => new Withdrawal(id, asset, amount, timestamp, status, string.Empty));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="id">The ID.</param>
/// <param name="asset">The asset.</param>
/// <param name="amount">The amount.</param>
/// <param name="time">The time.</param>
/// <param name="status">The status.</param>
/// <param name="address">The address.</param>
/// <param name="addressTag">The address tag.</param>
/// <param name="txId">The transaction ID.</param>
public Withdrawal(string id, string asset, decimal amount, DateTime time, WithdrawalStatus status, string address, string addressTag = null, string txId = null)
{
Throw.IfNullOrWhiteSpace(id, nameof(id));
Throw.IfNullOrWhiteSpace(asset, nameof(asset));
Throw.IfNullOrWhiteSpace(address, nameof(address));
if (amount <= 0)
{
throw new ArgumentException($"{nameof(Withdrawal)}: amount must be greater than 0.", nameof(amount));
}
Id = id;
Asset = asset.FormatSymbol();
Amount = amount;
Time = time;
Status = status;
Address = address;
AddressTag = addressTag;
TxId = txId;
}
private void CancelOfflineWithdrawalRequest(WithdrawalStatus stateToGetInto)
{
_paymentTestHelper.MakeDeposit(_player.Id, 2000);
Balance.Main = 2000;
var response = _paymentTestHelper.MakeWithdraw(_player.Id, amount: 100);
_withdrawalService.Revert(response.Id, "Revert to Verification Queue");
/*
*/
//Cancel withdrawal request
if (stateToGetInto == WithdrawalStatus.Canceled)
{
_withdrawalService.Cancel(response.Id, "Cancel Withdrawal Request");
}
else if (stateToGetInto == WithdrawalStatus.Unverified)
{
_withdrawalService.Unverify(response.Id, "Unverify Withdrawal Request");
}
//Assert there's nothing in the "On Hold Queue"
var withdrawalsInTheOnHoldQueue = _withdrawalService.GetWithdrawalsOnHold();
Assert.IsEmpty(withdrawalsInTheOnHoldQueue);
//Assert there's nothing in the "Release Queue"
var withdrawalsInTheReleaseQueue = _withdrawalService.GetWithdrawalsForApproval();
Assert.IsEmpty(withdrawalsInTheReleaseQueue);
//Assert there's nothing in the "Acceptance Queue"
var withdrawalsInTheAccQueue = _withdrawalService.GetWithdrawalsForAcceptance();
Assert.IsEmpty(withdrawalsInTheAccQueue);
//Assert there's nothing in the "Verification Queue"
var withdrawalsInTheVerificationQueue = _withdrawalService.GetWithdrawalsForVerificationQueue();
Assert.IsEmpty(withdrawalsInTheVerificationQueue);
}
public WithdrawalEvent(
Guid wdId,
decimal amount,
DateTimeOffset dtCrated,
Guid uId,
Guid wdMadeBy,
WithdrawalStatus status,
string remark,
string transactionNumb,
string username = null)
{
this.WithdrawalId = wdId;
this.Amount = amount;
this.DateCreated = dtCrated;
this.UserId = uId;
this.WithdrawalMadeBy = wdMadeBy;
this.Status = status;
this.Remark = remark;
this.TransactionNumber = transactionNumb;
this.Username = username ?? EventCreatedBy;
}
public void Properties()
{
const string id = "1234567890";
var asset = Asset.BTC;
const decimal amount = 1.23m;
const long timestamp = 1234567890;
const WithdrawalStatus status = WithdrawalStatus.Completed;
const string address = "0x12345678901234567890";
const string addressTag = "ABCDEF";
const string txId = "21436587092143658709";
var withdrawal = new Withdrawal(id, asset, amount, timestamp, status, address, addressTag, txId);
Assert.Equal(id, withdrawal.Id);
Assert.Equal(asset, withdrawal.Asset);
Assert.Equal(amount, withdrawal.Amount);
Assert.Equal(timestamp, withdrawal.Timestamp);
Assert.Equal(status, withdrawal.Status);
Assert.Equal(address, withdrawal.Address);
Assert.Equal(addressTag, withdrawal.AddressTag);
Assert.Equal(txId, withdrawal.TxId);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="id">The ID.</param>
/// <param name="asset">The asset.</param>
/// <param name="amount">The amount.</param>
/// <param name="timestamp">The timestamp.</param>
/// <param name="status">The status.</param>
/// <param name="address">The address.</param>
/// <param name="addressTag">The address tag.</param>
/// <param name="txId">The transaction ID.</param>
public Withdrawal(string id, string asset, decimal amount, long timestamp, WithdrawalStatus status, string address, string addressTag = null, string txId = null)
{
Throw.IfNullOrWhiteSpace(id, nameof(id));
Throw.IfNullOrWhiteSpace(asset, nameof(asset));
Throw.IfNullOrWhiteSpace(address, nameof(address));
if (amount <= 0)
{
throw new ArgumentException($"{nameof(Withdrawal)} amount must be greater than 0.", nameof(amount));
}
if (timestamp <= 0)
{
throw new ArgumentException($"{nameof(Withdrawal)} timestamp must be greater than 0.", nameof(timestamp));
}
Id = id;
Asset = asset;
Amount = amount;
Timestamp = timestamp;
Status = status;
Address = address;
AddressTag = addressTag;
TxId = txId;
}
private void ThrowStatusError(WithdrawalStatus from, WithdrawalStatus to)
{
throw new InvalidOperationException(string.Format("The withdrawal has \"{0}\" status, so it can't be {1}", from, to));
}
/// <summary>
/// Get all withdrawal history
/// </summary>
/// <param name="status">withdrawal status (default all)</param>
/// <returns>Array of withdrawal</returns>
public async Task <Withdrawal[]> GetWithdrawalHistory(WithdrawalStatus status = WithdrawalStatus.all)
{
return(await OnGetWithdrawalHistory("", (int)status, 0, 0, 0));
}
/// <summary>
/// Get withdrawal history for an asset
/// </summary>
/// <param name="asset">string of asset</param>
/// <param name="status">withdrawal status (default all)</param>
/// <returns>Array of withdrawal</returns>
public async Task <Withdrawal[]> GetWithdrawalHistory(string asset, WithdrawalStatus status = WithdrawalStatus.all)
{
return(await OnGetWithdrawalHistory(asset, (int)status, 0, 0, 0));
}
/// <see cref="ICobinhoodClient.GetAllWithdrawals(WithdrawalStatus, string, int?, int?)"/>
public async Task <AllWithdrawalInfo> GetAllWithdrawals(string currency = "", WithdrawalStatus withdrawalStatus = WithdrawalStatus.All, int?limit = null, int?page = null)
{
var parameters = (string.IsNullOrWhiteSpace(currency) ? "" : $"currency={currency}")
+ (withdrawalStatus != WithdrawalStatus.All ? $"&status={withdrawalStatus.GetDescription()}" : "")
+ (limit.HasValue ? $"&limit={limit.Value}" : "")
+ (page.HasValue ? $"&page={page.Value}" : "");
var result = await _apiClient.CallAsync <AllWithdrawalInfo>(ApiMethod.GET, EndPoints.GetAllWithdrawals, parameters);
return(result);
}
public WithdrawalResponse(WithdrawalStatus status, string errorMessage = "")
{
Status = status;
ErrorMessage = errorMessage;
}
public void Can_withdraw_amount(decimal balance, decimal withdrawalAmount, decimal finalBalance, WithdrawalStatus expectedStatus, string expectedErrorMessage)
{
var card = new CashCard(TestPin, _pinValidationService);
card.Deposit(balance);
var response = card.Withdraw(withdrawalAmount, TestPin);
Assert.That(response.Status, Is.EqualTo(expectedStatus));
Assert.That(response.ErrorMessage, Is.EqualTo(expectedErrorMessage));
Assert.That(card.Balance, Is.EqualTo(finalBalance));
}
