public ActionResult FixValueProviderPost()
{
//Value provider csak az URL paraméterrel dolgozik
var querystringValues = new QueryStringValueProvider(this.ControllerContext);
var routeValues = new RouteDataValueProvider(this.ControllerContext);
ValueProviderResult action = querystringValues.GetValue("action"); //action=null
ValueProviderResult controller = querystringValues.GetValue("controller"); //controller=null
ValueProviderResult idResult = querystringValues.GetValue("Id"); //idResult=null
int id = (int)routeValues.GetValue("Id").ConvertTo(typeof(int)); //idResult=99999
string EzNemValid = querystringValues.GetValue(key: "WillNeverValid").AttemptedValue;
var model = CategoryModel.GetCategory(1);
//A model.WillNeverValid értéke "Hát ez honnan jött?" lesz:
this.TryUpdateModel <CategoryModel>(model, string.Empty, querystringValues);
//Input mezők
var formValues = new FormValueProvider(this.ControllerContext);
bool szerepel = formValues.ContainsPrefix("prefix.WillNeverValid");
this.TryUpdateModel <CategoryModel>(model, "prefix", formValues);
return(RedirectToAction("FixValueProvider"));
}
public async Task BindModelAsync_CorrectlyBindsEmptyEnumArrayQuery()
{
var queryParamName = "test";
var queryParamValues = Array.Empty <TestType>();
var queryParamType = typeof(TestType[]);
var modelBinder = new CommaDelimitedArrayModelBinder();
var valueProvider = new QueryStringValueProvider(
new BindingSource(string.Empty, string.Empty, false, false),
new QueryCollection(new Dictionary <string, StringValues>()
{
{ queryParamName, new StringValues(value: null) },
}),
CultureInfo.InvariantCulture);
var bindingContextMock = new Mock <ModelBindingContext>();
bindingContextMock.Setup(b => b.ValueProvider).Returns(valueProvider);
bindingContextMock.Setup(b => b.ModelName).Returns(queryParamName);
bindingContextMock.Setup(b => b.ModelType).Returns(queryParamType);
bindingContextMock.SetupProperty(b => b.Result);
await modelBinder.BindModelAsync(bindingContextMock.Object);
Assert.False(bindingContextMock.Object.Result.IsModelSet);
}
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
IncludedWords included = null;
//SESSION
if (controllerContext.HttpContext.Session != null)
{
included = (IncludedWords)controllerContext.HttpContext.Session[sessionKey];
}
if (included == null)
{
included = new IncludedWords();
//ACCESS TO PARAM LEVEL AT QUERY STRING
QueryStringValueProvider queryStringValueProvider = new QueryStringValueProvider(controllerContext);
ValueProviderResult Value = queryStringValueProvider.GetValue("Level");
var Level = Value.ConvertTo(typeof(Int32));
included.Words = ToList(LoadIncluded((Int32)Level));
if (controllerContext.HttpContext.Session != null)
{
controllerContext.HttpContext.Session[sessionKey] = included;
}
}
return(included);
}
public async Task BindModelAsync_EnumArrayQuery_BindValidOnly_2()
{
var queryParamName = "test";
var queryParamString1 = "How";
var queryParamString2 = "😱";
var queryParamType = typeof(IReadOnlyList <TestType>);
var modelBinder = new PipeDelimitedArrayModelBinder(new NullLogger <PipeDelimitedArrayModelBinder>());
var valueProvider = new QueryStringValueProvider(
new BindingSource(string.Empty, string.Empty, false, false),
new QueryCollection(new Dictionary <string, StringValues>
{
{ queryParamName, new StringValues(new[] { queryParamString1, queryParamString2 }) },
}),
CultureInfo.InvariantCulture);
var bindingContextMock = new Mock <ModelBindingContext>();
bindingContextMock.Setup(b => b.ValueProvider).Returns(valueProvider);
bindingContextMock.Setup(b => b.ModelName).Returns(queryParamName);
bindingContextMock.Setup(b => b.ModelType).Returns(queryParamType);
bindingContextMock.SetupProperty(b => b.Result);
await modelBinder.BindModelAsync(bindingContextMock.Object);
Assert.True(bindingContextMock.Object.Result.IsModelSet);
Assert.Single((IReadOnlyList <TestType>?)bindingContextMock.Object.Result.Model);
}
public async Task BindModelAsync_CorrectlyBindsValidPipeDelimitedEnumArrayQuery()
{
var queryParamName = "test";
IReadOnlyList <TestType> queryParamValues = new[] { TestType.How, TestType.Much };
var queryParamString = "How|Much";
var queryParamType = typeof(TestType[]);
var modelBinder = new PipeDelimitedArrayModelBinder(new NullLogger <PipeDelimitedArrayModelBinder>());
var valueProvider = new QueryStringValueProvider(
new BindingSource(string.Empty, string.Empty, false, false),
new QueryCollection(new Dictionary <string, StringValues> {
{ queryParamName, new StringValues(queryParamString) }
}),
CultureInfo.InvariantCulture);
var bindingContextMock = new Mock <ModelBindingContext>();
bindingContextMock.Setup(b => b.ValueProvider).Returns(valueProvider);
bindingContextMock.Setup(b => b.ModelName).Returns(queryParamName);
bindingContextMock.Setup(b => b.ModelType).Returns(queryParamType);
bindingContextMock.SetupProperty(b => b.Result);
await modelBinder.BindModelAsync(bindingContextMock.Object);
Assert.True(bindingContextMock.Object.Result.IsModelSet);
Assert.Equal((IReadOnlyList <TestType>?)bindingContextMock.Object.Result.Model, queryParamValues);
}
public async Task BindModelAsync_CorrectlyBindsValidCommaDelimitedIntArrayQuery()
{
var queryParamName = "test";
var queryParamValues = new int[] { 42, 0 };
var queryParamString = "42,0";
var queryParamType = typeof(int[]);
var modelBinder = new CommaDelimitedArrayModelBinder();
var valueProvider = new QueryStringValueProvider(
new BindingSource(string.Empty, string.Empty, false, false),
new QueryCollection(new Dictionary <string, StringValues>()
{
{ queryParamName, new StringValues(queryParamString) }
}),
CultureInfo.InvariantCulture);
var bindingContextMock = new Mock <ModelBindingContext>();
bindingContextMock.Setup(b => b.ValueProvider).Returns(valueProvider);
bindingContextMock.Setup(b => b.ModelName).Returns(queryParamName);
bindingContextMock.Setup(b => b.ModelType).Returns(queryParamType);
bindingContextMock.SetupProperty(b => b.Result);
await modelBinder.BindModelAsync(bindingContextMock.Object);
Assert.True(bindingContextMock.Object.Result.IsModelSet);
Assert.Equal((int[])bindingContextMock.Object.Result.Model, queryParamValues);
}
public async Task BindModelAsync_ThrowsIfCommaDelimitedEnumArrayQueryIsInvalid2()
{
var queryParamName = "test";
var queryParamValues = new TestType[] { TestType.How, TestType.Much };
var queryParamString1 = "How";
var queryParamString2 = "😱";
var queryParamType = typeof(TestType[]);
var modelBinder = new CommaDelimitedArrayModelBinder();
var valueProvider = new QueryStringValueProvider(
new BindingSource(string.Empty, string.Empty, false, false),
new QueryCollection(new Dictionary <string, StringValues>()
{
{ queryParamName, new StringValues(new string[] { queryParamString1, queryParamString2 }) },
}),
CultureInfo.InvariantCulture);
var bindingContextMock = new Mock <ModelBindingContext>();
bindingContextMock.Setup(b => b.ValueProvider).Returns(valueProvider);
bindingContextMock.Setup(b => b.ModelName).Returns(queryParamName);
bindingContextMock.Setup(b => b.ModelType).Returns(queryParamType);
bindingContextMock.SetupProperty(b => b.Result);
Func <Task> act = async() => await modelBinder.BindModelAsync(bindingContextMock.Object);
await Assert.ThrowsAsync <FormatException>(act);
}
/// <summary>
/// 获取提交的所有参数
/// </summary>
/// <param name="ivp"></param>
/// <returns></returns>
string GetAllParam(IValueProvider ivp)
{
Dictionary <string, string> Qsvp = new Dictionary <string, string>();
Dictionary <string, string> Fvp = new Dictionary <string, string>();
ValueProviderCollection vp = (ValueProviderCollection)ivp;
foreach (var v in vp)
{
Type t = v.GetType();
if (t.ToString() == "System.Web.Mvc.QueryStringValueProvider")
{
QueryStringValueProvider qvp = (QueryStringValueProvider)v;
foreach (var keys in qvp.GetKeysFromPrefix(""))
{
Qsvp.Add(keys.Key, qvp.GetValue(keys.Key).AttemptedValue);
}
}
if (t.ToString() == "System.Web.Mvc.FormValueProvider")
{
FormValueProvider qvp = (FormValueProvider)v;
foreach (var keys in qvp.GetKeysFromPrefix(""))
{
Fvp.Add(keys.Key, qvp.GetValue(keys.Key).AttemptedValue);
}
}
}
var param = new
{
QueryString = Qsvp,
FormValue = Fvp
};
return(Newtonsoft.Json.JsonConvert.SerializeObject(param));
}
private T GetModelFor <T>(string url)
{
RouteTable.Routes.Clear();
RegisterRoutes(RouteTable.Routes);
var httpContext = MvcMockHelpers.MockHttpContext(url);
var routeData = RouteTable.Routes.GetRouteData(httpContext);
var controller = new TestController();
controller.SetMockControllerContext(httpContext, routeData, RouteTable.Routes);
var queryStringValueProvider = new QueryStringValueProvider(controller.ControllerContext);
var modelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(T));
var bindingContext = new ModelBindingContext
{
ModelName = null,
ValueProvider = queryStringValueProvider,
ModelMetadata = modelMetadata
};
var binder = ModelBinders.Binders.GetBinder(typeof(DwollaRedirect));
return((T)binder.BindModel(controller.ControllerContext, bindingContext));
}
protected override IEnumerableValueProvider GetEnumerableValueProvider(
BindingSource bindingSource,
Dictionary <string, StringValues> values,
CultureInfo culture)
{
var emptyValueProvider = new QueryStringValueProvider(bindingSource, new QueryCollection(), culture);
var valueProvider = new FormValueProvider(bindingSource, new FormCollection(values), culture);
return(new CompositeValueProvider()
{
emptyValueProvider, valueProvider
});
}
public async void Must_Throw_PropertyNotFoundException()
{
var binder = new DynamicFilterBinder();
var queryCollection = new QueryCollection(new Dictionary <string, StringValues>()
{
{ "query", new StringValues("Nome=Bruno") }
});
var vp = new QueryStringValueProvider(BindingSource.Query, queryCollection, CultureInfo.CurrentCulture);
var context = GetBindingContext(vp, typeof(DynamicFilter <User>));
await Assert.ThrowsAsync <PropertyNotFoundException>(async() => await binder.BindModelAsync(context));
}
/// <inheritdoc />
public Task CreateValueProviderAsync(ValueProviderFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var valueProvider = new QueryStringValueProvider(
MatrixBindingSource.Matrix,
context.ActionContext.HttpContext.Request.GetMatrix(),
CultureInfo.InvariantCulture);
context.ValueProviders.Add(valueProvider);
return(TaskCache.CompletedTask);
}
public Task BindModelAsync(ModelBindingContext bindingContext)
{
if (bindingContext.ModelType != typeof(CourseDeliveryMode))
{
return(Task.CompletedTask);
}
var valueProvider = new QueryStringValueProvider(
BindingSource.Query,
bindingContext.HttpContext.Request.Query,
CultureInfo.InvariantCulture);
var valueProviderResult = valueProvider.GetValue(bindingContext.ModelName);
if (valueProviderResult.Length == 0)
{
bindingContext.ModelState.AddModelError(bindingContext.ModelName, "No DeliveryMode provided.");
bindingContext.Result = ModelBindingResult.Failed();
return(Task.CompletedTask);
}
CourseDeliveryMode?deliveryMode = valueProviderResult.FirstValue.ToLowerInvariant() switch
{
"classroom" => CourseDeliveryMode.ClassroomBased,
"classroombased" => CourseDeliveryMode.ClassroomBased,
"classroom-based" => CourseDeliveryMode.ClassroomBased,
"classroom based" => CourseDeliveryMode.ClassroomBased,
"online" => CourseDeliveryMode.Online,
"work" => CourseDeliveryMode.WorkBased,
"workbased" => CourseDeliveryMode.WorkBased,
"work-based" => CourseDeliveryMode.WorkBased,
"work based" => CourseDeliveryMode.WorkBased,
_ => null
};
if (deliveryMode == null)
{
bindingContext.ModelState.AddModelError(bindingContext.ModelName, $"Invalid DeliveryMode provided: '{valueProviderResult.FirstValue}'.");
bindingContext.Result = ModelBindingResult.Failed();
return(Task.CompletedTask);
}
bindingContext.Result = ModelBindingResult.Success(deliveryMode.Value);
return(Task.CompletedTask);
}
}
/// <summary>
/// Asynchronously executes the binding for the given request.
/// </summary>
/// <returns>
/// A task object representing the asynchronous operation.
/// </returns>
/// <param name="metadataProvider">Metadata provider to use for validation.</param>
/// <param name="actionContext">The action context for the binding. The action context contains the parameter dictionary that will get populated with the parameter.</param>
/// <param name="cancellationToken">Cancellation token for cancelling the binding operation.</param>
public override Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken)
{
// TODO: 本当はどうやってやるべきなのかがわからない…
var queryString = new QueryStringValueProvider(actionContext, CultureInfo.CurrentCulture);
var parameterName = Descriptor.ParameterName;
var value = queryString.GetValue(parameterName).Maybe(x => x.AttemptedValue) ??
actionContext.ControllerContext.RouteData.Values[parameterName] as string;
Version version;
if (Version.TryParse(value, out version))
{
SetValue(actionContext, version);
}
return(_completed);
}
public Task CreateValueProviderAsync(ValueProviderFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var query = context.ActionContext.HttpContext.Request.Query;
if (query != null && query.Count > 0)
{
var valueProvider = new QueryStringValueProvider(
BindingSource.Query,
query,
CultureInfo.CurrentCulture);
context.ValueProviders.Add(valueProvider);
}
return(Task.CompletedTask);
}
public async void Must_Match_Multiple_Users(string query, int count)
{
var binder = new DynamicFilterBinder();
var queryCollection = new QueryCollection(new Dictionary <string, StringValues>()
{
{ "query", new StringValues(query) }
});
var vp = new QueryStringValueProvider(BindingSource.Query, queryCollection, CultureInfo.CurrentCulture);
var context = GetBindingContext(vp, typeof(DynamicFilter <User>));
await binder.BindModelAsync(context);
var dynamicFilter = context.Result.Model as DynamicFilter <User>;
var result = await new UserController().Get(dynamicFilter);
Assert.Equal(count, result.Count);
}
public async void Must_Order_Values(string query, string order, string firstName)
{
var binder = new DynamicFilterBinder();
var queryCollection = new QueryCollection(new Dictionary <string, StringValues>()
{
{ "query", new StringValues(query) },
{ $"order", new StringValues(order) }
});
var vp = new QueryStringValueProvider(BindingSource.Query, queryCollection, CultureInfo.CurrentCulture);
var context = GetBindingContext(vp, typeof(DynamicFilter <User>));
await binder.BindModelAsync(context);
var dynamicFilter = context.Result.Model as DynamicFilter <User>;
var result = await new UserController().Get(dynamicFilter);
Assert.Equal(firstName, result.FirstOrDefault().Name);
}
public async Task InvokeAsync(HttpContext context)
{
var providerInfoCache = context.RequestServices.GetRequiredService <IProviderInfoCache>();
var currentUserProvider = context.RequestServices.GetRequiredService <ICurrentUserProvider>();
var providerContextProvider = context.RequestServices.GetRequiredService <IProviderContextProvider>();
bool runNext = true;
await TryAssignFeature();
if (runNext)
{
await _next(context);
}
async Task TryAssignFeature()
{
// For Provider {Super}Users the provider comes from their identity token.
// For Admin or Helpdesk users there should be a route value indicating the provider.
// If Provider {Super}Users specify the route value it's ignored.
var user = currentUserProvider.GetCurrentUser();
if (user == null)
{
return;
}
Guid providerId;
// A 'strict' provider context means it cannot be changed for a given request
bool strict = true;
var requestProviderId = TryGetProviderIdFromRequest();
if (!requestProviderId.HasValue)
{
requestProviderId = await TryGetProviderIdFromLegacyContext();
if (requestProviderId.HasValue)
{
strict = false;
}
}
if (user.IsDeveloper || user.IsHelpdesk)
{
if (!requestProviderId.HasValue)
{
return;
}
else
{
providerId = requestProviderId.Value;
}
}
else // user.IsProvider == true
{
var usersOwnProviderId = user.CurrentProviderId.Value;
// Route param or session value, if specified, must match user's own org
if (requestProviderId.HasValue && requestProviderId.Value != usersOwnProviderId)
{
context.Response.StatusCode = StatusCodes.Status403Forbidden;
runNext = false;
return;
}
providerId = usersOwnProviderId;
}
var providerInfo = await providerInfoCache.GetProviderInfo(providerId);
if (providerInfo != null)
{
var providerContext = new ProviderContext(providerInfo, strict);
providerContextProvider.SetProviderContext(providerContext);
}
}
Guid?TryGetProviderIdFromRequest()
{
var routeValueProvider = new RouteValueProvider(
BindingSource.Path,
context.GetRouteData().Values);
var queryStringValueProvider = new QueryStringValueProvider(
BindingSource.Query,
context.Request.Query,
CultureInfo.InvariantCulture);
var matches = routeValueProvider.GetValue(RouteValueKey).Values
.Concat(queryStringValueProvider.GetValue(RouteValueKey).Values)
.Distinct()
.ToList();
if (matches.Count == 1 && Guid.TryParse(matches.Single(), out var providerId))
{
return(providerId);
}
return(null);
}
async Task <Guid?> TryGetProviderIdFromLegacyContext()
{
var ukprn = context.Session.GetInt32("UKPRN");
return(ukprn.HasValue ? await providerInfoCache.GetProviderIdForUkprn(ukprn.Value) : null);
}
}
private Task <object> BindInternal(HttpContext context, Type returnType)
{
var mediatorRequest = Activator.CreateInstance(returnType);
var requestProperties = typeBindingRepo.GetProperties(returnType);
if (!requestProperties.Any())
{
return(Task.FromResult(mediatorRequest));
}
var routeProvider = new RouteValueProvider(BindingSource.Path, context.Request.RouteValues);
var queryProvider = new QueryStringValueProvider(BindingSource.Query, context.Request.Query, CultureInfo.InvariantCulture);
var compositeValueProvider = new CompositeValueProvider
{
routeProvider,
queryProvider
};
IValueProvider formProvider = null;
var bodyProvider = new JsonBodyValueProvider(context, jsonOptions);
if (context.Request.HasFormContentType)
{
formProvider = new FormValueProvider(BindingSource.Form, context.Request.Form, CultureInfo.CurrentCulture);;
compositeValueProvider.Add(formProvider);
}
else
{
compositeValueProvider.Add(bodyProvider);
}
IValueProvider GetProvider(BoundProperty property)
{
if (property.BindingSource == BindingSource.Path)
{
return(routeProvider);
}
else if (property.BindingSource == BindingSource.Query)
{
return(queryProvider);
}
else if (property.BindingSource == BindingSource.Form)
{
return(formProvider);
}
else if (property.BindingSource == BindingSource.Body)
{
return(bodyProvider);
}
return(compositeValueProvider);
}
foreach (var property in requestProperties)
{
var propType = property.Property.PropertyType;
var valueProvider = GetProvider(property);
if (valueProvider != null)
{
var value = valueProvider.GetValue(property.Name);
if (value.FirstValue != null)
{
if (Nullable.GetUnderlyingType(propType) != null)
{
propType = Nullable.GetUnderlyingType(propType);
}
if (propType == typeof(string))
{
property.Property.SetValue(mediatorRequest, value.FirstValue);
}
else if (propType == typeof(bool))
{
property.Property.SetValue(mediatorRequest, Convert.ToBoolean(value.FirstValue));
}
else if (propType == typeof(char))
{
property.Property.SetValue(mediatorRequest, Convert.ToChar(value.FirstValue));
}
else if (propType == typeof(DateTime))
{
property.Property.SetValue(mediatorRequest, Convert.ToDateTime(value.FirstValue));
}
else if (propType == typeof(DateTimeOffset))
{
property.Property.SetValue(mediatorRequest, DateTimeOffset.Parse(value.FirstValue));
}
else if (propType == typeof(TimeSpan))
{
property.Property.SetValue(mediatorRequest, TimeSpan.Parse(value.FirstValue));
}
else if (propType == typeof(Uri))
{
property.Property.SetValue(mediatorRequest, new Uri(value.FirstValue));
}
else if (propType == typeof(Version))
{
property.Property.SetValue(mediatorRequest, new Version(value.FirstValue));
}
else if (propType == typeof(Guid))
{
property.Property.SetValue(mediatorRequest, Guid.Parse(value.FirstValue));
}
else if (propType == typeof(decimal) || propType == typeof(double) || propType == typeof(int) || propType == typeof(uint) ||
propType == typeof(byte) || propType == typeof(sbyte) || propType == typeof(long) || propType == typeof(float) ||
propType == typeof(short) || propType == typeof(ulong) || propType == typeof(ushort))
{
var objValue = JsonSerializer.Deserialize(value.FirstValue, propType, jsonOptions.Value.JsonSerializerOptions);
property.Property.SetValue(mediatorRequest, objValue);
}
else
{
var needsQuotes = bodyProvider.ValueKind == JsonValueKind.String || bodyProvider.ValueKind == null;
var text = needsQuotes ? $"\"{value.FirstValue}\"" : value.FirstValue;
var objValue = JsonSerializer.Deserialize(text, propType, jsonOptions.Value.JsonSerializerOptions);
property.Property.SetValue(mediatorRequest, objValue);
}
}
}
}
return(Task.FromResult(mediatorRequest));
}
public static IDictionary <string, object> ToDictionaryIn(this System.Net.Http.HttpRequestMessage message)
{
Dictionary <string, object> d = new Dictionary <string, object>();
d.Add("xf-request.message.uri", message.RequestUri.ToString());
d.Add("xf-request.message.local-path", message.RequestUri.LocalPath.Trim(new char[] { '/' }).ToLower());
d.Add("xf-request.message.http-method", message.Method.Method.ToUpper());
if (message.Headers.Authorization != null)
{
d.Add("xf-request.message.auth-schema", message.Headers.Authorization.Scheme);
d.Add("xf-request.message.auth-value", message.Headers.Authorization.Parameter);
if (message.Headers.Authorization.Scheme.Equals("basic", StringComparison.OrdinalIgnoreCase))
{
d.Add("xf-request.message.basic-token", message.Headers.Authorization.Parameter);
}
if (message.Headers.Authorization.Scheme.Equals("bearer", StringComparison.OrdinalIgnoreCase))
{
d.Add("xf-request.message.bearer-token", message.Headers.Authorization.Parameter);
}
}
else
{
d.Add("xf-request.message.auth-schema", "none");
d.Add("xf-request.message.auth-value", "none");
}
d.Add("xf-request.message.protocol", message.RequestUri.Scheme.ToLower());
string host = message.RequestUri.Host.ToLower();
d.Add("xf-request.message.host", host.ToLower());
var parts = host.Split(new char[] { '.' });
if (parts.Length > 1)
{
d.Add("xf-request.message.sub-domain", parts[0].ToLower());
}
if (message.Properties.ContainsKey("MS_HttpContext"))
{
var context = ((System.Web.HttpContextWrapper)message.Properties["MS_HttpContext"]);
if (!String.IsNullOrEmpty(context.Request.UserHostAddress))
{
d.Add("xf-request.message.client-ip", context.Request.UserHostAddress);
}
if (!String.IsNullOrWhiteSpace(context.Request.UserAgent))
{
d.Add("xf-request.message.user-agent", context.Request.UserAgent);
}
}
foreach (var item in message.Headers)
{
d.Add(String.Format("xf-request.header.{0}", item.Key.ToLower()), item.Value);
}
foreach (var item in message.Properties)
{
if (item.Key.Equals("{8572540D-3BD9-46DA-B112-A1E6C9086003}", StringComparison.OrdinalIgnoreCase))
{
QueryStringValueProvider provider = item.Value as QueryStringValueProvider;
if (provider != null)
{
foreach (var kvp in provider.GetKeysFromPrefix(""))
{
string key = kvp.Key;
ValueProviderResult vpr = (ValueProviderResult)provider.GetValue(key);
d.Add(String.Format("xf-request.query-string.{0}", key), vpr.AttemptedValue);
}
}
}
}
foreach (KeyValuePair <string, string> kvp in message.GetQueryNameValuePairs())
{
string key = String.Format("xf-request.query-string.{0}", kvp.Key);
d.Add(key, kvp.Value);
}
return(d);
}
public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
{
if (bindingContext.ModelType != typeof(GridArgs))
{
return(false);
}
var queryString = HttpContext.Current.Request.QueryString;
var provider = new QueryStringValueProvider(actionContext, CultureInfo.CurrentCulture);
var result = new GridArgs
{
Filtering = new Filtering
{
Filters = new List <CompositeFilter>()
},
Sorting = new Sorting(),
Paging = new Paging()
};
var filterIndex = 0;
var simpleFilterField = "filter[filters][{0}][field]";
var simpleFilterOperator = "filter[filters][{0}][operator]";
var simpleFilterValue = "filter[filters][{0}][value]";
var complexFilterOperator = "filter[filters][{0}][logic]";
var complexFilterField1 = "filter[filters][{0}][filters][0][field]";
var complexFilterOperator1 = "filter[filters][{0}][filters][0][operator]";
var complexFilterValue1 = "filter[filters][{0}][filters][0][value]";
var complexFilterField2 = "filter[filters][{0}][filters][1][field]";
var complexFilterOperator2 = "filter[filters][{0}][filters][1][operator]";
var complexFilterValue2 = "filter[filters][{0}][filters][1][value]";
var filterOperator = "filter[logic]";
result.Paging.Take = Convert.ToInt32(queryString.Get("take"));
result.Paging.Skip = Convert.ToInt32(queryString.Get("skip"));
result.Sorting.Field = queryString.Get("sort[0][field]");
result.Sorting.Direction = queryString.Get("sort[0][dir]");
result.Filtering.Logic = queryString.Get(filterOperator);
while (filterIndex < 20)
{
if (queryString.Get(string.Format(simpleFilterField, filterIndex)) != null)
{
var compositeFilter = new CompositeFilter
{
Filters = new List <Filter>(),
Logic = "and"
};
compositeFilter.Filters.Add(new Filter
{
Field = queryString.Get(string.Format(simpleFilterField, filterIndex)),
Value = queryString.Get(string.Format(simpleFilterValue, filterIndex)),
Operator = queryString.Get(string.Format(simpleFilterOperator, filterIndex))
});
result.Filtering.Filters.Add(compositeFilter);
}
else if (queryString.Get(string.Format(complexFilterOperator, filterIndex)) != null)
{
var filtering = new CompositeFilter
{
Filters = new List <Filter>(),
Logic = queryString.Get(string.Format(complexFilterOperator, filterIndex))
};
filtering.Filters.Add(new Filter
{
Field = queryString.Get(string.Format(complexFilterField1, filterIndex)),
Value = queryString.Get(string.Format(complexFilterValue1, filterIndex)),
Operator = queryString.Get(string.Format(complexFilterOperator1, filterIndex))
});
filtering.Filters.Add(new Filter
{
Field = queryString.Get(string.Format(complexFilterField2, filterIndex)),
Value = queryString.Get(string.Format(complexFilterValue2, filterIndex)),
Operator = queryString.Get(string.Format(complexFilterOperator2, filterIndex))
});
result.Filtering.Filters.Add(filtering);
}
else
{
break;
}
filterIndex++;
}
bindingContext.Model = result;
return(true);
}
