private static IList <IFilterDescriptor> ParseCompositeFilters(string filterInput)
{
var compositefilterResult = new StringBuilder();
CustomDataSourceRequestCompositeFilter filters = JsonConvert.DeserializeObject <CustomDataSourceRequestCompositeFilter>(filterInput);
if (filters != null && filters.Filters != null)
{
var balance = filters.Filters.Count;
foreach (var filter in filters.Filters)
{
balance--;
string filterResult = FilterFormat(filter);
if (!string.IsNullOrEmpty(filterResult))
{
compositefilterResult.Append($"({filterResult})");
if (balance > 0)
{
compositefilterResult.Append($"~{filters.Logic}~");
}
}
}
}
return(FilterDescriptorFactory.Create(compositefilterResult.ToString()));
}
/// <summary>
/// Create DataSource Request
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
public static DataSourceRequest CreateDataSourceRequest(this DataSourceRequestOptions req)
{
var request = new DataSourceRequest();
if (req.Sort != null)
{
request.Sorts = DataSourceDescriptorSerializer.Deserialize <SortDescriptor>(req.Sort);
}
request.Page = req.Page;
request.PageSize = req.PageSize;
if (req.Filter != null)
{
request.Filters = FilterDescriptorFactory.Create(req.Filter);
}
if (req.Group != null)
{
request.Groups = DataSourceDescriptorSerializer.Deserialize <GroupDescriptor>(req.Group);
}
if (req.Aggregate != null)
{
request.Aggregates = DataSourceDescriptorSerializer.Deserialize <AggregateDescriptor>(req.Aggregate);
}
return(request);
}
public override RoboUIGridRequest CreateGridRequest(ControllerContext controllerContext)
{
var result = new RoboUIGridRequest();
var request = controllerContext.HttpContext.Request;
var page = request.Form["page"];
if (page != null)
{
result.PageIndex = Convert.ToInt32(page);
}
var pageSize = request.Form["pageSize"];
if (pageSize != null)
{
result.PageSize = Convert.ToInt32(pageSize);
}
var bindingContext = new ModelBindingContext
{
ValueProvider = controllerContext.Controller.ValueProvider
};
string value;
if (TryGetValue(bindingContext, "sort", out value))
{
result.Sorts = GridDescriptorSerializer.Deserialize <SortDescriptor>(value);
}
if (TryGetValue(bindingContext, "filter", out value))
{
if (!string.IsNullOrEmpty(value))
{
// Process [today], [beginWeek], [endWeek], [beginMonth], [endMonth], [beginPrevMonth] tokens
var dtNow = DateTime.UtcNow.Date;
int startIndex;
var endIndex = 0;
while ((startIndex = value.IndexOf("[today", endIndex, StringComparison.Ordinal)) != -1)
{
endIndex = value.IndexOf("]", startIndex, StringComparison.Ordinal);
var days = value.Substring(startIndex + 6, endIndex - startIndex - 6);
value = value.Replace("[today" + days + "]", dtNow.AddDays(Convert.ToInt32(days)).ToString("O"));
}
value = value.Replace("[beginWeek]", dtNow.StartOfWeek(DayOfWeek.Monday).ToString("O"));
value = value.Replace("[endWeek]", dtNow.EndOfWeek(DayOfWeek.Sunday).AddDays(1).ToString("O"));
value = value.Replace("[beginMonth]", new DateTime(dtNow.Year, dtNow.Month, 1, 0, 0, 0, DateTimeKind.Utc).ToString("O"));
value = value.Replace("[endMonth]", new DateTime(dtNow.Year, dtNow.Month + 1, 1, 0, 0, 0, DateTimeKind.Utc).ToString("O"));
value = value.Replace("[beginPrevMonth]", new DateTime(dtNow.Year, dtNow.Month - 1, 1, 0, 0, 0, DateTimeKind.Utc).ToString("O"));
value = value.Replace("[beginYear]", new DateTime(dtNow.Year, 1, 1, 0, 0, 0, DateTimeKind.Utc).ToString("O"));
value = value.Replace("[endYear]", new DateTime(dtNow.Year + 1, 1, 1, 0, 0, 0, DateTimeKind.Utc).ToString("O"));
result.Filters = FilterDescriptorFactory.Create(value);
}
}
return(result);
}
public void Should_create_filter_descriptor()
{
FilterDescriptor filterDescriptor = (FilterDescriptor)FilterDescriptorFactory.Create("age~eq~10")[0];
Assert.Equal(FilterOperator.IsEqualTo, filterDescriptor.Operator);
Assert.Equal("age", filterDescriptor.Member);
Assert.Equal(10, Convert.ToInt32(filterDescriptor.Value));
}
public static DataSourceRequest Parse(dynamic param)
{
dynamic objParamInfo = param.gridState;
string page = objParamInfo.page;
string pageSize = objParamInfo.pageSize;
string sort = objParamInfo.sort;
string group = objParamInfo.group;
string filter = objParamInfo.filter;
string aggregates = objParamInfo.aggregate;
DataSourceRequest request = new DataSourceRequest();
try
{
if (!string.IsNullOrEmpty(page))
{
int p = 0;
Int32.TryParse(page, out p);
request.Page = p;
}
if (!string.IsNullOrEmpty(pageSize))
{
int psize = 0;
Int32.TryParse(pageSize, out psize);
request.PageSize = psize;
}
if (!string.IsNullOrEmpty(sort))
{
request.Sorts = DataSourceDescriptorSerializer.Deserialize <SortDescriptor>(sort);
}
if (!string.IsNullOrEmpty(filter))
{
request.Filters = FilterDescriptorFactory.Create(filter);
}
if (!string.IsNullOrEmpty(group))
{
request.Groups = DataSourceDescriptorSerializer.Deserialize <GroupDescriptor>(group);
}
if (!string.IsNullOrEmpty(aggregates))
{
request.Aggregates = DataSourceDescriptorSerializer.Deserialize <AggregateDescriptor>(group);
}
}
catch (Exception ex)
{
var msg = ex.Message;
}
return(request);
}
public static GridCommand Parse(int page, int pageSize, string orderBy, string groupBy, string filter)
{
GridCommand result = new GridCommand
{
Page = page,
PageSize = pageSize,
SortDescriptors = GridDescriptorSerializer.Deserialize <SortDescriptor>(orderBy),
FilterDescriptors = FilterDescriptorFactory.Create(filter),
GroupDescriptors = GridDescriptorSerializer.Deserialize <GroupDescriptor>(groupBy)
};
return(result);
}
public Task BindModelAsync(ModelBindingContext bindingContext)
{
if (bindingContext == null)
{
throw new ArgumentNullException(nameof(bindingContext));
}
DataSourceRequest request = new DataSourceRequest();
var pageValueProviderResult = bindingContext.ValueProvider.GetValue(GridUrlParameters.Page);
if (pageValueProviderResult != ValueProviderResult.None)
{
if (int.TryParse(pageValueProviderResult.FirstValue, out var page))
{
request.Page = page;
}
}
var pageSizeValueProviderResult = bindingContext.ValueProvider.GetValue(GridUrlParameters.PageSize);
if (pageSizeValueProviderResult != ValueProviderResult.None)
{
if (int.TryParse(pageSizeValueProviderResult.FirstValue, out var pageSize))
{
request.PageSize = pageSize;
}
}
var sortValueProviderResult = bindingContext.ValueProvider.GetValue(GridUrlParameters.Sort);
if (sortValueProviderResult != ValueProviderResult.None)
{
request.Sorts = GridDescriptorSerializer.Deserialize <SortDescriptor>(sortValueProviderResult.FirstValue);
}
var filterValueProviderResult = bindingContext.ValueProvider.GetValue(GridUrlParameters.Filter);
if (filterValueProviderResult != ValueProviderResult.None)
{
request.Filters = FilterDescriptorFactory.Create(filterValueProviderResult.FirstValue);
}
bindingContext.Result = ModelBindingResult.Success(request);
return(Task.CompletedTask);
}
public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
{
DataSourceRequest request = new DataSourceRequest();
string sort, group, filter, aggregates;
int currentPage;
int pageSize;
if (TryGetValue(bindingContext, GridUrlParameters.Sort, out sort))
{
request.Sorts = GridDescriptorSerializer.Deserialize <SortDescriptor>(sort);
}
if (TryGetValue(bindingContext, GridUrlParameters.Page, out currentPage))
{
request.Page = currentPage;
}
if (TryGetValue(bindingContext, GridUrlParameters.PageSize, out pageSize))
{
request.PageSize = pageSize;
}
if (TryGetValue(bindingContext, GridUrlParameters.Filter, out filter))
{
request.Filters = FilterDescriptorFactory.Create(filter);
}
else
{
request.Filters = new System.Collections.Generic.List <IFilterDescriptor>();
}
if (TryGetValue(bindingContext, GridUrlParameters.Group, out group))
{
request.Groups = GridDescriptorSerializer.Deserialize <GroupDescriptor>(group);
}
if (TryGetValue(bindingContext, GridUrlParameters.Aggregates, out aggregates))
{
request.Aggregates = GridDescriptorSerializer.Deserialize <AggregateDescriptor>(aggregates);
}
bindingContext.Model = request;
return(true);
}
protected void BindFilters(IValueProvider valueProvider, PageDescriptorModel model)
{
var filterResult = valueProvider.GetValue(FilterKey);
var value = filterResult.FirstValue;
if (!string.IsNullOrEmpty(value))
{
var filterValues = value.Split(new[] { ";" }, StringSplitOptions.None);
foreach (var filterValue in filterValues)
{
var filter = FilterDescriptorFactory.Create(filterValue);
if (filter != null)
{
model.Filters.Add(filter);
}
}
}
}
public void OnActionExecuting(ActionExecutingContext filterContext)
{
string key = ActionParameterName;
IEnumerable <KeyValuePair <string, object> > source = filterContext.ActionParameters.Where(parameter => parameter.Value is GridCommand);
if (source.Count() == 1)
{
key = source.First().Key;
}
if (!filterContext.ActionParameters.ContainsKey(key))
{
return;
}
GridCommand gridCommand = (GridCommand)filterContext.ActionParameters[key] ?? new GridCommand();
gridCommand.Page = filterContext.Controller.ValueOf <int>(Prefix(GridUrlParameters.Page));
gridCommand.PageSize = filterContext.Controller.ValueOf <int>(Prefix(GridUrlParameters.PageSize));
string from1 = filterContext.Controller.ValueOf <string>(Prefix(GridUrlParameters.Sort));
gridCommand.SortDescriptors.AddRange(GridDescriptorSerializer.Deserialize <SortDescriptor>(from1));
string input = filterContext.Controller.ValueOf <string>(Prefix(GridUrlParameters.Filter));
if (input != null)
{
input = input.Replace('+', ' ');
}
gridCommand.FilterDescriptors.AddRange(FilterDescriptorFactory.Create(input));
string from2 = filterContext.Controller.ValueOf <string>(Prefix(GridUrlParameters.Group));
gridCommand.GroupDescriptors.AddRange(GridDescriptorSerializer.Deserialize <GroupDescriptor>(from2));
string from3 = filterContext.Controller.ValueOf <string>(Prefix(GridUrlParameters.Aggregates));
gridCommand.Aggregates.AddRange(GridDescriptorSerializer.Deserialize <AggregateDescriptor>(from3));
filterContext.ActionParameters[ActionParameterName] = gridCommand;
}
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
{
DataSourceRequest request = new DataSourceRequest();
string sort, group, filter, aggregates;
int currentPage;
int pageSize;
if (TryGetValue(bindingContext, GridUrlParameters.Sort, out sort))
{
request.Sorts = GridDescriptorSerializer.Deserialize <SortDescriptor>(sort);
}
if (TryGetValue(bindingContext, GridUrlParameters.Page, out currentPage))
{
request.Page = currentPage;
}
if (TryGetValue(bindingContext, GridUrlParameters.PageSize, out pageSize))
{
request.PageSize = pageSize;
}
if (TryGetValue(bindingContext, GridUrlParameters.Filter, out filter))
{
request.Filters = FilterDescriptorFactory.Create(filter);
}
if (TryGetValue(bindingContext, GridUrlParameters.Group, out group))
{
request.Groups = GridDescriptorSerializer.Deserialize <GroupDescriptor>(group);
}
if (TryGetValue(bindingContext, GridUrlParameters.Aggregates, out aggregates))
{
request.Aggregates = GridDescriptorSerializer.Deserialize <AggregateDescriptor>(aggregates);
}
return(request);
}
private static IList <IFilterDescriptor> ParseFilters(string body)
{
IList <IFilterDescriptor> filters = null;
dynamic json = JsonConvert.DeserializeObject <dynamic>(body);
if (json != null && json.filter != null)
{
dynamic filter = json.filter;
if (filter.filters != null)
{
if (filter.filters.ToString().Contains("logic"))
{
filters = ParseCompositeFilters(filter.ToString());
}
else
{
filters = ParseSimpleFilters(filter.ToString());
}
}
}
return(filters ?? FilterDescriptorFactory.Create(string.Empty));
}
public virtual void OnActionExecuting(ActionExecutingContext filterContext)
{
var parameterName = ActionParameterName;
var parametersOfGridCommandType = filterContext.ActionParameters
.Where(parameter => parameter.Value is GridCommand);
if (parametersOfGridCommandType.Count() == 1)
{
parameterName = parametersOfGridCommandType.First().Key;
}
if (filterContext.ActionParameters.ContainsKey(parameterName))
{
var command = ((GridCommand)filterContext.ActionParameters[parameterName] ?? new GridCommand());
command.Page = filterContext.Controller.ValueOf <int>(Prefix(GridUrlParameters.CurrentPage));
command.PageSize = filterContext.Controller.ValueOf <int>(Prefix(GridUrlParameters.PageSize));
var orderBy = filterContext.Controller.ValueOf <string>(Prefix(GridUrlParameters.OrderBy));
command.SortDescriptors.AddRange(GridDescriptorSerializer.Deserialize <SortDescriptor>(orderBy));
var filter = filterContext.Controller.ValueOf <string>(Prefix(GridUrlParameters.Filter));
command.FilterDescriptors.AddRange(FilterDescriptorFactory.Create(filter));
var groupBy = filterContext.Controller.ValueOf <string>(Prefix(GridUrlParameters.GroupBy));
command.GroupDescriptors.AddRange(GridDescriptorSerializer.Deserialize <GroupDescriptor>(groupBy));
var aggregates = filterContext.Controller.ValueOf <string>(Prefix(GridUrlParameters.Aggregates));
command.Aggregates.AddRange(GridDescriptorSerializer.Deserialize <AggregateDescriptor>(aggregates));
filterContext.ActionParameters[ActionParameterName] = command;
}
}
public void Should_return_empty_list_when_input_is_null()
{
Assert.Equal(0, FilterDescriptorFactory.Create(null).Count);
}
private static IList <IFilterDescriptor> ParseSimpleFilters(string filterInput)
{
CustomDataSourceRequestFilter filters = JsonConvert.DeserializeObject <CustomDataSourceRequestFilter>(filterInput);
return(FilterDescriptorFactory.Create(FilterFormat(filters)));
}
private static LambdaExpression GetFilter(this string filter, Type type, string parameterName = "i")
{
if (string.IsNullOrEmpty(filter))
{
return(null);
}
var parameterExpression = Expression.Parameter(type, parameterName);
var expressionBuilder = new FilterDescriptorCollectionExpressionBuilder(parameterExpression, FilterDescriptorFactory.Create(filter));
expressionBuilder.Options.LiftMemberAccessToNull = false;
return(expressionBuilder.CreateFilterExpression());
}
