public void OnlyNameSet()
{
var queryStringBuilder = new QueryStringBuilder();
var objectToConvert = new TestSerialisationObject {Name = "test"};
var queryString = queryStringBuilder.ToQueryString(objectToConvert);
StringAssert.AreEqualIgnoringCase("name=test",queryString);
}
public async Task<string> StoreFromStreamAsync(Stream stream, string filename = null, string extension = null, string rootFolder = null, string path = null)
{
if (stream == null) throw new ArgumentNullException("stream");
var qs = new QueryStringBuilder();
if (string.IsNullOrWhiteSpace(path))
{
if (!string.IsNullOrWhiteSpace(filename))
qs["filename"] = filename;
if (!string.IsNullOrWhiteSpace(extension))
qs["extension"] = extension;
if (!string.IsNullOrWhiteSpace(rootFolder))
qs["rootFolder"] = rootFolder;
var resp = await _client.PostAsync(qs.ToString(), new StreamContent(stream)).ConfigureAwait(false);
await EnsureSuccess(resp);
path = await resp.Content.ReadAsStringAsync().ConfigureAwait(false);
}
else
{
qs["path"] = path;
var resp = await _client.PutAsync(qs.ToString(), new StreamContent(stream)).ConfigureAwait(false);
await EnsureSuccess(resp);
path = await resp.Content.ReadAsStringAsync().ConfigureAwait(false);
}
return path;
}
public void SetEnumerableString()
{
var builder = new QueryStringBuilder();
var target = new SetEnumerableStringTarget(builder);
target.Prop = new[] {"c", "a", null, "b"};
Assert.That(builder.ToQueryString(), Is.EqualTo("key=a&key=b&key=c"));
}
public void Empty_builder_should_result_in_empty_string()
{
// Act
var builder = new QueryStringBuilder();
// Assert
builder.ToString().ShouldBe(string.Empty);
}
public void Test_2_Parameters_Return_Valid_Query_String()
{
QueryStringBuilder qsb = new QueryStringBuilder();
qsb.AddParameter("q", "environment");
qsb.AddParameter("filter", "uk");
Assert.AreEqual("?q=environment&filter=uk", qsb.GetQueryString());
}
public void AppendToUrlWithExistingQueryString_String()
{
var builder = new QueryStringBuilder();
builder.Set("a", "1");
var baseUrl = "http://localhost/default.aspx?b=2";
Assert.That(builder.AppendToUrl(baseUrl), Is.EqualTo("http://localhost/default.aspx?b=2&a=1"));
}
public void Test_With_Date_Parameter()
{
QueryStringBuilder qsb = new QueryStringBuilder();
qsb.AddParameter("q", "environment");
qsb.AddParameter("filter", "uk");
qsb.AddParameter("After", new DateTime(1971, 2, 20));
Assert.AreEqual("?q=environment&filter=uk&after=1971-02-20", qsb.GetQueryString());
}
internal static string EncodeCredentialsAsQueryString(Credentials credentials)
{
QueryStringBuilder builder = new QueryStringBuilder();
foreach (CredentialsNameValuePair nv in credentials.Attributes)
{
builder.Append(nv.Name, nv.Value);
}
return builder.ToString();
}
public void AppendToUrlWithExistingQueryString_RelativeUri()
{
var builder = new QueryStringBuilder();
builder.Set("a", "1");
var baseUrl = new Uri("/default.aspx?b=2", UriKind.Relative);
var expected = new Uri("/default.aspx?b=2&a=1", UriKind.Relative);
Assert.That(builder.AppendToUrl(baseUrl), Is.EqualTo(expected));
}
public void AppendToUrlWithExistingQueryString_AbsoluteUri()
{
var builder = new QueryStringBuilder();
builder.Set("a", "1");
var baseUrl = new Uri("http://localhost/default.aspx?b=2");
var expected = new Uri("http://localhost/default.aspx?b=2&a=1");
Assert.That(builder.AppendToUrl(baseUrl), Is.EqualTo(expected));
}
/// <summary>
/// Returns the query string to be used in the webhook URL
/// </summary>
/// <returns></returns>
public string ToQueryString()
{
QueryStringBuilder builder = new QueryStringBuilder();
if (ThreadId.HasValue)
{
builder.Add("thread_id", ThreadId.Value.ToString());
}
return(builder.ToString());
}
private QueryStringBuilder CreateQueryStringBuilder()
{
var qsb = new QueryStringBuilder();
if (!string.IsNullOrEmpty(PrivateToken))
{
qsb.SetValue("private_token", PrivateToken);
}
return(qsb);
}
public async Task <IEXResponse <IEnumerable <OptionResponse> > > OptionsAsync(string symbol, string expiration, OptionSide optionSide)
{
const string urlPattern = "stock/[symbol]/options/[expiration]/[optionSide]";
var qsb = new QueryStringBuilder();
var pathNvc = new NameValueCollection {
{ "symbol", symbol }, { "expiration", expiration }, { "optionSide", optionSide.GetDescriptionFromEnum() }
};
return(await executor.ExecuteAsync <IEnumerable <OptionResponse> >(urlPattern, pathNvc, qsb));
}
/// <summary>
/// Gets an access token from the provided refresh token
/// </summary>
/// <param name="refreshToken">Refresh token</param>
/// <returns>Access token for OneDrive</returns>
/// <exception cref="Exceptions.TokenRetrievalFailedException">Thrown when unable to retrieve a valid access token</exception>
protected override async Task <OneDriveAccessToken> GetAccessTokenFromRefreshToken(string refreshToken)
{
var queryBuilder = new QueryStringBuilder();
queryBuilder.Add("client_id", ClientId);
queryBuilder.Add("redirect_uri", AuthenticationRedirectUrl);
queryBuilder.Add("client_secret", ClientSecret);
queryBuilder.Add("refresh_token", refreshToken);
queryBuilder.Add("grant_type", "refresh_token");
return(await PostToTokenEndPoint(queryBuilder));
}
public async Task HistoricalPriceAsync(string symbol,
ChartRange range = ChartRange._1m, QueryStringBuilder qsb = null)
{
var response = await sandBoxClient.Stock.HistoricalPriceAsync(symbol, range);
Assert.IsNull(response.ErrorMessage);
Assert.IsNotNull(response.Data);
Assert.GreaterOrEqual(response.Data.Count(), 1);
Assert.IsNotEmpty(response.Data.First().date);
Assert.Greater(response.Data.First().GetDateTimeInUTC(), DateTime.MinValue);
}
internal string ToQueryString()
{
QueryStringBuilder builder = new QueryStringBuilder();
if (WithUserCount.HasValue)
{
builder.Add("with_user_count", WithUserCount.Value.ToString());
}
return(builder.ToString());
}
public void Adding_first_item_should_prepend_question_mark()
{
// Arrange
var builder = new QueryStringBuilder();
// Act
builder.Add("foo", "bar");
// Assert
builder.ToString().ShouldBe("?foo=bar");
}
public async Task <IEXResponse <IEnumerable <DividendV1Response> > > DividendAsync(string symbol, DividendRange range)
{
const string urlPattern = "stock/[symbol]/dividends/[range]";
var qsb = new QueryStringBuilder();
var pathNvc = new NameValueCollection
{
{ "symbol", symbol }, { "range", range.GetDescriptionFromEnum() }
};
return(await executor.ExecuteAsync <IEnumerable <DividendV1Response> >(urlPattern, pathNvc, qsb));
}
private static string GenerateMediaFileUrl(this ExtensionPoint <UrlHelper> instance, Guid mediaFileGuid, string siteName, SizeConstraint constraint)
{
var mediaFileUrlProvider = Service <IMediaFileUrlProvider> .Entry();
var url = mediaFileUrlProvider.GetMediaFileUrl(mediaFileGuid, siteName);
var queryStringBuilder = new QueryStringBuilder().AppendSizeConstraint(constraint);
url += queryStringBuilder.ToString();
return(instance.Target.Content(url));
}
public string RetrieveWarehouse(string Id)
{
var queryString =
new QueryStringBuilder()
.Add("$expand", "Locations")
.ToString();
var response = _httpContext.Get($"Warehouse/{Id}?{queryString}");
return(response.Body);
}
protected QueryStringBuilder GetQueryStringBuilderInstance()
{
QueryStringBuilder queryStringBuilder = null;
if (queryStringBuilder == null)
{
return(new QueryStringBuilder());
}
return(queryStringBuilder);
}
public static async Task AddToPendingSubscriptionQueueAsync(OneDriveNotification notification)
{
QueryStringBuilder qsb = new QueryStringBuilder {
StartCharacter = null
};
qsb.Add("id", notification.UserId);
CloudQueueMessage message = new CloudQueueMessage(qsb.ToString());
await SubscriptionQueue.AddMessageAsync(message);
}
/// <summary>
/// Gets an access token from the provided refresh token
/// </summary>
/// <param name="refreshToken">Refresh token</param>
/// <param name="scopes">Scopes to request access for</param>
/// <returns>Access token for the Graph API</returns>
/// <exception cref="Exceptions.TokenRetrievalFailedException">Thrown when unable to retrieve a valid access token</exception>
protected async Task <OneDriveAccessToken> GetAccessTokenFromRefreshToken(string refreshToken, string[] scopes)
{
var queryBuilder = new QueryStringBuilder();
queryBuilder.Add("client_id", ClientId);
queryBuilder.Add("scope", scopes.Aggregate((x, y) => $"{x} {y}"));
queryBuilder.Add("refresh_token", refreshToken);
queryBuilder.Add("redirect_uri", AuthenticationRedirectUrl);
queryBuilder.Add("grant_type", "refresh_token");
return(await PostToTokenEndPoint(queryBuilder));
}
public void Value_should_be_url_encoded()
{
// Arrange
var builder = new QueryStringBuilder();
// Act
builder.Add("foo", "% ");
// Assert
builder.ToString().ShouldEndWith("foo=%25%20");
}
public void BuilderWithNullNameShouldThrow()
{
// arrange
var builder = new QueryStringBuilder();
// act
Action result = () => builder.Add(null, "bar");
// assert
Assert.Throws <ArgumentNullException>("name", result);
}
public void BuildQueryParam_LongType_ParseLong()
{
// Arrange
QueryStringBuilder queryString = new QueryStringBuilder();
// Act
string longStr = queryString.BuildQueryParam(43145123456L);
// Assert
Assert.AreEqual("43145123456", longStr);
}
/// <summary>
///
/// </summary>
/// <param name="credentials"></param>
/// <param name="notificationCode"></param>
/// <returns></returns>
private static string BuildSearchUrlByNotification(Credentials credentials, string notificationCode)
{
QueryStringBuilder searchUrlByNotification;
searchUrlByNotification = new QueryStringBuilder("{url}/notifications/{notificationCode}?{credential}");
searchUrlByNotification.ReplaceValue("{url}", PagSeguroConfiguration.PreApprovalSearchUri.AbsoluteUri);
searchUrlByNotification.ReplaceValue("{notificationCode}", HttpUtility.UrlEncode(notificationCode));
searchUrlByNotification.ReplaceValue("{credential}", new QueryStringBuilder().EncodeCredentialsAsQueryString(credentials).ToString());
return(searchUrlByNotification.ToString());
}
/// <summary>
/// Creates or updates a user or group. The user or group (that is, the principal) is created or
/// updated in the same account as the user making the call.
/// </summary>
/// <param name="principalDelete">The principal setup.</param>
/// <returns>Status Info.</returns>
public PrincipalResult PrincipalDelete(PrincipalDelete principalDelete)
{
// action=principals-delete
var commandParams = QueryStringBuilder.EntityToQueryString(principalDelete);
StatusInfo status;
var doc = this.requestProcessor.Process(Commands.Principal.Delete, commandParams, out status);
return(new PrincipalResult(status, PrincipalParser.Parse(doc)));
}
public async Task <IEXResponse <SentimentResponse> > SentimentByDayAsync(string symbol, string date)
{
const string urlPattern = "stock/[symbol]/sentiment/daily/[date]";
var qsb = new QueryStringBuilder();
var pathNvc = new NameValueCollection {
{ "symbol", symbol }, { "date", date }
};
return(await executor.ExecuteAsync <SentimentResponse>(urlPattern, pathNvc, qsb));
}
/// <summary>
///
/// </summary>
/// <param name="credentials"></param>
/// <param name="preApprovalCode"></param>
/// <returns></returns>
private static string BuildSearchUrlByCode(Credentials credentials, string preApprovalCode)
{
QueryStringBuilder searchUrlByCode;
searchUrlByCode = new QueryStringBuilder("{url}/{preApprovalCode}?{credential}");
searchUrlByCode.ReplaceValue("{url}", PagSeguroConfiguration.PreApprovalSearchUri.AbsoluteUri);
searchUrlByCode.ReplaceValue("{preApprovalCode}", HttpUtility.UrlEncode(preApprovalCode));
searchUrlByCode.ReplaceValue("{credential}", new QueryStringBuilder().EncodeCredentialsAsQueryString(credentials).ToString());
return(searchUrlByCode.ToString());
}
public void BuildQueryParam_DoubleType_ParseDouble()
{
// Arrange
QueryStringBuilder queryString = new QueryStringBuilder();
// Act
string doubleStr = queryString.BuildQueryParam(1234.5678);
// Assert
Assert.AreEqual("1234.5678", doubleStr);
}
public void BuildQueryParam_QuotedStringType_ParseString()
{
// Arrange
QueryStringBuilder queryString = new QueryStringBuilder();
// Act
string strStr = queryString.BuildQueryParam("Haystack");
// Assert
Assert.AreEqual("\"Haystack\"", strStr);
}
public void NewBuilderShouldBeEmpty()
{
// arrange
var builder = new QueryStringBuilder();
// act
var result = builder.ToString();
// assert
Assert.Equal("", result);
}
private static String BuildInstallmentURL(Credentials credentials, Decimal amount, String cardBrand)
{
QueryStringBuilder builder = new QueryStringBuilder("{url}?{credentials}&amount={amount}&cardBrand={cardBrand}");
builder.ReplaceValue("{url}", PagSeguroConfiguration.InstallmentUri.AbsoluteUri);
builder.ReplaceValue("{credentials}", new QueryStringBuilder().EncodeCredentialsAsQueryString(credentials).ToString());
builder.ReplaceValue("{amount}", PagSeguroUtil.DecimalFormat(amount));
builder.ReplaceValue("{cardBrand}", HttpUtility.UrlEncode(cardBrand.ToString()));
return(builder.ToString());
}
public void BuildQueryParam_IntType_ParseInt()
{
// Arrange
QueryStringBuilder queryString = new QueryStringBuilder();
// Act
string intStr = queryString.BuildQueryParam(123);
// Assert
Assert.AreEqual("123", intStr);
}
public void BuilderWithNullValuesShouldThrow()
{
// arrange
var builder = new QueryStringBuilder();
// act
Action result = () => builder.Add("foo", new string[] { null });
// assert
Assert.Throws <ArgumentNullException>("value", result);
}
public void BuilderWithRemoveNullShouldThrow()
{
// arrange
var builder = new QueryStringBuilder();
// act
Action result = () => builder.Remove(null);
// assert
Assert.Throws <ArgumentNullException>("name", result);
}
static void Main(string[] args)
{
QueryStringBuilder qsb = new QueryStringBuilder("http//fkj.dk");
qsb.Add("x", 5);
qsb.Add("y", "23 23");
qsb.Add("z", 9);
Console.WriteLine((qsb.ToString()));
}
public void BuildQueryParam_EnumType_ParseEnum()
{
// Arrange
QueryStringBuilder queryString = new QueryStringBuilder();
// Act
string enumStr = queryString.FormatQueryParam(TestEnum.DISABLED);
// Assert
Assert.Equal("DISABLED", enumStr);
}
public void can_build_query_string_from_object_template_with_collections()
{
var qs = new QueryStringBuilder(new
{
name = "Homer",
kids = new string[] { "Bart", "Lisa", "Maggie" },
ages = new int[] { 42 }
});
Assert.Equal("?name=Homer&kids=Bart&kids=Lisa&kids=Maggie&ages=42", qs.ToString());
}
public ActionResult SignInBusiness()
{
QueryStringBuilder builder = new QueryStringBuilder();
builder.Add("client_id", ConfigurationManager.AppSettings["ida:AADAppId"]);
builder.Add("response_type", "code");
builder.Add("redirect_uri", whois.RedirectUri);
builder.Add("state", "business");
string targetUrl = ConfigurationManager.AppSettings["ida:AADAuthService"] + builder.ToString();
return Redirect(targetUrl);
}
/// <summary>
///
/// </summary>
/// <param name="credentials"></param>
/// <param name="reference"></param>
/// <returns></returns>
private static string BuildSearchUrlByReference(Credentials credentials, string reference)
{
QueryStringBuilder searchUrlByReference;
searchUrlByReference = new QueryStringBuilder("{url}?{credentials}&reference={reference}");
searchUrlByReference.ReplaceValue("{url}", PagSeguroConfiguration.SearchUri.AbsoluteUri);
searchUrlByReference.ReplaceValue("{reference}", HttpUtility.UrlEncode(reference));
searchUrlByReference.ReplaceValue("{credentials}", new QueryStringBuilder().EncodeCredentialsAsQueryString(credentials).ToString());
return(searchUrlByReference.ToString());
}
public void Test_Parameter_With_No_Value_Does_Not_Appear_In_Query_String()
{
QueryStringBuilder qsb = new QueryStringBuilder();
qsb.AddParameter("q", "environment");
qsb.AddParameter("filter", "uk");
qsb.AddParameter("", "blank");
qsb.AddParameter(null, "blank");
qsb.AddParameter("blank", "");
qsb.AddParameter("", "");
Assert.AreEqual("?q=environment&filter=uk", qsb.GetQueryString());
}
public void Adding_multiple_items_should_separate_them_with_ampersand()
{
// Arrange
var builder = new QueryStringBuilder();
builder.Add("foo", "bar");
// Act
builder.Add("haha", "lala");
// Assert
builder.ToString().ShouldBe("?foo=bar&haha=lala");
}
public void ToStringTest()
{
var sb = new QueryStringBuilder
{
{"t", "test test"},
{"tl", "en-US"},
{"sv", "g1"},
{"vn", "rjs"},
{"pitch", 0.5},
{"rate", 0.5},
{"vol", 1}
};
const string expected = "?t=test+test&tl=en-US&sv=g1&vn=rjs&pitch=0.5&rate=0.5&vol=1";
Assert.AreEqual(expected, sb.ToString());
}
public async Task DeleteAsync(string path)
{
if (path == null) throw new ArgumentNullException("path");
var qs = new QueryStringBuilder { { "path", path } };
var resp = await _client.DeleteAsync(qs.ToString()).ConfigureAwait(false);
await EnsureSuccess(resp);
}
public void Test_Format_Date()
{
QueryStringBuilder qsb = new QueryStringBuilder();
DateTime dt = new DateTime(2009, 1, 30);
Assert.AreEqual("2009-01-30", qsb.FormatDate(dt));
}
public async Task<Stream> GetStreamAsync(string path)
{
if (path == null) throw new ArgumentNullException("path");
var qs = new QueryStringBuilder { { "path", path } };
var resp = await _client.GetAsync(qs.ToString()).ConfigureAwait(false);
await EnsureSuccess(resp);
return await resp.Content.ReadAsStreamAsync().ConfigureAwait(false);
}
public async Task AppendFromStreamAsync(string path, Stream stream)
{
if (path == null) throw new ArgumentNullException("path");
if (stream == null) throw new ArgumentNullException("stream");
var content = new StreamContent(stream);
var qs = new QueryStringBuilder { { "path", path } };
var resp = await _client.SendAsync("PATCH", qs.ToString(), content).ConfigureAwait(false);
await EnsureSuccess(resp);
}
public void AppendToUrlWithEmptyBuilder()
{
var builder = new QueryStringBuilder();
var baseUrl = "http://localhost/default.aspx";
Assert.That(builder.AppendToUrl(baseUrl), Is.EqualTo("http://localhost/default.aspx"));
}
public SetEnumerableStringTarget(QueryStringBuilder builder)
: base(builder)
{
}
protected BaseRetrievalService(IEncentivizeRestClient restClient, EntitySettings entitySettings)
: base(restClient, entitySettings)
{
QueryStringBuilder = new QueryStringBuilder(propertiesToExclude: new[] { "PageNumber", "PageSize" });
}
public void Test_No_Parameters_Returns_Empty_String()
{
QueryStringBuilder qsb = new QueryStringBuilder();
Assert.IsEmpty(qsb.GetQueryString());
}
public QueryBuilderTest()
{
_queryStringBuilder = new QueryStringBuilder();
}
/// <summary>
/// Common implmentation of all SearchByDate methods
/// </summary>
/// <param name="credentials">PagSeguro credentials. Required.</param>
/// <param name="initialDate"></param>
/// <param name="finalDate">End of date range. Use DateTime.MaxValue to search without an upper boundary.</param>
/// <param name="pageNumber">Page number, starting with 1. If passed as 0, it will call the web service to get the default page, also page number 1.</param>
/// <param name="resultsPerPage">Results per page, optional.</param>
/// <returns></returns>
private static TransactionSearchResult SearchByDateCore(Credentials credentials, DateTime initialDate, DateTime finalDate, int pageNumber, int resultsPerPage)
{
UriBuilder uriBuilder = new UriBuilder(PagSeguroConfiguration.SearchUri);
QueryStringBuilder query = new QueryStringBuilder(ServiceHelper.EncodeCredentialsAsQueryString(credentials));
query.Append(InitialDateParameterName, initialDate);
if (finalDate < DateTime.MaxValue)
{
query.Append(FinalDateParameterName, finalDate);
}
if (pageNumber > 0)
{
query.Append(PageNumberParameterName, pageNumber);
}
if (resultsPerPage > 0)
{
query.Append(MaxPageResultsParameterName, resultsPerPage);
}
uriBuilder.Query = query.ToString();
PagSeguroTrace.Info(String.Format(CultureInfo.InvariantCulture, "TransactionSearchService.SearchByDate(initialDate={0}, finalDate={1}) - begin", initialDate, finalDate));
WebRequest request = WebRequest.Create(uriBuilder.Uri);
request.Method = ServiceHelper.GetMethod;
request.Timeout = PagSeguroConfiguration.RequestTimeout;
try
{
using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
{
using (XmlReader reader = XmlReader.Create(response.GetResponseStream()))
{
TransactionSearchResult result = new TransactionSearchResult();
TransactionSearchResultSerializer.Read(reader, result);
PagSeguroTrace.Info(String.Format(CultureInfo.InvariantCulture, "TransactionSearchService.SearchByDate(initialDate={0}, finalDate={1}) - end {2}", initialDate, finalDate, result));
return result;
}
}
}
catch (WebException exception)
{
PagSeguroServiceException pse = ServiceHelper.CreatePagSeguroServiceException((HttpWebResponse)exception.Response);
PagSeguroTrace.Error(String.Format(CultureInfo.InvariantCulture, "TransactionSearchService.SearchByDate(initialDate={0}, finalDate={1}) - error {2}", initialDate, finalDate, pse));
throw pse;
}
}
