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 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) { //记录日志 } }
public override BalanceModel RequestBalances() { var b = new BalanceRequest(this); var model = b.Request <BalanceResponse>().Transform(); return(model); }
public virtual BalanceResponse GetBalance(BalanceRequest request) { var sw = new Stopwatch(); sw.Start(); try { var result = NetAgent.UploadData(request.Url, request.PostData, Encoding.UTF8, null, new Dictionary <string, string>() { { "Content-Type", "application/json" }, { "Content-Language", request.Language.ToString() }, { "X-Forwarded-IP", IPAgent.IP } }); if (result.StartsWith("Error:")) { throw new Exception(result); } return(new BalanceResponse(request, result, (int)sw.ElapsedMilliseconds)); } catch (Exception ex) { return(new BalanceResponse(request, ex.Message, (int)sw.ElapsedMilliseconds, true)); } }
public double GetBalanceByPhoneNumber(string value) { BalanceEventArgs eventArgs = new BalanceEventArgs(); eventArgs.PhoneNumber = value; BalanceRequest?.Invoke(this, eventArgs); return(eventArgs.Balance); }
public BalanceResponse BalanceRequest(BalanceRequest balanceRequest) { var makeUri = new Uri(@"/webservice/deposition/api/balance", UriKind.Relative); var xmlRequest = xmlSerializer.Serialize(balanceRequest); var response = Request <BalanceRequest>(xmlRequest, makeUri); return(xmlSerializer.Deserialize <BalanceResponse>(response)); }
public void UnsubscribeBalance() { BalanceRequest br = new BalanceRequest { Action = ActionType.Unsubscribe }; AddMessageToQueue(br); }
public async Task <List <Currency> > GetBalance(string account, string code, string symbol) { BalanceRequest request = new BalanceRequest() { Code = code, Account = account, Symbol = symbol }; return(await PostAsync <List <Currency> >(request, $"/v{ApiVersion}/{ChainGroup}/get_currency_balance")); }
public async Task <Accounting.Decimal> GetBalance(BalanceRequest request, DateTime?deadline = null, CancellationToken context = default) { var resp = await AccountingClient.BalanceAsync(request, deadline : deadline, cancellationToken : context); if (!resp.Verify()) { throw new FormatException("invalid balance response"); } CheckStatus(resp); return(resp.Body.Balance); }
public void BalanceRequestTest() { var balanceRequest = new BalanceRequest { mocean_resp_format = "json" }; Assert.IsNotNull(balanceRequest.mocean_resp_format); Assert.AreEqual(balanceRequest.mocean_resp_format, "json"); balanceRequest = new BalanceRequest(); Assert.IsNull(balanceRequest.mocean_resp_format); balanceRequest.mocean_resp_format = "json"; Assert.AreEqual(balanceRequest.mocean_resp_format, "json"); }
public IHttpActionResult GetBalanceWithFees(BalanceRequest balance) { try { RabbitMQClient client = new RabbitMQClient(); client.SendBalance(balance, "FSV.Balance"); client.Close(); } catch (Exception) { return(StatusCode(HttpStatusCode.BadRequest)); } return(Ok(balance)); }
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 Task<JsonResult<BalanceModel>> getBalance(BalanceRequest balanceRequest) { BalanceModel balanceModel = new BalanceModel(); /* Para sabe cual es su ApiKey debe iniciar sesion como empresa en www.Xaldo.com e ir al apartado de "Empresa" despúes en la parte "WebService" y "Api Key" */ if (balanceRequest.ApiKey == "Qpx4AQlFWoCe4wrESGxYycyb3j1EwO") { if (balanceRequest.Contract != "" && balanceRequest.Contract != null) { DataBaseDebt debtSearcher = new DataBaseDebt(balanceRequest); try { balanceModel = await debtSearcher.search(); } catch (Exception e) { balanceModel.Contract = balanceRequest.Contract; balanceModel.Amount = 0.0; balanceModel.Concept = "not_found"; balanceModel.DueDate = "01/01/1900"; balanceModel.IdError = 1; balanceModel.Status = false; } } else { balanceModel.Contract = balanceRequest.Contract; balanceModel.Amount = 0.0; balanceModel.Concept = "not_found"; balanceModel.DueDate = "01/01/1900"; balanceModel.IdError = (int)ErrorEnum.ErrorResponce.Invalid_Contract; balanceModel.Status = false; } } else { balanceModel.Contract = balanceRequest.Contract; balanceModel.Amount = 0.0; balanceModel.Concept = "not_found"; balanceModel.DueDate = "01/01/1900"; balanceModel.IdError = (int)ErrorEnum.ErrorResponce.Unauthorized; balanceModel.Status = false; } return Json(balanceModel); }
public async Task <ApiUserBalanceResponse> GetBalance(BalanceRequest request) { try { return(await ApiPrivateService.GetUserBalance(new ApiUserBalanceRequest { Currency = request.Currency, CurrencyId = request.CurrencyId, UserId = new Guid(User.Identity.Name) })); } catch (Exception) { return(new ApiUserBalanceResponse { Success = false, Error = "Bad Request" }); } }
public async Task <BalanceResponse> GetBalanceAsync() { BalanceRequest request = new BalanceRequest(login, password); string content = JsonConvert.SerializeObject(request); using (HttpClient httpClient = new HttpClient()) { httpClient.DefaultRequestHeaders.Accept.Clear(); httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(contentType)); HttpContent httpContent = new StringContent(content, Encoding.UTF8, contentType); string url = baseAddress + "/balance.json"; var httpResponse = await httpClient.PostAsync(url, httpContent); var responseContent = await httpResponse.Content.ReadAsStringAsync(); return(JsonConvert.DeserializeObject <BalanceResponse>(responseContent)); } }
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 HttpResponseMessage Post(HttpRequestMessage request, [FromBody] BalanceRequest requestBody) { IEnumerable <string> token = null; request.Headers.TryGetValues("Token-autorization", out token); //TODO: Corregir error ortográfico PersonEN personVerified = personBL.VerifyPersonAuthentication(token); if (!string.IsNullOrEmpty(requestBody.VendorEmail)) { if (personVerified.IsValidToken) { var inf = balanceRequestBL.RequestBalance(requestBody.VendorEmail); if (inf != null) { var responseSucces = interactor.createSuccessResponse(inf); return(Request.CreateResponse <IResponse>(HttpStatusCode.OK, responseSucces)); } else { response.HttpCode = 404; response.Message = "Seller not found"; return(Request.CreateResponse <IResponse>(HttpStatusCode.Unauthorized, response)); } } else { response.HttpCode = 401; response.Message = "Authentication token has expired."; return(Request.CreateResponse <IResponse>(HttpStatusCode.Unauthorized, response)); } } else { response.HttpCode = 400; response.Message = "Email parameter must not be null."; return(Request.CreateResponse <IResponse>(HttpStatusCode.BadRequest, response)); } }
public async Task <Accounting.Decimal> GetBalance(OwnerID owner = null, CallOptions options = null, CancellationToken context = default) { var opts = DefaultCallOptions.ApplyCustomOptions(options); CheckOptions(opts); if (owner is null) { owner = OwnerID.FromScriptHash(opts.Key.PublicKey().PublicKeyToScriptHash()); } var req = new BalanceRequest { Body = new BalanceRequest.Types.Body { OwnerId = owner, } }; req.MetaHeader = opts.GetRequestMetaHeader(); opts.Key.Sign(req); return(await GetBalance(req, opts.Deadline, context)); }
/// <summary> /// Balance kész /// </summary> public override Task <BalanceResponse> Balance(BalanceRequest request, ServerCallContext context) { if (sessions.Contains(request.Uid)) { var filter = new FilterDefinitionBuilder <BsonDocument>().Empty; var result = balance.Find(filter); return(Task.FromResult(new BalanceResponse() { Balance = result.ToList().First().GetValue("balance").ToInt32() })); } else { return(Task.FromResult(new BalanceResponse() { Balance = 0 })); } }
public Accounting.Decimal GetBalance(OwnerID owner, CallOptions options = null) { var account_client = new AccountingService.AccountingServiceClient(channel); var opts = DefaultCallOptions.ApplyCustomOptions(options); var req = new BalanceRequest { Body = new BalanceRequest.Types.Body { OwnerId = owner, } }; req.MetaHeader = opts.GetRequestMetaHeader(); req.SignRequest(key); var resp = account_client.Balance(req); if (!resp.VerifyResponse()) { throw new FormatException("invalid balance response"); } return(resp.Body.Balance); }
public BalanceResponse Balance(BalanceRequest externalRequest) { Log(Logger.LogMessageType.Info, "-> -------------------- Comienza la ejecución del método Sales.Balance", Logger.LoggingLevelType.Medium); BalanceRequestInternal internalRequest = new BalanceRequestInternal() { SessionID = externalRequest.Request.SessionID, DeviceType = externalRequest.Request.DeviceType }; BalanceResponseInternal internalResponse = BalanceProvider.BalanceInternal(internalRequest); BalanceResponse externalResponse = new BalanceResponse(); BalanceResponseBody externalResponseBody = new BalanceResponseBody() { ResponseCode = internalResponse.ResponseCode, ResponseMessage = internalResponse.ResponseMessage, TransactionID = internalResponse.TransactionID, Balance = internalResponse.StockBalance }; externalResponse.Response = externalResponseBody; Log(Logger.LogMessageType.Info, "-> -------------------- Termina la ejecución del método Sales.Balance", Logger.LoggingLevelType.Medium); return(externalResponse); }
public async Task <BalanceResponse> Balance() { var req = new BalanceRequest(); return(await PostPrivateRequest <BalanceRequest, BalanceResponse> ("balance", req)); }
public async Task <BalanceResponse> GetBalance(BalanceRequest request) { return(await GetResult <BalanceResponse, BalanceRequest>(PrivateApiCall.GetBalance, request)); }
public void ResetBalance([FromBody] BalanceRequest request) { _client.ResetBalance(); }
/// <summary> /// Gets the current balance. /// </summary> /// <param name="request">The request.</param> /// <returns>The response that was returned by the API.</returns> public BalanceResponse GetBalance(BalanceRequest request) { return(Get <BalanceRequest, BalanceResponse>(@"balance", request)); }
public BalanceResponse GetBalance(string url, BalanceRequest request) { throw new NotImplementedException(); }
/// <summary> /// Gets the current balance. /// </summary> /// <param name="request">The request.</param> /// <returns>The response that was returned by the API.</returns> public Task <BalanceResponse> GetBalanceAsync(BalanceRequest request) { return(GetAsync <BalanceRequest, BalanceResponse>(@"balance", request)); }
public void SetBalance([FromBody] BalanceRequest request) { _client.SetBalance(request.Address, request.Balance); }
public DataBaseDebt(BalanceRequest BalanceRequest) { this.BalanceRequest = BalanceRequest; }
private void HandleBalanceMoney(BalanceRequest message) { Sender.Tell(new ReceiptResponse(_balance)); }