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); }