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