public void ToQueryString() { var Collection = new Dictionary<string, string>(); Collection.Add("A", "1"); Collection.Add("B", "2"); Assert.Equal("?A=1&B=2", Collection.ToQueryString()); }
public async Task<byte[]> GetEpisodePictureASync(int episodeId, int width, int height) { var postData = new Dictionary<string, string>(); postData.Add("id", episodeId); if (width != 0) postData.Add("width", width); if (height != 0) postData.Add("height", height); postData.Add("picked", "show"); var options = "?" + postData.ToQueryString(); var response = await Get(EpisodeUrl + options); if (response.StatusCode == HttpStatusCode.NotFound) return null; var stream = await response.Content.ReadAsBufferAsync(); var byteArray = stream.ToArray(); return byteArray.Length == 0 ? null : byteArray; }
public async Task<IEnumerable<Models.Products.ProductSuggestItemOutputModel>> GetSuggestSimilarDocumentsAsync(int id, string offerType = null, string domainLanguage = "fr", int take = 3) { using (var dclient = this.CreateClient()) { var client = dclient.Client; var parameters = new Dictionary<string, string>(); var dico = new Dictionary<string, string>(){ { "domainLanguage", domainLanguage }, { "take", take.ToString() }, { "offerType", offerType } }; var queryString = dico.ToQueryString(); var url = "api/v2/products/{id}/suggests/similar".Replace("{id}", id.ToString()); if (!string.IsNullOrEmpty(queryString)) url = url + "?" + queryString; var response = await client.GetAsync(this.GetUri(url)).ConfigureAwait(false); await this.HandleResponseAsync(response).ConfigureAwait(false); if (response.IsSuccessStatusCode) return (await this.GetObjectAsync<IEnumerable<Models.Products.ProductSuggestItemOutputModel>>(response.Content).ConfigureAwait(false)); return Enumerable.Empty<Models.Products.ProductSuggestItemOutputModel>(); } }
public async Task<RootAuth> AuthASync(string login, string password) { var postData = new Dictionary<string, string>(); postData.Add("login", login); var md5Password = MD5CryptoServiceProvider.GetMd5String(password); postData.Add("password", md5Password); var options = "?" + postData.ToQueryString(); RootAuth response; try { response = await Post<RootAuth>(AuthUrl + options, null); ValidateResponse(response); } catch (ConnectionException ex) { if (!string.IsNullOrEmpty(ex.ResponseContent)) ValidateResponse(ex.ResponseContent); throw; } return response; }
public override string ToString() { Dictionary<string, string> parameters = new Dictionary<string, string>(); if (Lat.HasValue && Lon.HasValue) { parameters.Add("cp", string.Format("{0}~{1}", Lat.Value, Lon.Value)); } if (Zoom.HasValue) { parameters.Add("lvl", Zoom.Value.ToString()); } if (!String.IsNullOrWhiteSpace(Query)) { parameters.Add("q", Query); } if (!String.IsNullOrWhiteSpace(Where)) { parameters.Add("where", Where); } if (TrafficOn.HasValue) { parameters.Add("trfc", TrafficOn.Value ? "1" : "0"); } if (RoadView.HasValue) { parameters.Add("sty", RoadView.Value ? "r" : "a"); } return parameters.ToQueryString("bingmaps://dreamteam-mobile.com/"); }
public async Task <string> GetStringAsync(string path, Dictionary <string, object> parameters) { var client = await GetHttpClientAsync(); var result = await client.GetStringAsync($"{path}?{parameters?.ToQueryString()}", CheckErrorAsync); return(result); }
public void ToQueryStringOneValue() { var dict = new Dictionary<string, string>(); dict["foo"] = "bar"; Assert.AreEqual("?foo=bar", dict.ToQueryString()); }
public async Task <QueryResult <T> > GetQueryResultAsync <T>(string segments, Dictionary <string, object> parameters) where T : class { var client = await GetHttpClientAsync(); var result = await client.GetAsync <QueryResult <T> >($"{segments}?{parameters?.ToQueryString()}", CheckErrorAsync); return(result); }
public void ToQueryStringUnsafeValues() { var dict = new Dictionary<string, string>(); dict["foo"] = "#?&%="; Assert.AreEqual("?foo=%23%3F%26%25%3D", dict.ToQueryString()); }
public async Task <T> PutAsync <T>(string segments, Dictionary <string, object> parameters, object model) { var client = await GetHttpClientAsync(); var result = await client.PutAsync <T>($"{segments}?{parameters?.ToQueryString()}", model, CheckErrorAsync); return(result); }
public async Task <ExecuteResult> StartPlanAsyncWithParametersAsQueryString(Plan plan, long planInstanceId, bool dryRun = false, Dictionary <string, string> dynamicParameters = null) { string planString = plan.ToYaml(); planString = CryptoHelpers.Encode(planString); string requestUri = $"{_rootPath}/{planInstanceId}/?dryRun={dryRun}{dynamicParameters?.ToQueryString( asPartialQueryString: true )}"; return(await PostAsync <string, ExecuteResult>(planString, requestUri)); }
public void ToQueryStringTwoValues() { var dict = new Dictionary<string, string>(); dict["foo"] = "bar"; dict["ba"] = "zinga"; Assert.AreEqual("?foo=bar&ba=zinga", dict.ToQueryString()); }
public void should_convert_string_dictionary_to_query_string() { var values = new Dictionary<string, string> { {"key1", "value1"}, {"key2", "value2"} }; values.ToQueryString().Should().Be("key1=value1&key2=value2"); }
/// <summary> /// transform a dictionary into the query string that is translated in byte array then /// </summary> /// <param name="items"></param> /// <returns></returns> public static byte[] PostBytes(Dictionary<string, string> items) { if (items == null || !items.Any()) return null; var bytes = Encoding.UTF8.GetBytes(items.ToQueryString()); return bytes.Any() ? bytes : null; }
public static String getSignature(Dictionary <String, String> param, String secret) { string pStr = param.ToQueryString(Encoding.UTF8); byte[] pByte = Encoding.UTF8.GetBytes(pStr + secret); MD5 md5 = new MD5CryptoServiceProvider(); byte[] result = md5.ComputeHash(pByte); return(Convert.ToBase64String(result)); }
public async Task <long> StartPlanAsync(string planName, bool dryRun = false, string requestNumber = null, Dictionary <string, string> dynamicParameters = null, string nodeRootUrl = null) { requestNumber = requestNumber?.ToUrlEncodedOrNull("&requestNumber"); nodeRootUrl = nodeRootUrl?.ToUrlEncodedOrNull("&nodeRootUrl"); string qs = $"?dryRun={dryRun}{requestNumber}{nodeRootUrl}{dynamicParameters?.ToQueryString( asPartialQueryString: true )}"; string requestUri = $"{_rootPath}/{planName}/start/{qs}"; return(await GetAsync <long>(requestUri)); }
public Task <EventsResponse> GetEventsAsync(DateTime startDate, DateTime endDate, CancellationToken ct) { this.SetHeaders(); this.ValidateDates(ref startDate, ref endDate); var dic = new Dictionary <string, object>(); dic.Add("startDate", this.FormatDate(startDate)); dic.Add("endDate", this.FormatDate(endDate)); return(this.GetAsync <EventsResponse>("/v2/users/self/events" + dic.ToQueryString(), ct)); }
/// <summary> /// Helper to build requestUri for each server endpoint and include optional querystring parameters /// </summary> public static string GetRequestUri(Uri baseUri, string endPoint, Dictionary <string, string> parameters = null) { // Build QueryString if parameters are available var queryString = parameters != null?parameters.ToQueryString() : string.Empty; // Return Uri formatted to include base, endpoint and optional querystring var requestUri = string.Format("{0}{1}{2}", baseUri, endPoint, queryString); return(requestUri); }
public void should_override_default_delimiters_when_writing() { var values = new Dictionary<string, string> { {"key1", "value1"}, {"key2", "value2"} }; values.ToQueryString(paramDelimiter: ' ', valueDelimiter: '@') .Should().Be("key1@value1 key2@value2"); }
public void TestToQueryString() { Dictionary <string, string> testData = new Dictionary <string, string>(); string expectedResult = ""; Assert.AreEqual(expectedResult, testData.ToQueryString()); testData.Add("param", "Value"); expectedResult = "param=Value"; Assert.AreEqual(expectedResult, testData.ToQueryString()); testData.Add("2", "v2"); expectedResult = "2=v2¶m=Value"; Assert.AreEqual(expectedResult, testData.ToQueryString()); }
public void should_encode_values() { var values = new Dictionary <string, string> { { "name", "John Smith" }, { "email", "*****@*****.**" } }; values.ToQueryString(encode: true) .Should().Be("name=John+Smith&email=email%40website.com"); }
public void should_override_default_delimiters_when_writing() { var values = new Dictionary <string, string> { { "key1", "value1" }, { "key2", "value2" } }; values.ToQueryString(paramDelimiter: ' ', valueDelimiter: '@') .Should().Be("key1@value1 key2@value2"); }
public void PairsWithNullValuesAreIgnored() { var data = new Dictionary <string, object>() { ["first"] = "1", ["second"] = null }; Assert.AreEqual("first=1", data.ToQueryString()); }
public void should_encode_values() { var values = new Dictionary<string, string> { {"name", "John Smith"}, {"email", "*****@*****.**"} }; values.ToQueryString(encode: true) .Should().Be("name=John+Smith&email=email%40website.com"); }
public void MultipleValueConcatenation() { var data = new Dictionary <string, object>() { ["first"] = "1", ["second"] = 2 }; Assert.AreEqual("first=1&second=2", data.ToQueryString()); }
internal static async Task<T> Get<T>(string path, Dictionary<string, object> query = null, CancellationToken cancellationToken = default) { var queryString = string.Empty; if (query != null) { queryString = query.ToQueryString(); } try { var response = await HttpClient.GetAsync(path + queryString, cancellationToken).ConfigureAwait(false); var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false); if (!response.IsSuccessStatusCode) { Error error = null; try { error = JsonSerializer.Deserialize<Error>(json); } catch { // ignore } if (!string.IsNullOrEmpty(error?.ErrorMessage)) { throw new BitFlyerApiException(path, error.ErrorMessage, error); } throw new BitFlyerApiException(path, $"Error has occurred. Response StatusCode:{response.StatusCode} ReasonPhrase:{response.ReasonPhrase}."); } return JsonSerializer.Deserialize<T>(json); } catch (WebException ex) { switch (ex.Status) { case WebExceptionStatus.RequestCanceled: case WebExceptionStatus.Timeout: throw new BitFlyerApiException(path, "Request Timeout"); default: throw; } } catch (TaskCanceledException) { throw new BitFlyerApiException(path, "Request Timeout"); } catch (OperationCanceledException) { throw new BitFlyerApiException(path, "Request Timeout"); } }
public static string GetObjectUrl(string storageUrl, string containerId, string objectId, Dictionary<string, string> queryParams = null) { var url = storageUrl + "/" + containerId.Encode() + "/" + objectId.Encode(); if (queryParams != null) { url += queryParams.ToQueryString(); } return url; }
public void OneItemDictionaryTest() { var dict = new Dictionary <string, string>() { { "bob", "1" } }; var value = dict.ToQueryString(); Assert.AreEqual("?bob=1", value); }
/// <summary> /// transform a dictionary into the query string that is translated in byte array then /// </summary> /// <param name="items"></param> /// <returns></returns> public static byte[] PostBytes(Dictionary <string, string> items) { if (items == null || !items.Any()) { return(null); } var bytes = Encoding.UTF8.GetBytes(items.ToQueryString()); return(bytes.Any() ? bytes : null); }
public static string GetAccountUrl(string storageUrl, Dictionary <string, string> queryParams = null) { var url = storageUrl; if (queryParams != null) { url += queryParams.ToQueryString(); } return(url); }
public static void InitContent(dynamic viewBag, string nameSpace, string page, Dictionary<string, string> dimensions) { var repository = new ContentRepository( new Uri(System.Configuration.ConfigurationManager.AppSettings["NeuCMSServiceURL"]) ); var content = repository.GetViewContents(nameSpace,page, dimensions.ToQueryString()).ToList(); dynamic neuCMSContent = new NeuCMSContent(content); viewBag.NeuContent = neuCMSContent; }
public static string GetAccountUrl(string storageUrl, Dictionary<string, string> queryParams = null) { var url = storageUrl; if (queryParams != null) { url += queryParams.ToQueryString(); } return url; }
public static string GetObjectUrl(string storageUrl, string containerId, string objectId, Dictionary <string, string> queryParams = null) { var url = storageUrl + "/" + containerId.Encode() + "/" + objectId.Encode(); if (queryParams != null) { url += queryParams.ToQueryString(); } return(url); }
/// <summary> /// 远程批量获取语言包 /// </summary> /// <param name="input">需要翻译的词条(携带~符号)</param> /// <param name="apiurl">远程接口地址</param> /// <param name="languages">要翻译的语种</param> /// <returns></returns> public static Dictionary <string, Dictionary <Language, string> > Get(this string[] input, string apiurl, params Language[] languages) { Dictionary <string, string> data = new Dictionary <string, string>() { { "Content", string.Concat("[", string.Join(",", input.Select(t => $"\"{ HttpUtility.JavaScriptStringEncode(t) }\"")), "]") }, { "Language", string.Join(",", languages) }, { "Action", "TranslateData" } }; string result = NetAgent.UploadData(apiurl, data.ToQueryString(), Encoding.UTF8); return(JsonConvert.DeserializeObject <Dictionary <string, Dictionary <Language, string> > >(result)); }
public static void InitContent(dynamic viewBag, string nameSpace, string page, Dictionary <string, string> dimensions) { var repository = new ContentRepository( new Uri(System.Configuration.ConfigurationManager.AppSettings["NeuCMSServiceURL"]) ); var content = repository.GetViewContents(nameSpace, page, dimensions.ToQueryString()).ToList(); dynamic neuCMSContent = new NeuCMSContent(content); viewBag.NeuContent = neuCMSContent; }
private async Task <string> SendRequest(HttpMethod method, string path, Dictionary <string, object> query = null, object body = null) { var queryString = string.Empty; if (query != null) { queryString = query.ToQueryString(); } using (var message = new HttpRequestMessage(method, path + queryString)) { byte[] bodyBytes = null; if (body != null) { bodyBytes = JsonSerializer.Serialize(body); message.Content = new ByteArrayContent(bodyBytes); message.Content.Headers.ContentType = MediaType; } var timestamp = DateTimeOffset.UtcNow.ToUnixTime().ToString(); var payload = bodyBytes == null?Encoding.UTF8.GetBytes(timestamp + method + path + queryString) : Encoding.UTF8.GetBytes(timestamp + method + path + queryString).Concat(bodyBytes).ToArray(); var hash = SignWithHmacsha256(payload); message.Headers.Add("ACCESS-KEY", _apiKey); message.Headers.Add("ACCESS-TIMESTAMP", timestamp); message.Headers.Add("ACCESS-SIGN", hash); try { var response = await HttpClient.SendAsync(message); var responseJson = await response.Content.ReadAsStringAsync(); if (!response.IsSuccessStatusCode) { var error = JsonSerializer.Deserialize <Error>(responseJson); if (!string.IsNullOrEmpty(error?.ErrorMessage)) { throw new BitFlyerApiException(path, error.ErrorMessage, error); } throw new BitFlyerApiException(path, $"Error has occurred. Response StatusCode:{response.StatusCode} ReasonPhrase:{response.ReasonPhrase}."); } return(responseJson); } catch (TaskCanceledException) { throw new BitFlyerApiException(path, "Request Timeout"); } } }
public async Task<bool> UnArchiveASync(int showId) { var postData = new Dictionary<string, string>(); postData.Add("id", showId); var options = "?" + postData.ToQueryString(); await Delete(ArchiveUrl + options); return true; }
public static string ToQueryString(this TaxLocationInfo locationInfo) { var dictionary = new Dictionary <string, object> { ["country"] = locationInfo.Country, ["state"] = locationInfo.State, ["city"] = locationInfo.City, ["street"] = locationInfo.Street }; return(dictionary.ToQueryString()); }
public async Task <bool> UnArchiveASync(int showId) { var postData = new Dictionary <string, string>(); postData.Add("id", showId); var options = "?" + postData.ToQueryString(); await Delete(ArchiveUrl + options); return(true); }
public void ToQueryString_WhenDictionaryIsEmpty_QueryStringIsEmpty() { // Arrange var parameters = new Dictionary <string, string>(); string expected = string.Empty; // Act var result = parameters.ToQueryString(); // Assert result.Should().Be(expected); }
public void ShouldGenerateBasicQueryString() { var queryCollection = new Dictionary <string, object> { { "heroName", "yasuo" }, { "filter", "assassin" } }; var result = queryCollection.ToQueryString(); Assert.Equal("heroName=yasuo&filter=assassin", result); }
public void MalformedRealm() { var values = new Dictionary<string, string> { { "realm", "malformed" } }; var client = new HttpClient(); var result = client.GetAsync(baseAddress + values.ToQueryString()).Result; Assert.AreEqual<HttpStatusCode>(HttpStatusCode.BadRequest, result.StatusCode); }
public void ShouldFormatKeyToLower() { var queryCollection = new Dictionary <string, object> { { "HeroName", "yasuo" }, { "Level", 100 } }; var result = queryCollection.ToQueryString(opts => opts.KeyFormatter = key => key.ToLower()); Assert.Equal("heroname=yasuo&level=100", result); }
public void Test() { var entity = EncryptServerHelper.ShowEncrypt("o8KB3uBl_0QJFEpnFUCnyYMPpZ9Y", "9EAFA395-3AFC-4D41-93CD-F801FBF8C8A3"); var dictionary = new Dictionary<object, object> { {"Encrypt",entity.Encrypt}, {"Sign",entity.Sign}, }; var postDataStr = dictionary.ToQueryString(); var requset = WebHelper.WebFormPost("http://hyinvite.21move.net/api/BindingUnbundling/", postDataStr); }
public async Task <GetBotPositionsResponse> GetBotPositions(GetBotPositionsRequest request) { var queryParameters = new Dictionary <string, string>(); queryParameters.AddValueIfNotNullOrEmpty("signalProvider", _options.SignalProvider); queryParameters.AddValueIfNotNullOrEmpty("signalProviderKey", _options.SignalProviderKey); queryParameters.AddValueIfNotNullOrEmpty("exchange", request.Exchange.ToString().ToLower()); queryParameters.AddValueIfNotNullOrEmpty("baseAsset", request.BaseAsset); var queryString = queryParameters.ToQueryString(); return(await this.GetAsync <GetBotPositionsResponse>($"v2/getBotAssetsPct{queryString}")); }
public void CanCreateUrlQueryFromEmptyDictionary() { // Arrange var parameters = new Dictionary <string, string>(); string expected = string.Empty; // Act var result = parameters.ToQueryString(); // Assert Assert.AreEqual(expected, result); }
public void ToQueryString_WhenDictionaryIsEmpty_QueryStringIsEmpty() { // Arrange var parameters = new Dictionary <string, string>(); string expected = string.Empty; // Act var result = parameters.ToQueryString(); // Assert Assert.AreEqual(expected, result); }
public void NoCredentials() { var values = new Dictionary<string, string> { { "realm", rp } }; var client = new HttpClient(); var result = client.GetAsync(baseAddress + values.ToQueryString()).Result; Assert.AreEqual<HttpStatusCode>(HttpStatusCode.Unauthorized, result.StatusCode); }
public async Task <GetOrderInfoResponse> GetOrderInfo(GetOrderInfoRequest request) { var queryParameters = new Dictionary <string, string>(); queryParameters.AddValueIfNotNullOrEmpty("signalProvider", _options.SignalProvider); queryParameters.AddValueIfNotNullOrEmpty("signalProviderKey", _options.SignalProviderKey); queryParameters.AddValueIfNotNullOrEmpty("extId", request.ExternalId); queryParameters.AddValueIfNotNullOrEmpty("orderId", request.OrderId); var queryString = queryParameters.ToQueryString(); return(await this.GetAsync <GetOrderInfoResponse>($"v2/getOrderInfo{queryString}")); }
public Task<string> GeneratePasswordAsync(int minLength, int maxLength) { var url = "api/v1/accounts/generated-passwords"; var dico = new Dictionary<string, string>() { { "minLength", minLength.ToString() }, { "maxLength", maxLength.ToString() }, }; url = url + "?" + dico.ToQueryString(); return this.PostWithResultAsync<string>(url, null); }
public void MalformedRealm() { var values = new Dictionary<string, string> { { "realm", "malformed" } }; var client = new HttpClient(); client.SetBasicAuthenticationHeader(Constants.Credentials.ValidUserName, Constants.Credentials.ValidPassword); var result = client.GetAsync(baseAddress + values.ToQueryString()).Result; Assert.AreEqual<HttpStatusCode>(HttpStatusCode.BadRequest, result.StatusCode); }
public async Task<Message> DeleteASync(int id) { var postData = new Dictionary<string, string>(); postData.Add("id", id); var options = "?" + postData.ToQueryString(); var response = await Delete<RootMessage>(SendDeleteUrl + options); ValidateResponse(response); return response.Message; }
public async Task<IList<Message>> GetDiscussionASync(int id) { var postData = new Dictionary<string, string>(); postData.Add("id", id); var options = "?" + postData.ToQueryString(); var response = await Get<MessageList>(DiscussionUrl + options); ValidateResponse(response); return response.Messages; }
public async Task<string> GenerateIframeTagAsync(int id, Models.Products.EmbedGenerateModel features) { var parameters = new Dictionary<string, string>(); this.generateParameters(parameters, features); var queryString = parameters.ToQueryString(); var url = ApiUrls.EmbedUrl.Replace("{id}", id.ToString()); if (!string.IsNullOrEmpty(queryString)) url = url + "?" + queryString; var model = await this.GetAsync<Models.Products.EmbedResponse>(url); if (model == null) return string.Empty; return model.Content; }
public async Task<IList<Show>> SearchASync(string title) { var postData = new Dictionary<string, string>(); postData.Add("title", title); var options = "?" + postData.ToQueryString(); var response = await Get<ShowList>(SearchUrl + options); ValidateResponse(response); return response.Shows; }
public async Task<Comment> DeleteAsync(int commentId) { var postData = new Dictionary<string, string>(); postData.Add("id", commentId); var options = "?" + postData.ToQueryString(); var response = await Delete<RootComment>(DeleteUrl + options); ValidateResponse(response); return response.Comment; }
public async Task<ProductCommentsOutput> GetCommentsAsync(int productId, int skip = 0, int take = 5, int repliesTake = 3) { var url = "api/v1/products/" + productId + "/comments"; var dico = new Dictionary<string, string>(){ { "skip", skip.ToString() }, { "take", take.ToString() }, { "repliesTake", repliesTake.ToString() } }; url = url + "?" + dico.ToQueryString(); var model = await this.GetAsync<ProductCommentsOutput>(url); if (model == null) return new ProductCommentsOutput() { Count = -1, Comments = Enumerable.Empty<ProductCommentOutput>() }; return model; }
public async Task<Member> BlockASync(int memberId) { var postData = new Dictionary<string, string>(); postData.Add("id", memberId); var options = "?" + postData.ToQueryString(); var response = await Post<RootMember>(BlockUnblockUrl + options, null); ValidateResponse(response); return response.Member; }
public async Task<Member> RemoveASync(int memberId) { var postData = new Dictionary<string, string>(); postData.Add("id", memberId); var options = "?" + postData.ToQueryString(); var response = await Delete<RootMember>(AddRemoveUrl + options); ValidateResponse(response); return response.Member; }
public void ValidUserNameCredential() { var values = new Dictionary<string, string> { { "realm", rp } }; var client = new HttpClient(); client.SetBasicAuthenticationHeader(Constants.Credentials.ValidUserName, Constants.Credentials.ValidPassword); var result = client.GetAsync(baseAddress + values.ToQueryString()).Result; Assert.AreEqual<HttpStatusCode>(HttpStatusCode.OK, result.StatusCode); Assert.AreEqual<string>("application/json", result.Content.Headers.ContentType.MediaType); }