private static HttpResponseMessage AddDownloadHeader(HttpRequestMessage request, HttpResponseMessage responseMessage, string filenamePrefix)
{
var queryString = new QueryStringCollection(request.RequestUri);
bool download;
if (queryString.TryGetAndConvert <bool>("download", out download))
{
if (download)
{
responseMessage.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
{
FileName = filenamePrefix + ".json"
};
}
}
else
{
return(request.CreateResponse(
HttpStatusCode.BadRequest,
new ErrorModel {
Message = "Value for download was specified but cannot be converted to true or false."
},
new MediaTypeHeaderValue("application/json")));
}
return(responseMessage);
}
public void ShouldThrowInvalidArgumentExceptionWhenQsIsNull()
{
Assert.Throws<ArgumentNullException>(() =>
{
var collection = new QueryStringCollection((string)null);
});
}
public void ShouldThrowInvalidArgumentExceptionWhenUriIsNull()
{
Assert.Throws <ArgumentNullException>(() =>
{
var collection = new QueryStringCollection(null);
});
}
private void AddNativeQueryString <TSource>(PropertyInfo prop, TSource source, string path = "")
{
var fullPath = GetFullPath(prop, path);
var propValue = prop.GetValue(source);
if (propValue == null)
{
return;
}
var propValueResult = prop.GetValue(source);
if (prop.PropertyType == typeof(DateTime?))
{
propValueResult = ((DateTime?)propValueResult).GetValueOrDefault().ToString("yyyy-MM-dd");
}
if (prop.PropertyType == typeof(DateTime))
{
propValueResult = ((DateTime)propValueResult).ToString("yyyy-MM-dd");
}
QueryStringCollection.Add(fullPath.ToString(), propValueResult.ToString());
}
public async Task FromQuery2ParameterTest()
{
QueryStringCollection query = new QueryStringCollection();
string queryValue1 = "yes echo gogo";
string queryValue2 = "goodgoodverygood";
query.AddValue("queryValue1", queryValue1);
query.AddValue("queryValue2", queryValue2);
string path = $"/api/FromQueryTest/2params";
var result = await base.Get(path, query);
var je = JsonSerializer.Deserialize <JsonElement>(JsonSerializer.Serialize(result));
var echo1 = je.GetProperty("echo1").GetString();
var echo2 = je.GetProperty("echo2").GetString();
Assert.Equal(queryValue1, echo1);
Assert.Equal(queryValue2, echo2);
//Assert.StartsWith("echo:", result);
//Assert.EndsWith(queryValue, result);
}
public void ShouldHandleMultipleAmpersands()
{
var collection = new QueryStringCollection(
new Uri("http://example.com?first=value1&second=value2&&")
);
Assert.Equal(2, collection.Count);
}
public void ShouldReturnNullForNonExistantEntry()
{
var queryStringCollection = new QueryStringCollection(
new Uri("http://example.com?intvalue=1&stringvalue=str&boolvalue=true&empty")
);
Assert.Null(queryStringCollection["nonexistant"]);
}
public void ShouldHandleMultipleAmpersands()
{
var collection = new QueryStringCollection(
new Uri("http://example.com?first=value1&second=value2&&")
);
Assert.Equal(2, collection.Count);
}
public void ShouldHandleNameOnlyParameters()
{
var collection = new QueryStringCollection(
new Uri("http://example.com?first=value1&second")
);
Assert.Equal(null, collection["second"]);
}
public void ShouldReturnNullForNonExistantEntry()
{
var queryStringCollection = new QueryStringCollection(
new Uri("http://example.com?intvalue=1&stringvalue=str&boolvalue=true&empty")
);
Assert.Null(queryStringCollection["nonexistant"]);
}
public void ShouldHandleNameOnlyParameters()
{
var collection = new QueryStringCollection(
new Uri("http://example.com?first=value1&second")
);
Assert.Equal(null, collection["second"]);
}
protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
{
return base.GetCollapsibleContent(request).Then(content =>
{
var queryString = new QueryStringCollection(request.RequestUri.Query);
content.Title = queryString["q"] ?? "Google Maps";
return content;
});
}
public void ShouldReturnFirstAndSecondParameter()
{
var collection = new QueryStringCollection(
new Uri("http://example.com?first=value1&second=value2")
);
Assert.Equal("value1", collection["first"]);
Assert.Equal("value2", collection["second"]);
}
protected override Task <ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
{
return(base.GetCollapsibleContent(request).Then(content =>
{
var queryString = new QueryStringCollection(request.RequestUri.Query);
content.Title = queryString["q"] ?? LanguageResources.GoogleMapsContent_DefaultTitle;
return content;
}));
}
public void ShouldReturnFirstAndSecondParameter()
{
var collection = new QueryStringCollection(
new Uri("http://example.com?first=value1&second=value2")
);
Assert.Equal("value1", collection["first"]);
Assert.Equal("value2", collection["second"]);
}
internal static string ResolveUriTemplate(string uriTemplate, QueryStringCollection queryStringCollection)
{
var createdUriPath = uriTemplate;
MatchCollection matchedParamNames = _uriParamRegex.Matches(uriTemplate);
int matchedParamNameAmount = matchedParamNames.Count;
if (matchedParamNameAmount != 0)
{
// TODO: Regex match operration + this operation's result can be cached.
// Build a key from the base address and the uriTemplate and look that up.
// Get the match values under an array.
string[] matchedParameterNameArray = new string[matchedParamNameAmount];
for (int i = 0; i < matchedParamNameAmount; i++)
{
matchedParameterNameArray[i] = matchedParamNames[i].Value;
}
// Check here that enough number of parameters are available.
// We assume here that we have the queryStringCollection.Count and id parameter if queryStringCollection is not null
if (((queryStringCollection != null) ? queryStringCollection.Count : 0) < matchedParamNameAmount)
{
throw new InvalidOperationException(InternalResource.ResolveUriTemplate_PassedParamaterValueAmountErrorMessage);
}
foreach (var paramName in matchedParameterNameArray)
{
string paramValueFromQueryStringCollection = null;
if (queryStringCollection == null)
{
throw new InvalidOperationException(
string.Format(InternalResource.ResolveUriTemplate_PassedParamaterValueAmountErrorMessage, paramName));
}
else
{
var paramFromQueryStringCollection = queryStringCollection.FirstOrDefault(x => x.Key.Equals(paramName, StringComparison.InvariantCultureIgnoreCase));
paramValueFromQueryStringCollection = paramFromQueryStringCollection.Value;
if (paramValueFromQueryStringCollection == null)
{
throw new InvalidOperationException(
string.Format(InternalResource.ResolveUriTemplate_PassedParamaterValueAmountErrorMessage, paramName));
}
// Remove the selected one because it will be
// used for querystring composition.
queryStringCollection.Remove(paramFromQueryStringCollection);
}
string paramValue = paramValueFromQueryStringCollection;
createdUriPath = createdUriPath.Replace("{" + paramName + "}", paramValue);
}
}
return(((queryStringCollection != null) && queryStringCollection.Count > 0)
? string.Format("{0}?{1}", createdUriPath, queryStringCollection.ToString().ToLowerInvariant()) : createdUriPath);
}
void AddGetCheck <T>(T value)
{
string key = "key_" + new Random().Next(50000);
QueryStringCollection collection = new QueryStringCollection();
collection.AddValue(key, value);
Assert.True(collection.TryGetFirst <T>(key, out var result));
Assert.Equal(value, result);
}
internal static string ResolveUriTemplate(string uriTemplate, QueryStringCollection queryStringCollection)
{
var createdUriPath = uriTemplate;
MatchCollection matchedParamNames = _uriParamRegex.Matches(uriTemplate);
int matchedParamNameAmount = matchedParamNames.Count;
if (matchedParamNameAmount != 0) {
// TODO: Regex match operration + this operation's result can be cached.
// Build a key from the base address and the uriTemplate and look that up.
// Get the match values under an array.
string[] matchedParameterNameArray = new string[matchedParamNameAmount];
for (int i = 0; i < matchedParamNameAmount; i++) {
matchedParameterNameArray[i] = matchedParamNames[i].Value;
}
// Check here that enough number of parameters are available.
// We assume here that we have the queryStringCollection.Count and id parameter if queryStringCollection is not null
if (((queryStringCollection != null) ? queryStringCollection.Count : 0) < matchedParamNameAmount) {
throw new InvalidOperationException(InternalResource.ResolveUriTemplate_PassedParamaterValueAmountErrorMessage);
}
foreach (var paramName in matchedParameterNameArray) {
string paramValueFromQueryStringCollection = null;
if (queryStringCollection == null) {
throw new InvalidOperationException(
string.Format(InternalResource.ResolveUriTemplate_PassedParamaterValueAmountErrorMessage, paramName));
}
else {
var paramFromQueryStringCollection = queryStringCollection.FirstOrDefault(x => x.Key.Equals(paramName, StringComparison.InvariantCultureIgnoreCase));
paramValueFromQueryStringCollection = paramFromQueryStringCollection.Value;
if (paramValueFromQueryStringCollection == null) {
throw new InvalidOperationException(
string.Format(InternalResource.ResolveUriTemplate_PassedParamaterValueAmountErrorMessage, paramName));
}
// Remove the selected one because it will be
// used for querystring composition.
queryStringCollection.Remove(paramFromQueryStringCollection);
}
string paramValue = paramValueFromQueryStringCollection;
createdUriPath = createdUriPath.Replace("{" + paramName + "}", paramValue);
}
}
return ((queryStringCollection != null) && queryStringCollection.Count > 0)
? string.Format("{0}?{1}", createdUriPath, queryStringCollection.ToString().ToLowerInvariant()) : createdUriPath;
}
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (_useV3)
{
var parameter = Convert.ToBase64String(Encoding.ASCII.GetBytes(_account.ApiUser + ":" + _account.ApiKey));
request.Headers.Authorization = new AuthenticationHeaderValue("Basic", parameter);
}
else
{
if (request.Method == HttpMethod.Get)
{
var parameter = string.Format("api_user={0}&api_key={1}", _account.ApiUser, _account.ApiKey);
var uriBuilder = new UriBuilder(request.RequestUri);
if (string.IsNullOrEmpty(uriBuilder.Query))
{
uriBuilder.Query = parameter;
}
else
{
uriBuilder.Query = uriBuilder.Query.TrimStart('?') + "&" + parameter;
}
request.RequestUri = uriBuilder.Uri;
}
else
{
var formUrlEncodedContent = request.Content as FormUrlEncodedContent;
var multipartFormDataContent = request.Content as MultipartFormDataContent;
if (formUrlEncodedContent != null)
{
var queryString = await formUrlEncodedContent.ReadAsStringAsync().ConfigureAwait(false);
var data = new QueryStringCollection(queryString)
{
new KeyValuePair<string, string>("api_user", _account.ApiUser),
new KeyValuePair<string, string>("api_key", _account.ApiKey)
};
request.Content = new FormUrlEncodedContent(data);
}
else if (multipartFormDataContent != null)
{
multipartFormDataContent.Add(new StringContent("api_user"), _account.ApiUser);
multipartFormDataContent.Add(new StringContent("api_key"), _account.ApiKey);
}
}
}
return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
}
public async Task <object> Get(string path, QueryStringCollection query)
{
string method = "get";
var action = this.router.GetAction(method, path);
Assert.NotNull(action);
var result = await action.Invoke(this.provider, method, path, query);
return(result);
}
public void ShouldReturnTrueForEmptyNullableType()
{
var queryStringCollection = new QueryStringCollection(
new Uri("http://example.com?intvalue=1&stringvalue=str&boolvalue=true&empty")
);
bool?output;
var result = queryStringCollection.TryGetAndConvert <bool?>("empty", out output);
Assert.True(result);
}
protected override IList <string> ExtractParameters(Uri responseUri)
{
var queryString = new QueryStringCollection(responseUri.Query);
string formKey = queryString["formkey"];
if (!String.IsNullOrEmpty(formKey))
{
return(new [] { formKey });
}
return(null);
}
public void DateTimeTest()
{
string key = "key_" + new Random().Next(50000);
QueryStringCollection collection = new QueryStringCollection();
DateTime time = DateTime.Now;
collection.AddValue(key, time.ToString("o"));
Assert.True(collection.TryGetFirst <DateTime>(key, out var result));
Assert.Equal(time, result);
}
protected override IList<string> ExtractParameters(Uri responseUri)
{
var queryString = new QueryStringCollection(responseUri.Query);
string formKey = queryString["key"];
if (!String.IsNullOrEmpty(formKey))
{
return new [] { formKey };
}
return null;
}
protected QueryStringCollection CreateCustomerContactQueryStringCollection()
{
var id = AccountToEdit.GetAttributeValue <Guid>("accountid");
var queryStringCollection = new QueryStringCollection(string.Empty);
queryStringCollection.Set("AccountID", id.ToString());
queryStringCollection.Set("ReturnToAccount", "true");
return(queryStringCollection);
}
public void ShouldOutputValueForBool()
{
var queryStringCollection = new QueryStringCollection(
new Uri("http://example.com?intvalue=1&stringvalue=str&boolvalue=true&empty")
);
bool output;
var result = queryStringCollection.TryGetAndConvert <bool>("boolvalue", out output);
Assert.True(result);
Assert.Equal(true, output);
}
public void ShouldOutputZeroForNonexistantInt()
{
var queryStringCollection = new QueryStringCollection(
new Uri("http://example.com?intvalue=1&stringvalue=str&boolvalue=true&empty")
);
int output;
var result = queryStringCollection.TryGetAndConvert <int>("nonexistant", out output);
Assert.True(result);
Assert.Equal(0, output);
}
public void ShouldOutputValueForInt()
{
var queryStringCollection = new QueryStringCollection(
new Uri("http://example.com?intvalue=1&stringvalue=str&boolvalue=true&empty")
);
int output;
var result = queryStringCollection.TryGetAndConvert<int>("intvalue", out output);
Assert.True(result);
Assert.Equal(1, output);
}
public void ShouldOutputNullForNonexistantString()
{
var queryStringCollection = new QueryStringCollection(
new Uri("http://example.com?intvalue=1&stringvalue=str&boolvalue=true&empty")
);
string output;
var result = queryStringCollection.TryGetAndConvert <string>("stringvalue1", out output);
Assert.True(result);
Assert.Equal(null, output);
}
internal static string BuildRequestUri(string baseUri, string uriTemplate, object uriParameters = null)
{
var trimedUriTemplate = uriTemplate.TrimEnd('/').TrimStart('/').ToLowerInvariant();
QueryStringCollection queryStringCollection = null;
if (uriParameters != null) {
queryStringCollection = new QueryStringCollection(uriParameters);
}
string resolvedUriTemplate = ResolveUriTemplate(trimedUriTemplate, queryStringCollection);
string appendedUriTemplate = string.Format("{0}/{1}", baseUri, resolvedUriTemplate);
return appendedUriTemplate;
}
public void ToStringTest()
{
var query = new QueryStringCollection();
var list = Enumerable.Range(1, 5).ToArray();
foreach (var i in list)
{
query.AddValue("a", i);
}
Assert.Equal("a=1&a=2&a=3&a=4&a=5", query.ToString());
}
private void PopulateQueryString(System.Web.HttpRequest request)
{
this._query = new QueryStringCollection();
foreach (string key in request.QueryString.AllKeys)
{
if (!string.IsNullOrEmpty(key))
{
this._query.Add(key, request.QueryString[key]);
}
}
this.SetQuery();
}
public ActionResult Save(Bam.Net.Analytics.QueryString[] values)
{
try
{
QueryStringCollection saver = new QueryStringCollection();
saver.AddRange(values);
saver.Save();
return(Json(new { Success = true, Message = "", Dao = "" }));
}
catch (Exception ex)
{
return(GetErrorResult(ex));
}
}
internal static string BuildRequestUri(string baseUri, string uriTemplate, object uriParameters = null)
{
var trimedUriTemplate = uriTemplate.TrimEnd('/').TrimStart('/').ToLowerInvariant();
QueryStringCollection queryStringCollection = null;
if (uriParameters != null)
{
queryStringCollection = new QueryStringCollection(uriParameters);
}
string resolvedUriTemplate = ResolveUriTemplate(trimedUriTemplate, queryStringCollection);
string appendedUriTemplate = string.Format("{0}/{1}", baseUri, resolvedUriTemplate);
return(appendedUriTemplate);
}
public async Task FromQuery1ParameterTest()
{
QueryStringCollection query = new QueryStringCollection();
string queryValue = "yes echo gogo";
query.AddValue("queryValue", queryValue);
string path = $"/api/FromQueryTest/1param";
var result = (string)await base.Get(path, query);
Assert.StartsWith("echo:", result);
Assert.EndsWith(queryValue, result);
}
internal QueryStringCollection ToQueryString()
{
var result = new QueryStringCollection();
foreach (var property in GetType().GetProperties())
{
var value = property.GetValue(this);
if (value != null)
{
result.Add(ToSnakeCase(property.Name), value.ToString());
}
}
return result;
}
protected QueryStringCollection CreateCustomerContactQueryString()
{
var queryStringCollection = new QueryStringCollection("");
var oppId = OpenOpportunity.GetAttributeValue <Guid>("opportunityid");
var account = OpenOpportunity.GetAttributeValue <EntityReference>("customerid");
queryStringCollection.Set("OpportunityId", oppId.ToString());
if (account != null)
{
queryStringCollection.Set("AccountId", account.Id.ToString());
}
return(queryStringCollection);
}
public async Task Invoke(IDictionary <string, object> env)
{
var httpRequest = new OwinRequest(env);
if (!httpRequest.Path.StartsWith(_path))
{
await _next(env);
return;
}
var httpResponse = new OwinResponse(env);
var qs = new QueryStringCollection(httpRequest.QueryString);
string url = qs["url"];
Uri uri;
if (String.IsNullOrEmpty(url) ||
!ImageContentProvider.IsValidImagePath(url) ||
!Uri.TryCreate(url, UriKind.Absolute, out uri))
{
httpResponse.StatusCode = 404;
await TaskAsyncHelper.Empty;
return;
}
var request = (HttpWebRequest)WebRequest.Create(url);
request.CachePolicy = new RequestCachePolicy(RequestCacheLevel.Default);
var response = (HttpWebResponse)await request.GetResponseAsync();
httpResponse.SetHeader("ContentType", response.ContentType);
httpResponse.StatusCode = (int)response.StatusCode;
using (response)
{
using (Stream stream = response.GetResponseStream())
{
await stream.CopyToAsync(httpResponse.Body);
}
}
}
public override bool IsValidContent(Uri uri)
{
if (!base.IsValidContent(uri))
{
// Someone may have pasted a link requiring a login --
// We can handle that here
if (uri.AbsoluteUri.StartsWith("https://accounts.google.com/ServiceLogin") ||
uri.AbsoluteUri.StartsWith("http://accounts.google.com/ServiceLogin"))
{
var qs = new QueryStringCollection(uri.Query);
if (qs["continue"] != null)
{
return(Domains.Any(d => qs["continue"].StartsWith(d)));
}
}
return(false);
}
return(true);
}
public override bool IsValidContent(Uri uri)
{
if (!base.IsValidContent(uri))
{
// Someone may have pasted a link requiring a login --
// We can handle that here
if (uri.AbsoluteUri.StartsWith("https://accounts.google.com/ServiceLogin") ||
uri.AbsoluteUri.StartsWith("http://accounts.google.com/ServiceLogin"))
{
var qs = new QueryStringCollection(uri.Query);
if (qs["continue"] != null)
{
return Domains.Any(d => qs["continue"].StartsWith(d));
}
}
return false;
}
return true;
}
public async Task Invoke(IDictionary<string, object> env)
{
var httpRequest = new OwinRequest(env);
if (!httpRequest.Path.StartsWith(_path))
{
await _next(env);
return;
}
var httpResponse = new OwinResponse(env);
var qs = new QueryStringCollection(httpRequest.QueryString);
string url = qs["url"];
Uri uri;
if (String.IsNullOrEmpty(url) ||
!ImageContentProvider.IsValidImagePath(url) ||
!Uri.TryCreate(url, UriKind.Absolute, out uri))
{
httpResponse.StatusCode = 404;
await TaskAsyncHelper.Empty;
return;
}
var request = (HttpWebRequest)WebRequest.Create(url);
request.CachePolicy = new RequestCachePolicy(RequestCacheLevel.Default);
var response = (HttpWebResponse)await request.GetResponseAsync();
httpResponse.SetHeader("ContentType", response.ContentType);
httpResponse.StatusCode = (int)response.StatusCode;
using (response)
{
using (Stream stream = response.GetResponseStream())
{
await stream.CopyToAsync(httpResponse.Body);
}
}
}
protected override IList<string> ExtractParameters(Uri responseUri)
{
var queryString = new QueryStringCollection(responseUri.Query);
string query = queryString["q"];
string hl = queryString["hl"];
string ll = queryString["ll"];
string spn = queryString["spn"];
string sll = queryString["sll"];
string sspn = queryString["sspn"];
string vpsrc = queryString["vpsrc"];
string hnear = queryString["hnear"];
string t = queryString["t"];
string z = queryString["z"];
if (String.IsNullOrEmpty(ll))
{
return null;
}
return new List<string>() { query, hl, ll, spn, sll, sspn, vpsrc, hnear, t, z };
}
public async Task <JToken> Invoke()
{
Url.Query = QueryStringCollection.ToString() ?? "";
var client = new WebClient
{
Headers = Headers
};
try
{
var result = await client.DownloadStringTaskAsync(Url.ToString());
return(JToken.Parse(result));
}
catch (Exception e)
{
Console.WriteLine(e);
throw new Exception($"Error in calling ({Url}) method", e);
}
}
protected override Task <ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
{
var parameters = new QueryStringCollection(request.RequestUri);
// Extract either the term or defid field from request.RequestUri
string defid = parameters["defid"];
string term = parameters["term"];
if (string.IsNullOrWhiteSpace(term) && string.IsNullOrWhiteSpace(defid))
{
return(null);
}
var apiQuery = string.Format(_urbanDictionaryAPIURL,
string.IsNullOrWhiteSpace(term) ? string.Empty : string.Format("term={0}", term),
string.IsNullOrWhiteSpace(defid) ? string.Empty : string.Format("&defid={0}", defid));
return(FetchArticle(new Uri(apiQuery)).Then(result =>
{
var list = result.list;
var count = list.Count;
if (count > 0)
{
string definition = list[0].definition;
string permalink = list[0].permalink;
string title = list[0].word;
string example = list[0].example;
return new ContentProviderResult
{
Title = title,
Content = string.Format(_contentFormat, permalink, title, definition.Replace("\n", "<br/>"), example.Replace("\n", "<br/>"))
};
}
return null;
}));
}
protected override Task<ContentProviderResult> GetCollapsibleContent(ContentProviderHttpRequest request)
{
var parameters = new QueryStringCollection(request.RequestUri);
// Extract either the term or defid field from request.RequestUri
string defid = parameters["defid"];
string term = parameters["term"];
if (string.IsNullOrWhiteSpace(term) && string.IsNullOrWhiteSpace(defid))
{
return null;
}
var apiQuery = string.Format(_urbanDictionaryAPIURL,
string.IsNullOrWhiteSpace(term) ? string.Empty : string.Format("term={0}", term),
string.IsNullOrWhiteSpace(defid) ? string.Empty : string.Format("&defid={0}", defid));
return FetchArticle(new Uri(apiQuery)).Then(result =>
{
var list = result.list;
var count = list.Count;
if (count > 0)
{
string definition = list[0].definition;
string permalink = list[0].permalink;
string title = list[0].word;
string example = list[0].example;
return new ContentProviderResult
{
Title = title,
Content = string.Format(_contentFormat, permalink, title, definition.Replace("\n", "<br/>"), example.Replace("\n", "<br/>"))
};
}
return null;
});
}
/// <summary>
/// Creates an query string for a facet
/// </summary>
/// <param name="facetQuery">The facet query.</param>
/// <param name="facetName">Name of the facet.</param>
/// <param name="facetValue">The facet value.</param>
/// <returns>The query string for the facet.</returns>
private static string GetFacetQueryString(string facetQuery, string facetName, string facetValue)
{
var facetCollection = new QueryStringCollection();
if (!string.IsNullOrEmpty(facetQuery))
{
facetCollection.Parse(HttpUtility.UrlDecode(facetQuery));
}
if (facetCollection.Contains(facetName))
{
var facetQueryValues = facetCollection[facetName];
if (facetQueryValues.Contains(facetValue))
{
var newFacetQueryValues = string.Empty;
var facetValues = facetQueryValues.Split('|').Where(p => !string.Equals(p, facetValue, StringComparison.OrdinalIgnoreCase)).ToList();
if (facetValues.Count() > 0)
{
facetCollection.Set(facetName, string.Join("|", facetValues));
}
else
{
facetCollection.Remove(facetName);
}
}
else
{
facetCollection.Set(facetName, facetQueryValues + StorefrontConstants.QueryStrings.FacetsSeparator + facetValue);
}
}
else
{
facetCollection.Add(facetName, facetValue);
}
return(facetCollection.ToString());
}
/// <summary>
/// Populates the query string.
/// </summary>
/// <param name="url">The URL to get the query string from.</param>
private void PopulateQueryString(string url)
{
this._query = new QueryStringCollection(url);
this.SetQuery();
}
internal static NameValueCollection InternalParseQueryString(string query, Encoding encoding)
{
int len;
if (query == null || (len = query.Length) == 0 || (len == 1 && query[0] == '?'))
return new NameValueCollection (1);
if (query[0] == '?')
query = query.Substring (1);
var res = new QueryStringCollection ();
var components = query.Split ('&');
foreach (var component in components) {
var i = component.IndexOf ('=');
if (i > -1) {
var name = UrlDecode (component.Substring (0, i), encoding);
var val = component.Length > i + 1
? UrlDecode (component.Substring (i + 1), encoding)
: String.Empty;
res.Add (name, val);
}
else {
res.Add (null, UrlDecode (component, encoding));
}
}
return res;
}
/// <summary>
/// Creates an query string for a facet
/// </summary>
/// <param name="facetQuery">The facet query.</param>
/// <param name="facetName">Name of the facet.</param>
/// <param name="facetValue">The facet value.</param>
/// <returns>The query string for the facet.</returns>
private static string GetFacetQueryString(string facetQuery, string facetName, string facetValue)
{
var facetCollection = new QueryStringCollection();
if (!string.IsNullOrEmpty(facetQuery))
{
facetCollection.Parse(HttpUtility.UrlDecode(facetQuery));
}
if (facetCollection.Contains(facetName))
{
var facetQueryValues = facetCollection[facetName];
if (facetQueryValues.Contains(facetValue))
{
var newFacetQueryValues = string.Empty;
var facetValues = facetQueryValues.Split('|').Where(p => !string.Equals(p, facetValue, StringComparison.OrdinalIgnoreCase)).ToList();
if (facetValues.Count() > 0)
{
facetCollection.Set(facetName, string.Join("|", facetValues));
}
else
{
facetCollection.Remove(facetName);
}
}
else
{
facetCollection.Set(facetName, facetQueryValues + StorefrontConstants.QueryStrings.FacetsSeparator + facetValue);
}
}
else
{
facetCollection.Add(facetName, facetValue);
}
return facetCollection.ToString();
}
public void ShouldOutputNullForNonexistantString()
{
var queryStringCollection = new QueryStringCollection(
new Uri("http://example.com?intvalue=1&stringvalue=str&boolvalue=true&empty")
);
string output;
var result = queryStringCollection.TryGetAndConvert<string>("stringvalue1", out output);
Assert.True(result);
Assert.Equal(null, output);
}
private void PopulateQueryString(System.Web.HttpRequest request)
{
this._query = new QueryStringCollection();
foreach (string key in request.QueryString.AllKeys)
{
if (!string.IsNullOrEmpty(key))
{
this._query.Add(key, request.QueryString[key]);
}
}
this.SetQuery();
}
public void ShouldReturnTrueForEmptyNullableType()
{
var queryStringCollection = new QueryStringCollection(
new Uri("http://example.com?intvalue=1&stringvalue=str&boolvalue=true&empty")
);
bool? output;
var result = queryStringCollection.TryGetAndConvert<bool?>("empty", out output);
Assert.True(result);
}
