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