protected virtual void InitializeViewInfo()
{
if (this.parentViewInfo != null)
{
this.rowsViewState = new VirtualGridTableViewState(this.parentViewInfo.RowCount, 24, this.parentViewInfo.RowSpacing, true);
this.columnsViewState = new VirtualGridTableViewState(this.parentViewInfo.ColumnCount, 100, this.parentViewInfo.CellSpacing, false);
this.showFilterRow = this.parentViewInfo.showFilterRow;
this.showHeaderRow = this.parentViewInfo.showHeaderRow;
this.allowColumnSort = this.parentViewInfo.allowColumnSort;
this.showNewRow = this.parentViewInfo.showNewRow;
this.allowColumnHeaderContextMenu = this.parentViewInfo.allowColumnHeaderContextMenu;
this.allowCellContextMenu = this.parentViewInfo.allowCellContextMenu;
this.allowEdit = this.parentViewInfo.allowEdit;
this.allowCut = this.parentViewInfo.allowCut;
this.allowCopy = this.parentViewInfo.allowCopy;
this.allowPaste = this.parentViewInfo.allowPaste;
this.enableAlternatingRowColor = this.parentViewInfo.enableAlternatingRowColor;
this.allowColumnResize = this.parentViewInfo.allowColumnResize;
this.allowRowResize = this.parentViewInfo.allowRowResize;
}
else
{
this.rowsViewState = new VirtualGridTableViewState(0, 24, -1, true);
this.columnsViewState = new VirtualGridTableViewState(0, 100, -1, false);
}
this.rowsViewState.PropertyChanged += new PropertyChangedEventHandler(this.rowsViewState_PropertyChanged);
this.columnsViewState.PropertyChanged += new PropertyChangedEventHandler(this.columnsViewState_PropertyChanged);
this.rowsViewState.PageIndexChanging += new VirtualGridPageChangingEventHandler(this.rowsViewState_PageIndexChanging);
this.rowsViewState.PageIndexChanged += new EventHandler(this.rowsViewState_PageIndexChanged);
this.childViewInfos = new Dictionary <int, VirtualGridViewInfo>();
this.sortDescriptors = new SortDescriptorCollection();
this.sortDescriptors.CollectionChanged += new NotifyCollectionChangedEventHandler(this.sortDescriptors_CollectionChanged);
this.filterDescriptors = new FilterDescriptorCollection();
this.filterDescriptors.CollectionChanged += new NotifyCollectionChangedEventHandler(this.filterDescriptors_CollectionChanged);
}
protected virtual ListFilterSelectedMode GetGridFilteredValues(
FilterDescriptorCollection descriptorCollection,
ref RadListFilterDistinctValuesTable selectedValuesList,
ref RadListFilterDistinctValuesTable excludedValuesList)
{
ListFilterSelectedMode filterSelectedMode = ListFilterSelectedMode.All;
foreach (FilterDescriptor descriptor in (Collection <FilterDescriptor>)descriptorCollection)
{
if (descriptor is CompositeFilterDescriptor)
{
filterSelectedMode = this.GetGridFilteredValues(((CompositeFilterDescriptor)descriptor).FilterDescriptors, ref selectedValuesList, ref excludedValuesList);
}
else if (descriptor.PropertyName == this.DataColumn.Name)
{
switch (descriptor.Operator)
{
case FilterOperator.None:
case FilterOperator.IsLike:
case FilterOperator.IsNotLike:
case FilterOperator.IsLessThan:
case FilterOperator.IsLessThanOrEqualTo:
case FilterOperator.IsGreaterThanOrEqualTo:
case FilterOperator.IsGreaterThan:
case FilterOperator.StartsWith:
case FilterOperator.EndsWith:
case FilterOperator.Contains:
case FilterOperator.NotContains:
case FilterOperator.IsContainedIn:
case FilterOperator.IsNotContainedIn:
filterSelectedMode = ListFilterSelectedMode.None;
continue;
case FilterOperator.IsEqualTo:
selectedValuesList.Add(descriptor.Value);
filterSelectedMode = ListFilterSelectedMode.Custom;
continue;
case FilterOperator.IsNotEqualTo:
excludedValuesList.Add(descriptor.Value);
filterSelectedMode = ListFilterSelectedMode.Custom;
continue;
case FilterOperator.IsNull:
return(ListFilterSelectedMode.Null);
case FilterOperator.IsNotNull:
return(ListFilterSelectedMode.NotNull);
default:
continue;
}
}
}
return(filterSelectedMode);
}
public TreeBasedFilterViewModel(FilterDescriptorCollection targetFilters)
{
SampleData = SampleDataGenerator.GenerateDataWithHierarchy();
_targetFilters = targetFilters;
CreateFilterDescriptor();
_filters.FilterDescriptors.CollectionChanged += FilterDescriptors_CollectionChanged;
}
private void SetFilterDescriptors(FilterDescriptorCollection value)
{
if (this.filterDescriptors != null)
{
this.UnsubscribeForFilterDescriptorCollectionEvents();
}
this.filterDescriptors = value;
this.SubscribeForFilterDescriptorCollectionEvents();
}
private void SetFilterDescriptors(FilterDescriptorCollection value)
{
if (this.filterDescriptors != null)
{
this.UnsubscribeForFilterDescriptorCollectionEvents();
}
this.filterDescriptors = value;
this.SubscribeForFilterDescriptorCollectionEvents();
}
public void PerformOperation(ItemSourceOperation operation, IList descriptors, bool force = false)
{
switch (operation)
{
case ItemSourceOperation.Filtering:
FilterDescriptorCollection filterDescriptors = descriptors as FilterDescriptorCollection;
if (this.lastFilterExpression == filterDescriptors.Expression && !force)
{
return;
}
this.lastFilterExpression = filterDescriptors.Expression;
break;
case ItemSourceOperation.Sorting:
SortDescriptorCollection sortDescriptors = descriptors as SortDescriptorCollection;
if (this.lastSortExpression == sortDescriptors.Expression && !force)
{
return;
}
this.lastSortExpression = sortDescriptors.Expression;
break;
default:
break;
}
OperationParameters operationParams = new OperationParameters(operation, descriptors);
this.queuedOperations.Enqueue(operationParams);
if (this.backgroundWorker.IsBusy)
{
OperationParameters peek;
bool peeked = this.queuedOperations.TryPeek(out peek);
if (peeked && peek.Operation == operationParams.Operation && peek != operationParams)
{
OperationParameters dequeued;
this.queuedOperations.TryDequeue(out dequeued);
}
else if (peeked && peek.Operation != operationParams.Operation)
{
this.perform = false;
}
}
if (!this.backgroundWorker.IsBusy)
{
this.perform = true;
this.backgroundWorker.RunWorkerAsync();
this.OnOperationStarted(new ItemSourceOperationEventArgs(operationParams.Operation));
}
}
protected virtual void Filter(FilterDescriptorCollection descriptors)
{
FilterDescriptor[] currentDescriptors = descriptors.ToArray();
ExpressionNode node = ExpressionParser.Parse(descriptors.Expression, this.masterTemplate.CaseSensitive);
if (this.CurrentOperation != ItemSourceOperation.None || node == null || currentDescriptors.Length == 0)
{
this.view = this.dataSource;
this.CurrentOperation = ItemSourceOperation.None;
return;
}
this.CurrentOperation = ItemSourceOperation.Filtering;
List <object> newView = new List <object>();
IList filteredView = this.dataSource;
for (int i = 0; i < filteredView.Count; i++)
{
if (!this.perform)
{
this.CurrentOperation = ItemSourceOperation.None;
return;
}
object entry = filteredView[i];
ExpressionContext context = new ExpressionContext();
for (int j = 0; j < currentDescriptors.Length; j++)
{
string member = currentDescriptors[j].PropertyName;
if (!context.ContainsKey(member))
{
context.Add(member, this.GetValue(entry, member));
}
else
{
context[member] = this.GetValue(entry, member);
}
}
object evalResult = node.Eval(null, context);
if (evalResult is bool && (bool)evalResult)
{
newView.Add(entry);
}
}
this.view = newView;
this.CurrentOperation = ItemSourceOperation.None;
}
public void InitializeDescriptors()
{
this.sortDescriptors = new SortDescriptorCollection((IDataDescriptorsHost)this);
this.sortDescriptors.CollectionChanged += this.OnSortDescriptorsCollectionChanged;
this.groupDescriptors = new GroupDescriptorCollection((IDataDescriptorsHost)this);
this.groupDescriptors.CollectionChanged += this.OnGroupDescriptorsCollectionChanged;
this.filterDescriptors = new FilterDescriptorCollection((IDataDescriptorsHost)this);
this.filterDescriptors.CollectionChanged += this.OnFilterDescriptorsCollectionChanged;
this.aggregateDescriptors = new AggregateDescriptorCollection((IDataDescriptorsHost)this);
this.aggregateDescriptors.CollectionChanged += this.OnAggregateDescriptorsCollectionChanged;
}
/// <summary>
/// Convert a FilterDescriptorCollection to FilterExpression
/// </summary>
/// <param name="filterDescriptors"></param>
/// <returns></returns>
public static FilterExpression Convert(FilterDescriptorCollection filterDescriptors)
{
FilterExpression filter = null;
FilterExpression tmpFilter = null;
List <FilterExpression> tmpFilterExpressions = new List <FilterExpression>();
foreach (var f in filterDescriptors)
{
if (f.GetType() == typeof(CompositeFilterDescriptor))
{
CompositeFilterDescriptor compositeFilterDescriptor = (CompositeFilterDescriptor)f;
FilterExpression compositeFilter = null;
compositeFilter = Convert(compositeFilterDescriptor.FilterDescriptors);
if (compositeFilter != null)
{
if (filter != null)
{
tmpFilter = filter;
filter = BinaryFilterExpression.And(tmpFilter, compositeFilter);
}
else
{
filter = compositeFilter;
}
}
}
else
if (f.GetType() == typeof(FilterDescriptor))
{
FilterExpression fe = convert(f);
if (fe != null)
{
if (filter != null)
{
tmpFilter = filter;
filter = BinaryFilterExpression.And(tmpFilter, fe);
}
else
{
filter = fe;
}
}
}
}
return(filter);
}
/// <summary>
/// Event after grid has applied filtering. calls method to re-weight the Portfolio, Benchmark & Active-Position %
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void dgPortfolioDetails_Filtered(object sender, Telerik.Windows.Controls.GridView.GridViewFilteredEventArgs e)
{
string methodNamespace = String.Format("{0}.{1}", GetType().FullName, System.Reflection.MethodInfo.GetCurrentMethod().Name);
Logging.LogBeginMethod(this.DataContextPortfolioDetails.Logger, methodNamespace);
try
{
// SetGroupedData();
gridFilterDescriptors = dgPortfolioDetails.FilterDescriptors;
}
catch (Exception ex)
{
Prompt.ShowDialog("Message: " + ex.Message + "\nStackTrace: " + Logging.StackTraceToString(ex), "Exception", MessageBoxButton.OK);
Logging.LogException(this.DataContextPortfolioDetails.Logger, ex);
}
}
private List <IFilterDescriptor> GetFilterData(IQueryCollection args)
{
IEnumerable <IFilterDescriptor> filters = new List <IFilterDescriptor>();
var filterKeys = args.Where(o => o.Key.Contains("filterModel"))
.GroupBy(o => o.Key.Substring(o.Key.IndexOf("[") + 1, o.Key.IndexOf("]") - o.Key.IndexOf("[") - 1))
.Select(o => o.Key).ToArray();
foreach (var key in filterKeys)
{
string filterType = args.FirstOrDefault(o => o.Key.Contains($"filterModel[{key}][filterType]")).Value.ToString();
string type = args.FirstOrDefault(o => o.Key.Contains($"filterModel[{key}][type]")).Value.ToString();
var conditions = args.Where(o => o.Key.Contains($"filterModel[{key}][condition")).GroupBy(o => o.Key.Substring(o.Key.IndexOf("[condition"), 12)).ToArray();
if (conditions.Any())
{
string oprt = args.First(o => o.Key.Contains($"filterModel[{key}][operator]")).Value.ToString();
var compositeFilter = new CompositeFilterDescriptor();
IEnumerable <IFilterDescriptor> filterSubItems = new FilterDescriptorCollection();
var maxConditionCount = Math.Min(conditions.Count(), 9);
for (var i = 0; i < maxConditionCount; i++)
{
string condetionFilterType = args.FirstOrDefault(o => o.Key.Contains($"filterModel[{key}][condition{i + 1}][filterType]")).Value.ToString();
string conditionType = args.FirstOrDefault(o => o.Key.Contains($"filterModel[{key}][condition{i + 1}][type]")).Value.ToString();
string conditionFilter = args.FirstOrDefault(o => o.Key.Contains($"filterModel[{key}][condition{i + 1}][filter]")).Value.ToString();
string conditionFilterTo = args.FirstOrDefault(o => o.Key.Contains($"filterModel[{key}][condition{i + 1}][filterTo]")).Value.ToString();
//toto should be correct
filterSubItems = AddFilterDescriptor(filterSubItems, key, condetionFilterType, conditionType, conditionFilter, conditionFilterTo);
}
var collection = new FilterDescriptorCollection();
collection.AddRange(filterSubItems.ToList());
compositeFilter.FilterDescriptors = collection;
compositeFilter.LogicalOperator = (oprt == "AND" ? FilterCompositionLogicalOperator.And : FilterCompositionLogicalOperator.Or);
filters = filters.Concat(new List <IFilterDescriptor>()
{
compositeFilter
});
}
else
{
string filter = args.FirstOrDefault(o => o.Key.Contains($"filterModel[{key}][filter]")).Value.ToString();
string filterTo = args.FirstOrDefault(o => o.Key.Contains($"filterModel[{key}][filterTo]")).Value.ToString();
filters = AddFilterDescriptor(filters, key, filterType, type, filter, filterTo);
}
}
return(filters.ToList());
}
static IEnumerable <IFilterDescriptor> AddToRangeFilters(IEnumerable <IFilterDescriptor> filters, string key, FilterOperator op1, object val1, FilterOperator op2, object val2)
{
var compositeFilter = new CompositeFilterDescriptor();
var filterSubItems = new FilterDescriptorCollection();
filterSubItems.Add(new FilterDescriptor()
{
Member = key, Operator = op1, Value = val1
});
filterSubItems.Add(new FilterDescriptor()
{
Member = key, Operator = op2, Value = val2
});
compositeFilter.FilterDescriptors = filterSubItems;
compositeFilter.LogicalOperator = FilterCompositionLogicalOperator.And;
return(filters.Concat(new List <IFilterDescriptor>()
{
compositeFilter
}));
}
public void CollectionManagerCollatesFilterDescriptorEvents()
{
FilterDescriptorCollection collection = new FilterDescriptorCollection();
ExpressionCache cache = new ExpressionCache();
FilterDescriptor descriptor = null;
this.CollectionManagerCollatesTemplate(
(validationAction) =>
{
return(new FilterCollectionManager(collection, cache, fd => validationAction()));
},
() =>
{
collection.Add(new FilterDescriptor());
},
() =>
{
collection[0].PropertyPath = "First";
},
() =>
{
collection.Add(new FilterDescriptor());
},
() =>
{
collection[1].PropertyPath = "Second";
},
() =>
{
collection[1] = new FilterDescriptor();
},
() =>
{
descriptor = collection[0];
collection.Remove(descriptor);
},
() =>
{
descriptor.PropertyPath = "Removed";
});
}
private void ProcessFilterDescriptors(
GridViewTemplate template,
FilterDescriptorCollection filterDescriptorCollection)
{
foreach (FilterDescriptor filterDescriptor1 in (Collection <FilterDescriptor>)filterDescriptorCollection)
{
CompositeFilterDescriptor filterDescriptor2 = filterDescriptor1 as CompositeFilterDescriptor;
if (filterDescriptor2 != null)
{
this.ProcessFilterDescriptors(template, filterDescriptor2.FilterDescriptors);
}
else
{
GridViewDataColumn[] columnByFieldName = template.Columns.GetColumnByFieldName(filterDescriptor1.PropertyName);
if (columnByFieldName != null && columnByFieldName.Length > 0)
{
GridViewDataColumn gridViewDataColumn = columnByFieldName[0];
filterDescriptor1.Value = RadDataConverter.Instance.Parse((IDataConversionInfoProvider)gridViewDataColumn, filterDescriptor1.Value);
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FilterCollectionManager"/> class.
/// </summary>
/// <param name="sourceCollection">The collection of <see cref="FilterDescriptor"/>s to manage</param>
/// <param name="expressionCache">The cache with entries for the <see cref="FilterDescriptor"/>s</param>
/// <param name="validationAction">The callback for validating items that are added or changed</param>
public FilterCollectionManager(FilterDescriptorCollection sourceCollection, ExpressionCache expressionCache, Action<FilterDescriptor> validationAction)
{
if (sourceCollection == null)
{
throw new ArgumentNullException("sourceCollection");
}
if (expressionCache == null)
{
throw new ArgumentNullException("expressionCache");
}
if (validationAction == null)
{
throw new ArgumentNullException("validationAction");
}
this.ExpressionCache = expressionCache;
this._sourceCollection = sourceCollection;
this.ValidationAction = (item) => validationAction((FilterDescriptor)item);
this.AsINotifyPropertyChangedFunc = (item) => ((FilterDescriptor)item).Notifier;
this.AddCollection(this._sourceCollection);
}
protected override bool ProcessListOverride(
XmlReader reader,
object listOwner,
PropertyDescriptor ownerProperty,
IList list)
{
if (list is GridViewTemplateCollection)
{
this.ReadMergeCollection(reader, listOwner, ownerProperty, list, (string)null);
return(true);
}
if (!(list is GridViewColumnCollection))
{
return(base.ProcessListOverride(reader, listOwner, ownerProperty, list));
}
GridViewColumnCollection columnCollection = list as GridViewColumnCollection;
columnCollection.BeginUpdate();
FilterDescriptorCollection descriptorCollection = (FilterDescriptorCollection)null;
if (columnCollection.Owner != null)
{
descriptorCollection = columnCollection.Owner.FilterDescriptors;
}
descriptorCollection?.BeginUpdate();
for (int index = 0; index < list.Count; ++index)
{
GridViewDataColumn gridViewDataColumn = list[index] as GridViewDataColumn;
if (gridViewDataColumn != null)
{
gridViewDataColumn.FilterDescriptor = (FilterDescriptor)null;
}
}
this.ReadMergeCollection(reader, listOwner, ownerProperty, list, "UniqueName");
descriptorCollection?.EndUpdate();
columnCollection.EndUpdate();
return(true);
}
private static LambdaExpression BuildFilter(Type elementType, FilterDescriptorCollection filters)
{
ParameterExpression pe = Expression.Parameter(elementType, "fltr");
Expression expression = null;
foreach (FilterDescriptor filter in filters)
{
PropertyInfo pi = elementType.GetProperty(filter.PropertyName);
if (filter.Value == null)
{
if (pi.PropertyType.IsValueType)
{
filter.Value = Activator.CreateInstance(pi.PropertyType);
}
}
if (filter.GetType() != pi.PropertyType)
{
filter.Value = Convert.ChangeType(filter.Value, pi.PropertyType);
}
Expression value = Expression.Constant(filter.Value);
Expression property = Expression.Property(pe, filter.PropertyName);
Expression comparison = null;
switch (filter.Operator)
{
case FilterOperator.None:
comparison = Expression.Empty();
break;
case FilterOperator.IsLessThan:
comparison = Expression.LessThan(property, value);
break;
case FilterOperator.IsLessThanOrEqualTo:
comparison = Expression.LessThanOrEqual(property, value);
break;
case FilterOperator.IsEqualTo:
case FilterOperator.IsLike:
comparison = Expression.Equal(property, value);
break;
case FilterOperator.IsNotEqualTo:
case FilterOperator.IsNotLike:
comparison = Expression.NotEqual(property, value);
break;
case FilterOperator.IsGreaterThanOrEqualTo:
comparison = Expression.GreaterThanOrEqual(property, value);
break;
case FilterOperator.IsGreaterThan:
comparison = Expression.GreaterThan(property, value);
break;
case FilterOperator.StartsWith:
comparison = FilterHelper.GenerateStringMethodCall(StringStartsWithMethodInfo, property, value);
break;
case FilterOperator.EndsWith:
comparison = FilterHelper.GenerateStringMethodCall(StringEndsWithMethodInfo, property, value);
break;
case FilterOperator.Contains:
case FilterOperator.IsContainedIn:
comparison = FilterHelper.GenerateStringMethodCall(StringContainsMethodInfo, property, value);
break;
case FilterOperator.NotContains:
case FilterOperator.IsNotContainedIn:
comparison = Expression.Not(FilterHelper.GenerateStringMethodCall(StringContainsMethodInfo, property, value));
break;
case FilterOperator.IsNull:
comparison = Expression.Equal(property, Expression.Constant(null));
break;
case FilterOperator.IsNotNull:
comparison = Expression.NotEqual(property, Expression.Constant(null));
break;
}
if (expression == null)
{
expression = comparison;
continue;
}
if (filters.LogicalOperator == FilterLogicalOperator.And)
{
expression = Expression.AndAlso(expression, comparison);
}
else
{
expression = Expression.OrElse(expression, comparison);
}
}
return(Expression.Lambda(expression, pe));
}
public static DataServiceQuery <T> Filter <T>(DataServiceQuery <T> queryable, FilterDescriptorCollection filters) where T : ISavableObject
{
DataServiceQuery <T> query = queryable;
if (filters != null && filters.Count > 0)
{
Expression predicate = FilterHelper.BuildFilter(query.ElementType, filters);
var exp = Expression.Call(typeof(Queryable), "Where", new[] { query.ElementType }, query.Expression, Expression.Quote(predicate));
query = query.Provider.CreateQuery(exp) as DataServiceQuery <T>;
}
return(query);
}
/// <summary>
/// Produces the Linq expression representing the entire filter descriptors collection.
/// </summary>
/// <param name="filterDescriptors">Collection of filters</param>
/// <param name="filterOperator">The operator used to combine filters</param>
/// <param name="expressionCache">Cache for storing built expressions</param>
/// <returns>Produced linq expression, which can be <c>null</c> if there are no filter descriptors.</returns>
public static Expression BuildFiltersExpression(
FilterDescriptorCollection filterDescriptors,
FilterDescriptorLogicalOperator filterOperator,
ExpressionCache expressionCache)
{
Debug.Assert(filterDescriptors != null, "Unexpected null filterDescriptors");
Expression filtersExpression = null;
foreach (FilterDescriptor filterDescriptor in filterDescriptors)
{
// Ignored filters will not have a cache entry
if (expressionCache.ContainsKey(filterDescriptor))
{
Expression filterExpression = expressionCache[filterDescriptor];
if (filtersExpression == null)
{
filtersExpression = filterExpression;
}
else if (filterOperator == FilterDescriptorLogicalOperator.And)
{
filtersExpression = Expression.AndAlso(filtersExpression, filterExpression);
}
else
{
filtersExpression = Expression.OrElse(filtersExpression, filterExpression);
}
}
}
return filtersExpression;
}
private void SetFilterDescriptors(FilterDescriptorCollection value)
{
filterDescriptors = value;
}
public void CollectionManagerCollatesFilterDescriptorEvents()
{
FilterDescriptorCollection collection = new FilterDescriptorCollection();
ExpressionCache cache = new ExpressionCache();
FilterDescriptor descriptor = null;
this.CollectionManagerCollatesTemplate(
(validationAction) =>
{
return new FilterCollectionManager(collection, cache, fd => validationAction());
},
() =>
{
collection.Add(new FilterDescriptor());
},
() =>
{
collection[0].PropertyPath = "First";
},
() =>
{
collection.Add(new FilterDescriptor());
},
() =>
{
collection[1].PropertyPath = "Second";
},
() =>
{
collection[1] = new FilterDescriptor();
},
() =>
{
descriptor = collection[0];
collection.Remove(descriptor);
},
() =>
{
descriptor.PropertyPath = "Removed";
});
}
