public static void Balance(string apiurl)
{
BalanceRequest request = new BalanceRequest
{
Account = "账号",
Pwd = "接口密码",
};
StringBuilder arge = new StringBuilder();
arge.AppendFormat("Account={0}", request.Account);
arge.AppendFormat("&Pwd={0}", request.Pwd);
string weburl = apiurl + "/Account/Balance";
string resp = common.PushToWeb(weburl, arge.ToString(), Encoding.UTF8);
Console.WriteLine("Balance:" + resp);
try
{
BalanceResponse response = JsonConvert.DeserializeObject <BalanceResponse>(resp);
if (response.Code == 0)
{
//成功
}
else
{
//失败
}
}
catch (Exception ex)
{
//记录日志
}
}
static void Main(string[] args)
{
AntiCaptchaApi AntiCaptchaApi = new AntiCaptchaApi("https://api.anti-captcha.com", "Client Key");
NoCaptchaTaskProxyless captchaTask = new NoCaptchaTaskProxyless("Website Url", "Website Key");
System.Threading.Tasks.Task.Run(async() =>
{
// Get balance
BalanceResponse balanceResponse = await AntiCaptchaApi.GetBalanceAsync();
float balance = balanceResponse.Balance;
// Make a task
TaskResponse response = await AntiCaptchaApi.CreateTaskAsync(captchaTask);
int taskId = response.TaskId;
// Get the task result
TaskResult <NoCaptchaSolution> taskResult = null;
do
{
try
{
taskResult = await AntiCaptchaApi.GetTaskResultAsync <NoCaptchaSolution>(taskId);
// Wait 0.5 seconds before requesting again
System.Threading.Tasks.Task.Delay(500).Wait();
}
catch (Exception e)
{
throw e;
}
}while (taskResult != null && taskResult.Status != "ready");
});
Console.Read();
}
public double?GetBalance()
{
var jsonPostData = new JObject();
jsonPostData["clientKey"] = ClientKey;
dynamic postResult = JsonPostRequest(ApiMethod.GetBalance, jsonPostData);
if (postResult == null || postResult.Equals(false))
{
DebugHelper.Out("API error", DebugHelper.Type.Error);
return(null);
}
var balanceResponse = new BalanceResponse(postResult);
if (!balanceResponse.ErrorId.Equals(0))
{
ErrorMessage = balanceResponse.ErrorDescription;
DebugHelper.Out(
"API error " + balanceResponse.ErrorId + ": " + balanceResponse.ErrorDescription,
DebugHelper.Type.Error
);
return(null);
}
return(balanceResponse.Balance);
}
public async Task CheckBal()
{
var client = new RestClient(_config["brobotapibaseurl"] + "/api/v1/economy/getbalance/");
var request = new RestRequest(Method.POST);
ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => true;
BalanceRequest balance = new BalanceRequest();
balance.discordId = Context.User.Id;
request.AddJsonBody(balance);
IRestResponse response = client.Post(request);
Console.WriteLine(response.Content); //for logging purposes
BalanceResponse result = JsonConvert.DeserializeObject <BalanceResponse>(response.Content);
var builder = new EmbedBuilder()
.WithTitle($"Balance for {Context.User.Username}")
.AddField("Current Balance:", $"{result.balance} coins")
//.AddField("Last Updated", $"{result.lastUpdate}")
.WithColor(3, 115, 9);
var embed = builder.Build();
await Context.Channel.SendMessageAsync(null, false, embed);
}
public bool ServiceStatus()
{
logger.Info("Запрос статуса службы моментальных смс уведомлений");
try {
if (instantSmsServiceHost.State != CommunicationState.Opened)
{
logger.Info($"Хост сервиса моментальных sms сообщений находится в состоянии {instantSmsServiceHost.State}");
return(false);
}
BalanceResponse balanceResponse = smsSender.GetBalanceResponse;
if (balanceResponse.Status == BalanceResponseStatus.Error)
{
logger.Info($"Ошибка запроса баланса");
return(false);
}
if (balanceResponse.BalanceValue < minBalanceValue)
{
logger.Info($"Баланс на счёте менее {minBalanceValue} рублей");
return(false);
}
}
catch (Exception ex) {
logger.Error(ex, "Ошибка при проверке работоспособности службы смс уведомлений");
return(false);
}
return(true);
}
public void GetBalance()
{
//GetBalance
BalanceResponse balanceResponse = _apiClient.GetBalance();
Response.Write("balanceResponse.Credit.ToString() = " + balanceResponse.Credit.ToString() + "<br/><br/><br/>");
}
public static void Withdraw(WithdrawalPayload payload, ResponseCallback callback, ResponseFallback fallback)
{
HttpClient httpClient = new HttpClient();
Request request = new Request(HttpClient.Method.POST, Route.CREATE_WITHDRAWAL_ROUTE, payload);
httpClient.Request(
request,
(statusCode, response) => {
BalanceResponse depositResponse = Deserialize(response);
callback(depositResponse);
},
(statusCode, error) => {
if (statusCode == StatusCodes.CODE_VALIDATION_ERROR)
{
ValidationError validationError = ErrorDeserilizer.DeserializeValidationErrorData(error);
fallback(statusCode, validationError);
}
else
{
GenericError genericError = ErrorDeserilizer.DeserializeGenericErrorData(error);
fallback(statusCode, genericError);
}
}
);
}
public static async Task <BalanceResponse> GetBalanceResult(Merchant merchant)
{
string Url = @"https://api.privatbank.ua/p24api/balance";
string request = RequestBuilder.GetBalance(merchant);
HttpContent content = new StringContent(request);
BalanceResponse balanceResponse = new BalanceResponse();
using (var client = new HttpClient())
{
var result = await client.PostAsync(Url, content);
if (!result.IsSuccessStatusCode)
{
return new BalanceResponse
{
AvailableBalance = 0,
Balance = 0,
Limit = 0,
UpdateTime = "",
ErrorMes = "Requester Error"
}
}
;
using (result)
{
string response = await result.Content.ReadAsStringAsync();
return(balanceResponse.Build(response));
}
}
}
/// <summary>
/// обновился портфель
/// </summary>
private void UpdatePortfolios(BalanceResponse portf)
{
try
{
if (portf == null ||
portf.eur_balance == null)
{
return;
}
if (_portfolios == null)
{
_portfolios = new List <Portfolio>();
}
Portfolio osPortEur = _portfolios.Find(p => p.Number == "eurPortfolio");
if (osPortEur == null)
{
osPortEur = new Portfolio();
osPortEur.Number = "eurPortfolio";
_portfolios.Add(osPortEur);
}
osPortEur.ValueBegin = Convert.ToDecimal(portf.eur_balance.Replace(",", CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator), CultureInfo.InvariantCulture);
osPortEur.ValueBlocked = Convert.ToDecimal(portf.eur_reserved.Replace(",", CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator), CultureInfo.InvariantCulture);
Portfolio osPortUsd = _portfolios.Find(p => p.Number == "usdPortfolio");
if (osPortUsd == null)
{
osPortUsd = new Portfolio();
osPortUsd.Number = "usdPortfolio";
_portfolios.Add(osPortUsd);
}
osPortUsd.ValueBegin = Convert.ToDecimal(portf.usd_balance.Replace(",", CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator), CultureInfo.InvariantCulture);
osPortUsd.ValueBlocked = Convert.ToDecimal(portf.usd_reserved.Replace(",", CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator), CultureInfo.InvariantCulture);
Portfolio osPortBtc = _portfolios.Find(p => p.Number == "btcPortfolio");
if (osPortBtc == null)
{
osPortBtc = new Portfolio();
osPortBtc.Number = "btcPortfolio";
_portfolios.Add(osPortBtc);
}
osPortBtc.ValueBegin = Convert.ToDecimal(portf.btc_balance.Replace(",", CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator), CultureInfo.InvariantCulture);
osPortBtc.ValueBlocked = Convert.ToDecimal(portf.btc_reserved.Replace(",", CultureInfo.InvariantCulture.NumberFormat.NumberDecimalSeparator), CultureInfo.InvariantCulture);
_portfolioToSend.Enqueue(_portfolios);
}
catch (Exception error)
{
SendLogMessage(error.ToString(), LogMessageType.Error);
}
}
public async Task <ActionResult <BalanceResponse> > Balance()
{
Balance balance = await _walletService.GetBalanceAsync();
BalanceResponse balanceResponse = _mapper.Map <BalanceResponse>(balance);
return(Ok(balanceResponse));
}
public async Task Deposit_Deposit10_ReturnsOkAndPostDepositBalance()
{
//// Arrange
decimal postDepositBalance = 15;
Balance expectedBalance = new Balance()
{
Amount = postDepositBalance
};
BalanceResponse expectedBalanceResponse = new BalanceResponse()
{
Amount = postDepositBalance
};
decimal depositAmount = 10;
DepositRequest depositRequest = new DepositRequest {
Amount = depositAmount
};
// Setup Mocks
Mock <IWalletService> walletServiceMock = new Mock <IWalletService>();
Deposit deposit = new Deposit {
Amount = depositAmount
};
walletServiceMock
.Setup(walletService => walletService.DepositFundsAsync(deposit))
.Returns(Task.FromResult(expectedBalance));
IWalletService walletService = walletServiceMock.Object;
ILogger <WalletController> logger = Mock.Of <ILogger <WalletController> >();
IMapper mapper = Mock.Of <IMapper>(mapper => mapper.Map <Deposit>(depositRequest) == deposit &&
mapper.Map <BalanceResponse>(expectedBalance) == expectedBalanceResponse);
// Initialize SUT
WalletController walletController = new WalletController(logger, mapper, walletService);
//// Act
ActionResult <BalanceResponse> actionResult = await walletController.Deposit(depositRequest);
ActionResult actualActionResult = actionResult.Result;
//// Assert
OkObjectResult okObjectResult = Assert.IsType <OkObjectResult>(actionResult.Result);
BalanceResponse actualBalanceResponse = Assert.IsType <BalanceResponse>(okObjectResult.Value);
Assert.Equal(expectedBalanceResponse, actualBalanceResponse);
walletServiceMock.Verify(walletService => walletService.DepositFundsAsync(deposit), Times.Once);
walletServiceMock.VerifyNoOtherCalls();
}
public async Task Withdrawal_Withdraw20_ReturnsOkAndBalance5()
{
//// Arrange
decimal postWithdrawalBalanceAmount = 5;
Balance postWithdrawalBalance = new Balance()
{
Amount = postWithdrawalBalanceAmount
};
BalanceResponse expectedBalanceResponse = new BalanceResponse()
{
Amount = postWithdrawalBalanceAmount
};
decimal withdrawalAmount = 20;
WithdrawalRequest withdrawalRequest = new WithdrawalRequest {
Amount = withdrawalAmount
};
// Setup Mocks
Mock <IWalletService> walletServiceMock = new Mock <IWalletService>();
Withdrawal withdrawal = new Withdrawal {
Amount = withdrawalAmount
};
walletServiceMock
.Setup(walletService => walletService.WithdrawFundsAsync(withdrawal))
.Returns(Task.FromResult(postWithdrawalBalance));
IWalletService walletService = walletServiceMock.Object;
ILogger <WalletController> logger = Mock.Of <ILogger <WalletController> >();
IMapper mapper = Mock.Of <IMapper>(mapper => mapper.Map <Withdrawal>(withdrawalRequest) == withdrawal &&
mapper.Map <BalanceResponse>(postWithdrawalBalance) == expectedBalanceResponse);
// Initialize SUT
WalletController walletController = new WalletController(logger, mapper, walletService);
//// Act
ActionResult <BalanceResponse> actionResult = await walletController.Withdraw(withdrawalRequest);
ActionResult actualActionResult = actionResult.Result;
//// Assert
OkObjectResult okObjectResult = Assert.IsType <OkObjectResult>(actionResult.Result);
BalanceResponse actualBalanceResponse = Assert.IsType <BalanceResponse>(okObjectResult.Value);
Assert.Equal(expectedBalanceResponse, actualBalanceResponse);
walletServiceMock.Verify(walletService => walletService.WithdrawFundsAsync(withdrawal), Times.Once);
walletServiceMock.VerifyNoOtherCalls();
}
/// <summary>
/// Queries the balance.
/// </summary>
/// <returns>The balance.</returns>
public BalanceResponse QueryBalance()
{
long TimeStamp = DateTimeOffset.Now.ToUnixTimeMilliseconds();
string Signature = CryptoUtils.Sha256(string.Format(Const.QUERY_BALANCE_SIGN_TEMPLATE, TimeStamp, SmsKey));
var QueryBalanceUrl = string.Format(Const.QUERY_BALANCE_URL, AppId, TimeStamp, Signature);
BalanceResponse Response = WilddogHttpClient.DoGet <BalanceResponse>(QueryBalanceUrl);
return(Response);
}
public void OnGet()
{
// load the balance from the neo council wallet using their public address
Existing = _neo.GetBalance("AQVh2pG732YvtNaxEGkQUei3YA4cvo7d2i");
// generate a new random private key, and then get the balance from that
GeneratedKey = _neo.GeneratePrivateKey();
Generated = _neo.GetBalance(GeneratedKey.ToAddress());
}
public async Task <ActionResult <BalanceResponse> > Deposit(DepositRequest depositRequest)
{
Deposit deposit = _mapper.Map <Deposit>(depositRequest);
Balance balance = await _walletService.DepositFundsAsync(deposit);
BalanceResponse balanceResponse = _mapper.Map <BalanceResponse>(balance);
return(Ok(balanceResponse));
}
public async Task <ActionResult <BalanceResponse> > Withdraw(WithdrawalRequest withdrawalRequest)
{
Withdrawal withdrawal = _mapper.Map <Withdrawal>(withdrawalRequest);
Balance balance = await _walletService.WithdrawFundsAsync(withdrawal);
BalanceResponse balanceResponse = _mapper.Map <BalanceResponse>(balance);
return(Ok(balanceResponse));
}
public IActionResult GetBalance(string address)
{
var balanceResponse = new BalanceResponse
{
Address = address,
Balance = _blockchain.GetBalance(address)
};
return(Ok(balanceResponse));
}
public async Task Balance_GetBalanceIs4_ReturnsOkAndBalance4()
{
//// Arrange
decimal currentBalanceAmount = 4;
Balance currentBalance = new Balance()
{
Amount = currentBalanceAmount
};
BalanceResponse expectedBalanceResponse = new BalanceResponse()
{
Amount = currentBalanceAmount
};
// Setup Mocks
Mock <ILogger <WalletController> > loggerMock = new Mock <ILogger <WalletController> >();
ILogger <WalletController> logger = loggerMock.Object;
Mock <IMapper> mapperMock = new Mock <IMapper>();
mapperMock
.Setup(mapper => mapper.Map <BalanceResponse>(currentBalance))
.Returns(expectedBalanceResponse);
IMapper mapper = mapperMock.Object;
Mock <IWalletService> walletServiceMock = new Mock <IWalletService>();
walletServiceMock
.Setup(walletService => walletService.GetBalanceAsync())
.Returns(Task.FromResult(currentBalance));
IWalletService walletService = walletServiceMock.Object;
// Initialize SUT
WalletController walletController = new WalletController(logger, mapper, walletService);
//// Act
ActionResult <BalanceResponse> actionResult = await walletController.Balance();
ActionResult actualActionResult = actionResult.Result;
/// Assert
OkObjectResult okObjectResult = Assert.IsType <OkObjectResult>(actionResult.Result);
BalanceResponse actualBalanceResponse = Assert.IsType <BalanceResponse>(okObjectResult.Value);
Assert.Equal(expectedBalanceResponse, actualBalanceResponse);
walletServiceMock.Verify(walletService => walletService.GetBalanceAsync(), Times.Once);
walletServiceMock.VerifyNoOtherCalls();
}
public static string GetBalance(Merchant merchant)
{
BalanceResponse response = Requester.GetBalanceResult(merchant).Result;
string Av_Balance = response.AvailableBalance.ToString("C2", culture);
string Limit = response.Limit.ToString("C2", culture);
string balance = $"Баланс = {Av_Balance} 💰, " + Environment.NewLine +
$"кредитный лимит = {Limit} 💳, " + Environment.NewLine +
$"дата последней операции = {response.UpdateTime} 🏧" + Environment.NewLine + response.ErrorMes;
return(balance);
}
public async Task GetBalanceAsync_CurrentBalanceIs4_ReturnsOk4Async()
{
//// Arrange
decimal currentBalanceAmount = 4;
// Setup Mocks
Mock <IWalletService> walletServiceMock = new Mock <IWalletService>();
Balance currentBalance = new Balance()
{
Amount = currentBalanceAmount
};
walletServiceMock
.Setup(walletService => walletService.GetBalanceAsync())
.Returns(Task.FromResult(currentBalance));
IWalletService walletService = walletServiceMock.Object;
// Initialize HTTP client and request data
WebApplicationFactory <Startup> factory = new CustomWebApplicationFactory <Startup>(services =>
services.SwapTransient(provider => walletService)
);
HttpClient client = factory.CreateClient();
string endpoint = "Wallet/Balance";
// Set Expectations
BalanceResponse expectedBalanceResponse = new BalanceResponse()
{
Amount = currentBalanceAmount
};
//// Act
HttpResponseMessage response = await client.GetAsync(endpoint);
BalanceResponse actualBalanceResponse = await response.Content.ReadAsAsync <BalanceResponse>(new[] { new JsonMediaTypeFormatter() });
//// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
actualBalanceResponse.ShouldCompare(expectedBalanceResponse);
walletServiceMock.Verify(walletService => walletService.GetBalanceAsync(), Times.Once);
walletServiceMock.VerifyNoOtherCalls();
}
public void Withdraw()
{
string[] fields = { withdrawal_amount.text, accountNumber.text };
if (currentBank == null)
{
menuManager.StartCoroutine(menuManager.showPopUpT("Select a bank", "error"));
return;
}
Validate.CheckEmptyFields(
fields,
(message) => { menuManager.StartCoroutine(menuManager.showPopUpT(message, "error"));
//ResetWithdrawal();
},
() =>
{
SetLoading(withdraw_loading, withdraw_form, withdraw_back_button, true);
InitiateWithdrawal.Withdraw(
new WithdrawalPayload(float.Parse(withdrawal_amount.text), accountNumber.text, currentBank.uid),
(response) => {
BalanceResponse depositResponse = (BalanceResponse)response;
withdraw_form.SetActive(false);
Debug.Log(depositResponse.balance);
State.UserProfile.naira_balance = depositResponse.balance;
SetLoading(withdraw_loading, withdraw_success, withdraw_back_button, false);
},
(statusCode, error) => {
SetLoading(withdraw_loading, withdraw_failed, withdraw_back_button, false);
if (statusCode == StatusCodes.CODE_VALIDATION_ERROR)
{
ValidationError validationError = (ValidationError)error;
menuManager.StartCoroutine(menuManager.showPopUpT(validationError.errors.First().Value[0], "error"));
}
else
{
GenericError genericError = (GenericError)error;
menuManager.StartCoroutine(menuManager.showPopUpT(genericError.message, "error"));
}
}
);
});
}
public async Task <IActionResult> GetBalanceAsync(int playerId)
{
Logger.LogDebug(nameof(GetBalanceAsync));
var player = await _playerRepository.GetAsync(playerId).ConfigureAwait(false);
var result = new BalanceResponse
{
PlayerId = playerId,
Name = player.Name,
Balance = player.Balance
};
return(Ok(result));
}
private static BalanceResponse Deserialize(object response)
{
var responseJson = (string)response;
var data = fsJsonParser.Parse(responseJson);
object deserialized = null;
serializer.TryDeserialize(data, typeof(BalanceResponse), ref deserialized);
BalanceResponse serializedData = deserialized as BalanceResponse;
return(serializedData);
}
/// <summary>
/// Get balance for specified currency.
/// </summary>
/// <param name="currency">Currency type.</param>
/// <param name="address">Your public Address.</param>
/// <param name="includeUnspentOutputs">(For BTC only) if "true", the response includes unspent outputs for the address. "false" by default.</param>
/// <response code="200">Balance and associated currency.</response>
/// <response code="400">Invalid address format.</response>
/// <response code="500">Server error.</response>
/// <response code="503">Service unavailable for the specified currency or temporarily.</response>
public async Task <Result <BalanceResponse, ErrorResponse> > GetBalanceAsync(ECurrency currency, string address, bool includeUnspentOutputs = false)
{
if (string.IsNullOrWhiteSpace(address))
{
throw new ArgumentNullException(nameof(address));
}
var result = new Result <BalanceResponse, ErrorResponse>();
string requestUri = $"{mEnv.BaseUrl}/v1/{currency}/Addresses/{address}";
List <string> queryParams = new List <string>();
queryParams.Add($"includeUnspentOutputs={includeUnspentOutputs}");
if (queryParams.Any())
{
requestUri = $"{requestUri}?{string.Join("&", queryParams)}";
}
try
{
using (HttpClient httpClient = new HttpClient())
using (HttpResponseMessage response = await httpClient.GetAsync(requestUri))
{
if (response.IsSuccessStatusCode)
{
BalanceResponse balanceResponse = await response.Content.ReadAsAsync <BalanceResponse>();
result.IsSuccess = true;
result.Data = balanceResponse;
return(result);
}
string contentString = await response.Content.ReadAsStringAsync();
result.Error = ResponseHandler.GetError(response.StatusCode, requestUri, contentString);
}
}
catch (HttpRequestException)
{
result.IsSuccess = false;
result.Error = ResponseHandler.GetExceptionError();
}
return(result);
}
public ActionResult <BalanceResponse> Post([FromBody] BalanceRequest balanceRequest)
{
// TODO: query the core for a balance. Here, we'll just simulate
// that by returning a random value between $0.00 and $999.99:
Random rand = new Random(DateTime.Now.Millisecond);
decimal balance = (decimal)(rand.Next(99999) / 100.0);
BalanceResponse response = new BalanceResponse
{
success = true,
balance = balance,
routingTransitNumber = balanceRequest.routingTransitNumber,
accountNumber = balanceRequest.accountNumber
};
return(response);
}
public async void Run_TerminalGiftCardBalanceTest()
{
ShowTestOnTerminal("TerminalGiftCardBalance");
BalanceRequest request = new BalanceRequest
{
Test = true,
TerminalName = IntegrationTestConfiguration.Instance.Settings.DefaultTerminalName,
};
output.WriteLine("Request: {0}", request);
BalanceResponse response = await blockchyp.BalanceAsync(request);
output.WriteLine("Response: {0}", response);
Assert.True(response.Success, "response.Success");
Assert.NotEmpty(response.RemainingBalance);
}
public static void BalanceEvent(object sender, BalanceResponse response)
{
switch (response.Event)
{
case EventType.None: { break; }
case EventType.Subscribed:
{
Console.WriteLine("*You successfully subscribed to your balances.");
break;
}
case EventType.Unsubscribed:
{
Console.WriteLine($"*You successfully unsubscribed from your balances.");
break;
}
case EventType.Rejected:
{
Console.WriteLine($"*Balance subscription failed. Server returned a message: '{response.Message}'. ");
break;
}
case EventType.Snapshot:
{
Console.WriteLine("*** Balance snapshot:");
foreach (var balance in response.Balances)
{
Console.WriteLine(balance.ToString());
}
Console.WriteLine("\ntotal_available_local: " + response.Total_available_local);
Console.WriteLine("total_balance_local: " + response.Total_balance_local + "\n\n");
Console.WriteLine("*** End of snapshot.\n\n");
break;
}
case EventType.Updated: { break; }
default: { break; }
}
}
public bool GetBalance(Balance balance, string token, out string errorMessage, out string errorcode, out BalanceResponse balanceResponse)
{
errorcode = "";
errorMessage = "";
string apikey = token;
//func-ExecuteTransaction
string url = ConfigurationManager.AppSettings["GetBalanceUrl"];
string xml = $@"<?xml version=""1.0"" encoding=""utf-8""?>
<soap:Envelope xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns:soap=""http://schemas.xmlsoap.org/soap/envelope/"">
<soap:Body>
<GetBalance xmlns=""http://tempuri.org/"" >
<ApiKey>{apikey}</ApiKey>
<Carid>{balance.Cardid}</Carid>
<Mispar_hetken>{balance.Mispar_hetken}</Mispar_hetken>
<Pin_code>{balance.Pin_code}</Pin_code>
<Kod_station>{balance.Kod_station}</Kod_station>
<Pump_price>{balance.Pump_price}</Pump_price>
<Kod_tazkik>{balance.Kod_tazkik}</Kod_tazkik>
</GetBalance>
</soap:Body>
</soap:Envelope>";
string ans = POST(url, apikey, xml);
if (ans.Contains("Error message"))
{
errorMessage = ans;
balanceResponse = null;
return(false);
}
XmlDocument doc = new XmlDocument();
doc.LoadXml(ans);
balanceResponse = new BalanceResponse(doc.InnerText);
if (balanceResponse.ResponseCode == "2000")
{
return(true);
}
errorcode = doc.InnerText;
errorMessage = GetErrorMessage(errorcode);
return(false);
}
// 获取用户Balance
public IEnumerator GetUserBalance(string userName)
{
FormData formData = new FormData()
.AddField("app_id", _appID)
.AddField("app_key", _appKey)
.AddField("app_user", userName);
Request request = new Request(EOTAPI.Balance).Post(RequestBody.From(formData));
Client http = new Client();
yield return(http.Send(request));
if (http.IsSuccessful())
{
Response resp = http.Response();
Debug.Log("BalanceResponse: " + resp.Body());
_balanceResponse = JsonUtility.FromJson <BalanceResponse>(resp.Body());
if (_balanceResponse.success)
{
UserBalanceResult.Code = EOTConstant.CODE_SUCCESS;
UserBalanceResult.Msg = EOTConstant.MSG_SUCCESS;
UserBalanceResult.Balance = _balanceResponse.balance;
}
else
{
UserBalanceResult.Code = _balanceResponse.code;
UserBalanceResult.Msg = _balanceResponse.msg;
UserBalanceResult.Balance = null;
}
}
else
{
UserBalanceResult.Code = EOTConstant.CODE_NETWORK_ERROR;
UserBalanceResult.Msg = EOTConstant.MSG_NETWORK_ERROR;
Debug.LogError("NetWorkError: " + http.Error());
}
}
public async Task GetBalance_OK_HasCorrectData()
{
const string currency = FaucetPayClient.Bitcoin;
const string json = @"{
""status"": 200,
""message"": ""OK"",
""currency"": ""BTC"",
""balance"": ""4321"",
""balance_bitcoin"": ""0.00004321""
}";
var expectedResult = new BalanceResponse
{
Currency = FaucetPayClient.Bitcoin,
ActualBalance = 0.00004321m,
SatoshiBalance = 4321
}.ToExpectedObject();
var client = new MockRequester("balance", json).CreateClient();
var actualResult = await client.GetBalance(currency);
expectedResult.ShouldEqual(actualResult);
}
