private string GetSignature(string endpoint, List <KeyValuePair <string, string> > data)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
data.Sort(CompareKeyValuePair);
using (var content = new FormUrlEncodedContent(data))
{
var queryString = WebUtility.UrlDecode(content.ReadAsStringAsync().Result);
var plainString = $"GET{endpoint}{Uri}?{queryString}";
using (var hmac = new HMACSHA1(Encoding.UTF8.GetBytes(SecretKey)))
{
return(Convert.ToBase64String(hmac.ComputeHash(Encoding.UTF8.GetBytes(plainString))));
}
}
}
public async Task TrackEvent(string cid, string eventCategory, string eventAction, string eventLabel)
{
var payload = new FormUrlEncodedContent(new[] {
KeyValuePair.Create("v", "1"),
KeyValuePair.Create("tid", tid),
KeyValuePair.Create("cid", cid),
KeyValuePair.Create("t", "event"),
KeyValuePair.Create("ec", eventCategory),
KeyValuePair.Create("ea", eventAction),
KeyValuePair.Create("el", eventLabel)
});
var payloadString = await payload.ReadAsStringAsync();
var res = await httpClient.PostAsync(
new System.Uri("https://www.google-analytics.com/collect"),
new StringContent(payloadString));
}
private (string, IHeaderDictionary) FormRequest(object request, string endpoint, string token = null)
{
var headers = new HeaderDictionary();
var properties = request.GetType()
.GetRuntimeFields()
.Where(p => p.GetValue(request) != null).Select(p => new { p.Name, Value = p.GetValue(request) })
.ToDictionary(d => d.Name, v => v.Value.ToString());
properties.Add("ticket", token ?? Ticket);
using (var encodedContent = new FormUrlEncodedContent(properties))
{
var requestString = $"{tccBaseUrl}/tcc/{endpoint}?" + encodedContent.ReadAsStringAsync().Result;
return(requestString, headers);
}
}
/// <summary>
/// Retorna uma QueryString baseada nas propriedades do objeto informado.
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public static async Task <string> ToQueryStringAsync(this object obj)
{
if (obj == null)
{
return(null);
}
IDictionary <string, string> keyValueContent = obj.ToDictionary();
if (keyValueContent == null)
{
return(null);
}
var formUrlEncodedContent = new FormUrlEncodedContent(keyValueContent);
return(await formUrlEncodedContent.ReadAsStringAsync());
}
/// <summary>
/// 获取订单信息
/// </summary>
/// <param name="instrument_id">币对</param>
/// <param name="order_id">订单ID</param>
/// <returns></returns>
public async Task <JObject> getOrderByIdAsync(string instrument_id, string order_id)
{
var url = $"{this.BASEURL}{this.SPOT_SEGMENT}/orders/{order_id}";
using (var client = new HttpClient(new HttpInterceptor(this._apiKey, this._secret, this._passPhrase, null)))
{
var queryParams = new Dictionary <string, string>();
queryParams.Add("instrument_id", instrument_id);
var encodedContent = new FormUrlEncodedContent(queryParams);
var paramsStr = await encodedContent.ReadAsStringAsync();
var res = await client.GetAsync($"{url}?{paramsStr}");
var contentStr = await res.Content.ReadAsStringAsync();
return(JObject.Parse(contentStr));
}
}
public static async Task <IEnumerable <Claim> > GetTokenAsync(string username, string password)
{
using (var client = new HttpClient(new HttpClientHandler(), false))
{
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var content = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("username", username),
new KeyValuePair <string, string>("password", password),
new KeyValuePair <string, string>("grant_type", "password")
});
var response = await client.PostAsync(_tokenUri, content, new CancellationToken()).ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
var responseToken = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var json = JObject.Parse(responseToken);
var jwt = json["access_token"].ToString();
JwtSecurityTokenHandler handler;
JwtSecurityToken jwtTokenContent;
try
{
handler = new JwtSecurityTokenHandler();
jwtTokenContent = handler.ReadToken(jwt) as JwtSecurityToken;
}
catch (Exception ex)
{
throw ex;
}
return(jwtTokenContent.Claims);
}
else
{
var errorResponse = await content.ReadAsStringAsync().ConfigureAwait(false);
throw new HttpException((int)HttpStatusCode.InternalServerError, errorResponse);
}
}
}
private static async Task <string> GetSign(Dictionary <string, string> form = null)
{
form = form ?? new Dictionary <string, string>();
var content = new FormUrlEncodedContent(form);
var encodedForm = await content.ReadAsStringAsync();
var encoding = new UTF8Encoding();
var keyBytes = encoding.GetBytes(APIKeys.SECRET);
var formBytes = encoding.GetBytes(encodedForm);
var sha512 = new HMACSHA512(keyBytes);
var hashBytes = sha512.ComputeHash(formBytes);
var sign = BitConverter.ToString(hashBytes).Replace("-", "").ToLower();
return(sign);
}
/// <summary>
/// Gets Percentage of occupied space
/// </summary>
public async Task <ResponseModel> GetPercentageofOccupiedSpace(int userId)
{
// double
CheckJwt();
UriBuilder ub = new UriBuilder(rootUrl + "/api/parking/getpercentageofoccupiedspace");
using (var content = new FormUrlEncodedContent(new Dictionary <string, string>
{
{ "userId", userId.ToString() }
}))
{
ub.Query = await content.ReadAsStringAsync();
}
HttpResponseMessage response = await client.GetAsync(ub.Uri);
string resultString = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <ResponseModel>(resultString));
}
/// <summary>
/// Calculates remaining parking cost
/// </summary>
public async Task <ResponseModel> GetRemainingCost(int ticketNumber)
{
// decimal
CheckJwt();
UriBuilder ub = new UriBuilder(rootUrl + "/api/parking/getremainingcost");
using (var content = new FormUrlEncodedContent(new Dictionary <string, string>
{
{ "userName", CurrentUser.Username }
}))
{
ub.Query = await content.ReadAsStringAsync();
}
HttpResponseMessage response = await client.GetAsync(ub.Uri);
string resultString = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <ResponseModel>(resultString));
}
public async Task <IActionResult> Login()
{
var pkce = new Pkce
{
// uses the IdentityModel NuGet package to create a strongly random URL safe identifier
// this will be our Code Verifier
CodeVerifier = CryptoRandom.CreateUniqueId(32)
};
using (var sha256 = SHA256.Create())
{
// Here we create a hash of the code verifier
var challengeBytes = sha256.ComputeHash(Encoding.UTF8.GetBytes(pkce.CodeVerifier));
// and produce the "Code Challenge" from it by base64Url encoding it.
pkce.CodeChallenge = Base64Url.Encode(challengeBytes);
}
// Save the CodeVerifier in the memorycache so we are able to use it later
// This is just for demonstration. Please consider saving this in a more robust solution.
_memoryCache.Set(AppConstants.PKCECacheKey, pkce);
// Build the authorize url
var authorizeArgs = new Dictionary <string, string>
{
{ "client_id", _appConfiguration.ClientId },
{ "scope", "read:core:entities read:owneraccounts offline_access" },
{ "redirect_uri", "http://localhost:55183/Auth/LoginCallback" },
{ "response_type", "code" },
// Provide the Code Challenge along with the method (Sha256)
{ "code_challenge", pkce.CodeChallenge },
{ "code_challenge_method", "S256" }
};
var content = new FormUrlEncodedContent(authorizeArgs);
var contentAsString = await content.ReadAsStringAsync();
// prepare the URL for the authorize endpoint
var url = $"{_appConfiguration.TapkeyAuthorizationServerUrl}/{_appConfiguration.TapkeyAuthorizationEndpointPath}?{contentAsString}";
return(Redirect(url));
}
public async System.Threading.Tasks.Task CreateAsynchronousSignature()
{
var client = new HttpClient();
var postData = new List <KeyValuePair <string, string> >();
//postData.Add(new KeyValuePair<string, string>("Name", "Grace Hopper"));
postData.Add(new KeyValuePair <string, string>("request", "{\"dataHash\": {\"algorithm\": \"SHA-256\",\"value\": \"GHgonhozPdhQkdMPABufb57U1CjVfgSb0OvU28ib0hA=\" }, \"level\": 0, \"metadata\": { } }"));
var formContent = new FormUrlEncodedContent(postData);
string requestContent = await formContent.ReadAsStringAsync();
var response = await client.PostAsync("https://tryout-catena-db.guardtime.net/api/v1/signatures", formContent);
var content = await response.Content.ReadAsStringAsync();
//Assert.That(response.IsSuccessStatusCode);
//Debug.WriteLine(message: "Request:" + requestContent);
//Debug.WriteLine(message: "Response:" + content.ToString());
}
/// <inheritdoc/>
public override Task <ISharedGroupFileInfo> GetFileInfoAsync(long groupNumber, string?id, bool fetchDownloadInfo, CancellationToken token = default)
{
InternalSessionInfo session = SafeGetSession();
CreateLinkedUserSessionToken(session.Token, token, out CancellationTokenSource? cts, out token);
KeyValuePair <string?, string?>[] payload = new KeyValuePair <string?, string?>[4]
{
new KeyValuePair <string?, string?>("sessionKey", session.SessionKey),
new KeyValuePair <string?, string?>("id", id ?? null),
new KeyValuePair <string?, string?>("target", groupNumber.ToString()),
new KeyValuePair <string?, string?>("withDownloadInfo", fetchDownloadInfo.ToString().ToLower()),
};
using HttpContent content = new FormUrlEncodedContent(payload);
string query = content.ReadAsStringAsync().GetAwaiter().GetResult();
return(_client.GetAsync($"{_options.BaseUrl}/file/info?{query}", token)
.AsApiRespV2Async <ISharedGroupFileInfo, GroupFileInfo>(token)
.DisposeWhenCompleted(cts));
}
public async Task <Result <OutputObject> > Convert(InputObject inputObject)
{
HttpClient httpClient = new HttpClient();
IEnumerable <KeyValuePair <string, string> > queryParameters = GetQueryParameters(inputObject);
FormUrlEncodedContent formUrlEncodedContent = new FormUrlEncodedContent(queryParameters);
UriBuilder uriBuilder = new UriBuilder(ApiBaseUri)
{
Query = await formUrlEncodedContent.ReadAsStringAsync()
};
HttpResponseMessage response = await httpClient.GetAsync(uriBuilder.Uri);
return(response.IsSuccessStatusCode
? Result.Ok(await GetFromContentAsync(response.Content, inputObject))
: Result.Failure <OutputObject>($"HTTP Error: {response.StatusCode}"));
}
/// <summary>
/// Returns All Past Sessions if user is owner
/// </summary>
public async Task <ResponseModel> GetPastSesstionsForOwner(int userId)
{
// IEnumerable<ParkingSession>
CheckJwt();
UriBuilder ub = new UriBuilder(rootUrl + "/api/parking/getpastsesstionsforowner");
using (var content = new FormUrlEncodedContent(new Dictionary <string, string>
{
{ "userId", userId.ToString() }
}))
{
ub.Query = await content.ReadAsStringAsync();
}
HttpResponseMessage response = await client.GetAsync(ub.Uri);
string resultString = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <ResponseModel>(resultString));
}
public async void SendMsg(string content)
{
await RefreshChatList();
foreach (string id in chatIDList)
{
var url = $"{this.TelegramUrl}/{this.TokenStr}/sendmessage";
using (var client = new HttpClient())
{
var queryParams = new Dictionary <string, string>();
queryParams.Add("chat_id", id);
queryParams.Add("text", content);
var encodedContent = new FormUrlEncodedContent(queryParams);
var paramsStr = await encodedContent.ReadAsStringAsync();
var res = await client.GetAsync($"{url}?{paramsStr}");
}
}
}
public async Task <CurrentWeatherDto> FindForCoordinatesAsync(double latitude, double longitude, string units = "", CancellationTokenSource cancellationTokenSource = default(CancellationTokenSource))
{
if (latitude == -1 && longitude == -1)
{
return(null);
}
if (cancellationTokenSource == null)
{
cancellationTokenSource = new CancellationTokenSource();
}
string query;
var result = new List <KeyValuePair <string, string> >();
result.Add(new KeyValuePair <string, string>("lat", latitude.ToString()));
result.Add(new KeyValuePair <string, string>("lon", longitude.ToString()));
if (!string.IsNullOrEmpty(units))
{
result.Add(new KeyValuePair <string, string>("units", units));
}
result.Add(new KeyValuePair <string, string>("appid", ApiConstants.WeatherApiKey));
using (var content = new FormUrlEncodedContent(result.ToArray()))
{
query = await content.ReadAsStringAsync();
}
var weather = await HttpProxy.Instance.GetAsync(Endpoint + "?" + query, cancellationTokenSource.Token);
var possibleErrorResponse = JsonConvert.DeserializeObject <ErrorResponse>(weather);
if (possibleErrorResponse.cod == 404)
{
return(null);
}
var weatherEntity = JsonConvert.DeserializeObject <CurrentWeather>(weather);
return(new CurrentWeatherDto(weatherEntity));
}
/// <summary>
/// submit this form, using a specified HttpClient.
/// </summary>
/// <remarks>
/// the request will be set up from the form values.
/// You can set up other options (like user-agent, timeout, cookies) before executing.
/// </remarks>
/// <returns>an async task.</returns>
/// <exception cref="System.ArgumentException">
/// if the form's absolute action URL cannot be determined.
/// Make sure you pass the document's base URI when parsing.
/// </exception>
public Task <HttpResponseMessage> SubmitAsync(HttpClient client, CancellationToken cancellationToken)
{
string action = HasAttr("action") ? AbsUrl("action") : BaseUri;
Validate.NotEmpty(action, "Could not determine a form action URL for submit. Ensure you set a base URI when parsing.");
var data = new FormUrlEncodedContent(this.FormData);
if (string.Equals(Attr("method"), "POST", StringComparison.OrdinalIgnoreCase))
{
// POST
return(client.PostAsync(action, data, cancellationToken));
}
else
{
// GET
var actionUrl = new UriBuilder(action);
actionUrl.Query = data.ReadAsStringAsync().Result;
return(client.GetAsync(actionUrl.Uri, cancellationToken));
}
}
public async Task PostFormUrlEncodedContentAsyncWrapperTout_WhenCalled_UseCorrectMessageContent()
{
string sentContent = default;
var testContent = new Dictionary <string, string> {
["test"] = "test"
};
var expectedContent = new FormUrlEncodedContent(testContent);
_moqHttpClientHandler.Protected().As <IHttpClientHandlerProtectedMembers>()
.Setup(handler => handler.SendAsync(It.IsAny <HttpRequestMessage>(), It.IsAny <CancellationToken>()))
.Returns <HttpRequestMessage, CancellationToken>(async(message, token) =>
{
sentContent = await message.Content.ReadAsStringAsync();
return(_defaultResponce);
});
var result = await _requestWrapper.PostFormUrlEncodedContentAsyncWrapper <TestModelClass>(testContent, _testEndpoing);
Assert.AreEqual(await expectedContent.ReadAsStringAsync(), sentContent);
}
private string CreateQueryString(List <DateTime> dates, string targetCurrency,
string baseCurrency)
{
string queryString = "";
List <DateTime> datesForRequest = SetRequestStartEndDates(dates);
using (var content = new FormUrlEncodedContent(new Dictionary <string, string>()
{
{ "start_at", DateTimeUtil.DateTimeToDateString(datesForRequest[0]) },
{ "end_at", DateTimeUtil.DateTimeToDateString(datesForRequest[datesForRequest.Count - 1]) },
{ "symbols", $"{targetCurrency}" },
{ "base", $"{baseCurrency}" }
}))
{
queryString = baseUri + content.ReadAsStringAsync().Result;
}
return(queryString);
}
public async Task <NaomiResult> GetSearchResults(string file, NaomiOptions options = null)
{
if (!Uri.IsWellFormedUriString(file, UriKind.Absolute))
{
throw new ArgumentException("File URI is not well-formed.");
}
options = options ?? NaomiOptions.Default;
var qDict = options.BuildContent(file, ApiKey);
string query;
using (var content = new FormUrlEncodedContent(qDict.ToDictionary(k => k.Key, k => k.Value.ToString())))
{
query = content.ReadAsStringAsync().Result;
string response = await Http.GetStringAsync("search.php?" + query);
return(JsonConvert.DeserializeObject <NaomiResult>(response));
}
}
public async Task DeleteStaff(string staffId)
{
var data = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("id", staffId)
});
var query = data.ReadAsStringAsync().Result;
using (HttpResponseMessage response = await apiHelper.ApiClient.PostAsync("api/admin/delete?" + query, null))
{
if (response.IsSuccessStatusCode)
{
}
else
{
throw new Exception(response.ReasonPhrase);
}
}
}
async Task <string> prepareUrlParameters(string url, Dictionary <string, string> parameters)
{
string requestUri;
if (parameters != null)
{
using (var encodedParams = new FormUrlEncodedContent(parameters))
{
var value = await encodedParams.ReadAsStringAsync();
requestUri = string.Format("{0}?{1}", url, value);
}
}
else
{
requestUri = url;
}
return(requestUri);
}
private async Task <Uri> RenderUriAsync(string uri, object queryString = null, bool websocket = false)
{
if (queryString != null)
{
var keyValueContent = ToKeyValue(queryString);
var formUrlEncodedContent = new FormUrlEncodedContent(keyValueContent);
var urlEncodedString = await formUrlEncodedContent.ReadAsStringAsync();
uri += "?" + urlEncodedString;
}
return(new Uri(
websocket
? new Uri(BaseURL.ToString() // there's got to be a cleaner way to do this...
.Replace("http://", "ws://")
.Replace("https://", "wss://"))
: BaseURL,
uri
));
}
public static string InitializeParamsQueryForClient(string origin, string destination, string departureDate, string returnDate, string adults, string currency)
{
//origin = "NYC";
//destination = "MAD";
DateTime departureDateDateTime = Convert.ToDateTime(departureDate);
departureDate = departureDateDateTime.ToString("yyyy-MM-dd");
if (!String.IsNullOrEmpty(returnDate))
{
DateTime returnDateDateTime = Convert.ToDateTime(returnDate);
returnDate = departureDateDateTime.ToString("yyyy-MM-dd");
}
//adults = "5";
//currency = "USD";
var paramsDictionary = new Dictionary <string, string>();
paramsDictionary.Add(Origin, origin);
paramsDictionary.Add(Destination, destination);
paramsDictionary.Add(DepartureDate, departureDate);
if (!String.IsNullOrEmpty(returnDate))
{
paramsDictionary.Add(ReturnDate, returnDate);
}
paramsDictionary.Add(Adults, adults);
if (!String.IsNullOrEmpty(currency))
{
paramsDictionary.Add(Currency, currency);
}
//paramsDictionary.Add(MaxOffers, ConfigurationManager.AppSettings[MaxOffers]);
var paramsUrlEncoded = new FormUrlEncodedContent(paramsDictionary);
var paramsQuery = paramsUrlEncoded.ReadAsStringAsync().Result;
paramsQuery = paramsQuery.Insert(0, "?");
return(paramsQuery);
}
/// <summary>
/// Pobranie danych tokena autoryzującego, używane przy logowaniu
/// </summary>
/// <param name="login">Login</param>
/// <param name="password">Hasło</param>
/// <returns>Dictionary zawierający dane tokena</returns>
public Dictionary <string, string> GetToken(string login, string password)
{
HttpContent content = new FormUrlEncodedContent(new Dictionary <string, string>()
{
{ "grant_type", "password" },
{ "username", login },
{ "password", password }
});
try
{
using (HttpResponseMessage responseMessage = Task.Run(async() => { return(await _httpClient.PostAsync("Token", content)); }).Result)
{
if (responseMessage.StatusCode == HttpStatusCode.OK)
{
content = responseMessage.Content;
string jsonString = Task.Run(async() => { return(await content.ReadAsStringAsync()); }).Result;
Dictionary <string, string> tokenData = JsonConvert.DeserializeObject <Dictionary <string, string> >(jsonString);
return(tokenData);
}
else if (responseMessage.StatusCode == HttpStatusCode.BadRequest)
{
_lastErrorMessage = "Niepoprawne dane logowania";
}
else
{
_lastErrorMessage = "Błąd połączenia z serwerem";
}
}
}
catch (Exception exc)
{
_lastErrorMessage = "Błąd połączenia z serwerem";
}
finally
{
content.Dispose();
}
return(null);
}
// Throws on timeouts and server errors. Never returns null.
string SendRequest(HttpMethod method, string relativeUri, IEnumerable <KV> param)
{
if (param.Any())
{
_log.Info("OUT: {0} {1} {{{2}}}", method.ToString().ToUpper(), relativeUri,
String.Join(", ", param.Select(kv => String.Format("{0}={1}", kv.Key, kv.Value))));
}
else
{
_log.Info("OUT: {0} {1}", method.ToString().ToUpper(), relativeUri);
}
try
{
var form = new FormUrlEncodedContent(param);
var req = new HttpRequestMessage();
req.Method = method;
if (method == HttpMethod.Get)
{
string query = form.ReadAsStringAsync().Result;
if (query.Length > 0)
{
Condition.Requires(relativeUri, "relativeUri").DoesNotContain("?").DoesNotContain("#");
relativeUri = String.Format("{0}?{1}", relativeUri, query);
}
}
else if (method == HttpMethod.Post)
{
req.Content = form;
}
req.RequestUri = new Uri(relativeUri, UriKind.Relative);
HttpResponseMessage resp = _http.SendAsync(req, HttpCompletionOption.ResponseContentRead).Result;
string content = resp.EnsureSuccessStatusCode().Content.ReadAsStringAsync().Result;
_log.Info("IN: {0}", content);
return(content);
}
catch (Exception e)
{
_log.Warn(e, "IO error");
throw;
}
}
/// <summary>
/// 账单流水查询
/// </summary>
/// <param name="currency">币种，如btc</param>
/// <param name="type">填写相应数字：1:充值2:提现13:撤销提现18:转入合约账户19:合约账户转出20:转入子账户21:子账户转出28:领取29:转入指数交易区30:指数交易区转出 31:转入点对点账户32:点对点账户转出 33:转入币币杠杆账户 34:币币杠杆账户转出 37:转入币币账户 38:币币账户转出</param>
/// <param name="from">请求此页码之后的分页内容（举例页码为：1，2，3，4，5。from 4 只返回第5页，to 4只返回第3页）</param>
/// <param name="to">请求此页码之前的分页内容（举例页码为：1，2，3，4，5。from 4 只返回第5页，to 4只返回第3页）</param>
/// <param name="limit">分页返回的结果集数量，默认为100，最大为100，按时间顺序排列，越早下单的在前面</param>
/// <returns></returns>
public async Task <JContainer> getLedgerAsync(string currency, string type, int?from, int?to, int?limit)
{
var url = $"{this.BASEURL}{this.ACCOUNT_SEGMENT}/ledger";
using (var client = new HttpClient(new HttpInterceptor(this._apiKey, this._secret, this._passPhrase, null)))
{
var queryParams = new Dictionary <string, string>();
if (!string.IsNullOrEmpty(currency))
{
queryParams.Add("currency", currency);
}
if (!string.IsNullOrEmpty(type))
{
queryParams.Add("type", type);
}
if (from.HasValue)
{
queryParams.Add("from", from.Value.ToString());
}
if (to.HasValue)
{
queryParams.Add("to", to.Value.ToString());
}
if (limit.HasValue)
{
queryParams.Add("limit", limit.Value.ToString());
}
var encodedContent = new FormUrlEncodedContent(queryParams);
var paramsStr = await encodedContent.ReadAsStringAsync();
var res = await client.GetAsync($"{url}?{paramsStr}");
var contentStr = await res.Content.ReadAsStringAsync();
if (contentStr[0] == '[')
{
return(JArray.Parse(contentStr));
}
return(JObject.Parse(contentStr));
}
}
public async Task <Room[]> SearchRoomAsync(SearchRoomRequest request)
{
var uriString = _baseUrl + "/rooms?";
var parameters = new Dictionary <string, string>()
{
{ "name", request.ApplicationName },
{ "version", request.Version }
};
using (var content = new FormUrlEncodedContent(parameters))
{
uriString += await content.ReadAsStringAsync();
}
var uri = new Uri(uriString);
using (var response = await _httpClient.GetAsync(uri))
{
var responseStream = await response.Content.ReadAsStreamAsync();
var responseSerializer = new DataContractJsonSerializer(typeof(SearchRoomResponse));
var apiResponse = responseSerializer.ReadObject(responseStream) as SearchRoomResponse;
if (apiResponse == null || !apiResponse.Success)
{
throw new RoomApiException(apiResponse?.Error);
}
if (apiResponse.Rooms == null)
{
return(new Room[0]);
}
foreach (var room in apiResponse.Rooms)
{
room.ApplicationName = request.ApplicationName;
room.Version = request.Version;
}
return(apiResponse.Rooms);
}
}
/// <summary>
/// 获取成交明细
/// </summary>
/// <param name="instrument_id">合约名称，如BTC-USD-SWAP</param>
/// <param name="order_id">订单ID</param>
/// <param name="from">分页游标开始</param>
/// <param name="to">分页游标截至</param>
/// <param name="limit">分页数据数量，默认100</param>
/// <returns></returns>
public async Task <List <Fill> > getFillsAsync(string instrument_id, string order_id, int?from, int?to, int?limit)
{
var url = $"{this.BASEURL}{this.SWAP_SEGMENT}/fills";
using (var client = new HttpClient(new HttpInterceptor(this._apiKey, this._secret, this._passPhrase, null)))
{
var queryParams = new Dictionary <string, string>();
queryParams.Add("instrument_id", instrument_id);
queryParams.Add("order_id", order_id);
if (from.HasValue)
{
queryParams.Add("from", from.Value.ToString());
}
if (to.HasValue)
{
queryParams.Add("to", to.Value.ToString());
}
if (limit.HasValue)
{
queryParams.Add("limit", limit.Value.ToString());
}
var encodedContent = new FormUrlEncodedContent(queryParams);
var paramsStr = await encodedContent.ReadAsStringAsync();
var res = await client.GetAsync($"{url}?{paramsStr}");
var contentStr = await res.Content.ReadAsStringAsync();
if (contentStr[0] == '[')
{
JContainer jContainer = JArray.Parse(contentStr);
var result = ToList <Fill>(contentStr);
return(result);
}
else
{
var result = ToObject <ErrorResult>(contentStr);
throw new OKExException("Can't parse to list. json string = " + contentStr);
}
}
}
/// <summary>
/// Returns all parking session that are inside time interval
/// </summary>
public async Task <ResponseModel> GetSessionsInPeriod(int userId, DateTime since, DateTime until)
{
// IEnumerable<ParkingSession>
CheckJwt();
UriBuilder ub = new UriBuilder(rootUrl + "/api/parking/getsessionsinperiod");
using (var content = new FormUrlEncodedContent(new Dictionary <string, string>
{
{ "userId", userId.ToString() },
{ "since", since.ToString() },
{ "until", until.ToString() }
}))
{
ub.Query = await content.ReadAsStringAsync();
}
HttpResponseMessage response = await client.GetAsync(ub.Uri);
string resultString = await response.Content.ReadAsStringAsync();
return(JsonConvert.DeserializeObject <ResponseModel>(resultString));
}