This is a migrated thread and some comments may be shown as answers.

ColumnFilterDescriptor Added Programmatically issue

6 Answers 460 Views

GridView

This is a migrated thread and some comments may be shown as answers.

This question is locked. New answers and comments are not allowed.

6 Answers, 1 is accepted

answered on 30 May 2011, 10:11 AM

Hi Lorraine,

well the code is a bit long but here is the main idea:

using System;

using System.IO;

using System.Text;

using System.Runtime.Serialization;

using System.Collections.Generic;

using System.Linq;

using Telerik.Windows.Controls;

using Telerik.Windows.Controls.GridView;

using Telerik.Windows.Data;

namespace FleetV4.Domain

{

public class RadFilterSerializer

{

protected FilterSet _filterSet;

private List<object> GetFiltersFromFilterDescriptors(IEnumerable<IFilterDescriptor> list)

{

var results = new List<object>();

foreach (var item in list)

{

var cdf = item as CompositeFilterDescriptor;

if (cdf != null)

{

var fs = new FilterSet

{

Operator = cdf.LogicalOperator,

Filters = GetFiltersFromFilterDescriptors(cdf.FilterDescriptors.ToList()),

// JIM add Class Type to unserialized other specific base class of filter for gridview

ClassType = cdf.GetType().ToString()

};

try { fs.Member = (item as ColumnFilterDescriptor).Column.UniqueName; }

catch { }

try { fs.Member = (item as DistinctValuesFilterDescriptor).Member; }

catch { }

try { fs.Member = (item as FieldFilterDescriptor).FieldName; fs.DataType = (item as FieldFilterDescriptor).DataType.ToString(); }

catch { }

results.Add(fs);

}

else

{

var df = item as FilterDescriptor;

if (df != null && !df.Value.GetType().ToString().Equals("Telerik.Windows.Data.FilterDescriptor+FilterDescriptorUnsetValue"))

{

var f = new Filter

{

IsCaseSensitive = df.IsCaseSensitive,

Member = df.Member,

Operator = df.Operator,

Value = df.Value,

// JIM add Class Type to unserialized other specific base class of filter for gridview

ClassType = df.GetType().ToString()

};

results.Add(f);

}

return results;

}

private IEnumerable<IFilterDescriptor> GetFilterDescriptorsFromFilters(IEnumerable<object> list)

{

var results = new List<IFilterDescriptor>();

foreach (var item in list)

{

var fs = item as FilterSet;

if (fs != null)

{

var cdf = new CompositeFilterDescriptor { LogicalOperator = fs.Operator, FilterDescriptors = new FilterDescriptorCollection() };

cdf.FilterDescriptors.AddRange(GetFilterDescriptorsFromFilters(fs.Filters));

results.Add(cdf);

}

else

{

var f = item as Filter;

if (f != null)

{

var df = new FilterDescriptor

{

IsCaseSensitive = f.IsCaseSensitive,

Member = f.Member,

Operator = f.Operator,

Value = f.Value

};

results.Add(df);

}

return results;

}

private IEnumerable<IFilterDescriptor> GetFilterDescriptorsFromFilters(IEnumerable<object> list, GridViewColumnCollection columns)

{

try

{

var results = new List<IFilterDescriptor>();

foreach (var item in list)

{

var fs = item as FilterSet;

if (fs != null)

{

object cdf = null;

if (fs.ClassType == typeof(CompositeFilterDescriptor).ToString())

{

cdf = new CompositeFilterDescriptor { LogicalOperator = fs.Operator, FilterDescriptors = new FilterDescriptorCollection() };

((CompositeFilterDescriptor)cdf).FilterDescriptors.AddRange(GetFilterDescriptorsFromFilters(fs.Filters, columns));

}

if (fs.ClassType == typeof(ColumnFilterDescriptor).ToString())

{

cdf = new ColumnFilterDescriptor((IDataFieldDescriptor)columns[fs.Member]);

// Special case here, don't pass the filter directly

// cf http://www.telerik.com/help/silverlight/radgridview-filtering-column-filter-descriptors.html

IEnumerable<IFilterDescriptor> columnFilters = GetFilterDescriptorsFromFilters(fs.Filters, columns);

foreach(IFilterDescriptor filter in columnFilters)

{

try

{

// usually the first is the DistinctValuesFilterDescriptor

if (filter.GetType() == typeof(DistinctValuesFilterDescriptor))

{

foreach (object distinctVal in (filter as DistinctValuesFilterDescriptor).DistinctValues)

{

(cdf as ColumnFilterDescriptor).DistinctFilter.DistinctValues.Add(distinctVal);

}

if (filter.GetType() == typeof(FieldFilterDescriptor))

{

FieldFilterDescriptor fieldfilter = filter as FieldFilterDescriptor;

if (fieldfilter.FilterDescriptors.Count > 0)

{

(cdf as ColumnFilterDescriptor).FieldFilter.Filter1.Operator = ((FilterDescriptor)fieldfilter.FilterDescriptors[0]).Operator;

(cdf as ColumnFilterDescriptor).FieldFilter.Filter1.Value = ((FilterDescriptor)fieldfilter.FilterDescriptors[0]).Value;

(cdf as ColumnFilterDescriptor).FieldFilter.LogicalOperator = fieldfilter.LogicalOperator;

if (fieldfilter.FilterDescriptors.Count > 1)

{

(cdf as ColumnFilterDescriptor).FieldFilter.Filter2.Operator = ((FilterDescriptor)fieldfilter.FilterDescriptors[1]).Operator;

(cdf as ColumnFilterDescriptor).FieldFilter.Filter2.Value = ((FilterDescriptor)fieldfilter.FilterDescriptors[1]).Value;

}

catch { }

}

// (cdf as ColumnFilterDescriptor).FilterDescriptors.AddRange(columnFilters);

}

if (fs.ClassType == typeof(DistinctValuesFilterDescriptor).ToString())

{

cdf = new DistinctValuesFilterDescriptor(fs.Member) { LogicalOperator = fs.Operator, FilterDescriptors = new FilterDescriptorCollection() };

((DistinctValuesFilterDescriptor)cdf).FilterDescriptors.AddRange(GetFilterDescriptorsFromFilters(fs.Filters, columns));

}

if (fs.ClassType == typeof(FieldFilterDescriptor).ToString())

{

// todo get real system.Type based on the serialized name :S

Type dataType = typeof(string);

cdf = new FieldFilterDescriptor(fs.Member, dataType) { LogicalOperator = fs.Operator, FilterDescriptors = new FilterDescriptorCollection() };

if (fs.Filters != null && fs.Filters.Count > 0)

((FieldFilterDescriptor)cdf).FilterDescriptors.AddRange(GetFilterDescriptorsFromFilters(fs.Filters, columns));

}

results.Add((IFilterDescriptor)cdf);

}

else

{

var f = item as Filter;

if (f != null)

{

object df = null;

if (f.ClassType == typeof(FilterDescriptor).ToString())

{

df = new FilterDescriptor

{

IsCaseSensitive = f.IsCaseSensitive,

Member = f.Member,

Operator = f.Operator,

Value = f.Value

};

}

if (df != null)

results.Add((IFilterDescriptor)df);

}

return results;

}

catch { return null; }

}

public string Serialize(CompositeFilterDescriptorCollection FilterDescriptors)

{

_filterSet = new

FilterSet { Operator = FilterDescriptors.LogicalOperator, Filters = GetFiltersFromFilterDescriptors(FilterDescriptors.ToList()) };

var serializer = new DataContractSerializer(typeof(FilterSet), new List<Type> { typeof(Filter) });

var stream = new MemoryStream();

serializer.WriteObject(stream, _filterSet);

var encoding = new UTF8Encoding();

var serializedFilters = encoding.GetString(stream.ToArray(), 0, (int)stream.Length);

return serializedFilters;

}

public void Rehydrate(string xml, CompositeFilterDescriptorCollection FilterDescriptors)

{

var serializer = new DataContractSerializer(typeof(FilterSet), new List<Type> { typeof(Filter) });

var encoding = new UTF8Encoding();

var stream = new MemoryStream(encoding.GetBytes(xml));

var fs = (FilterSet)serializer.ReadObject(stream);

FilterDescriptors.Clear();

FilterDescriptors.LogicalOperator = fs.Operator;

FilterDescriptors.AddRange(GetFilterDescriptorsFromFilters(fs.Filters));

}

public string Serialize(FilterDescriptorCollection FilterDescriptors)

{

_filterSet = new

FilterSet { Operator = FilterCompositionLogicalOperator.And, Filters = GetFiltersFromFilterDescriptors(FilterDescriptors.ToList()) };

var serializer = new DataContractSerializer(typeof(FilterSet), new List<Type> { typeof(Filter) });

var stream = new MemoryStream();

serializer.WriteObject(stream, _filterSet);

var encoding = new UTF8Encoding();

var serializedFilters = encoding.GetString(stream.ToArray(), 0, (int)stream.Length);

return serializedFilters;

}

public void Rehydrate(string xml, FilterDescriptorCollection FilterDescriptors, GridViewColumnCollection columns)

{

var serializer = new DataContractSerializer(typeof(FilterSet), new List<Type> { typeof(Filter) });

var encoding = new UTF8Encoding();

var stream = new MemoryStream(encoding.GetBytes(xml));

var fs = (FilterSet)serializer.ReadObject(stream);

FilterDescriptors.Clear();

//FilterDescriptors.LogicalOperator = fs.Operator;

FilterDescriptors.AddRange(GetFilterDescriptorsFromFilters(fs.Filters, columns));

}

public IEnumerable<IFilterDescriptor> Rehydrate(string xml, GridViewColumnCollection columns)

{

var serializer = new DataContractSerializer(typeof(FilterSet), new List<Type> { typeof(Filter) });

var encoding = new UTF8Encoding();

var stream = new MemoryStream(encoding.GetBytes(xml));

var fs = (FilterSet)serializer.ReadObject(stream);

return GetFilterDescriptorsFromFilters(fs.Filters, columns);

}

public static void

CopyFilterDescriptorsToRadFilter(FilterDescriptorCollection FDListFrom, CompositeFilterDescriptorCollection FilterDescriptors)

{

FilterDescriptors.Clear();

foreach (IFilterDescriptor iFilter in FDListFrom)

{

if (iFilter.GetType() == typeof(FilterDescriptor))

FilterDescriptors.Add(((FilterDescriptor)iFilter).Clone());

if (iFilter.GetType() == typeof(ICompositeFilterDescriptor))

FilterDescriptors.Add(((CompositeFilterDescriptor)iFilter).Clone());

if (iFilter.GetType() == typeof(ColumnFilterDescriptor))

{

ICompositeFilterDescriptor clone = ((ColumnFilterDescriptor)iFilter).Clone();

FilterDescriptors.Add(clone);

}

public static T DeserializeObject<T>(string serialized)

{

if (serialized == null) throw new ArgumentNullException("serialized");

DataContractSerializer dcs = new DataContractSerializer(typeof(T));

MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(serialized));

return (T)dcs.ReadObject(ms);

}

public static string SerializeObject(object obj)

{

if (obj == null) throw new ArgumentNullException("obj");

DataContractSerializer dcs = new DataContractSerializer(obj.GetType());

MemoryStream ms = new MemoryStream();

dcs.WriteObject(ms, obj);

return Encoding.UTF8.GetString(ms.GetBuffer(), 0, (int)ms.Position);

}

I serialize a simplified class: FilterSet (and Filter)

public class Filter

{

public Filter()

{

IsCaseSensitive = false;

Member = "";

Value = null;

Operator = FilterOperator.IsEqualTo;

ClassType = "";

}

public bool IsCaseSensitive { get; set; }

public string Member { get; set; }

public object Value { get; set; }

public FilterOperator Operator { get; set; }

public string ClassType { get; set; }

}

public class FilterSet

{

public FilterSet()

{

Filters = null;

Operator = FilterCompositionLogicalOperator.And;

ClassType = "";

Member = "";

DataType = "";

}

public List<object> Filters;

public FilterCompositionLogicalOperator Operator { get; set; }

public string ClassType { get; set; }

// JIM Add member for column cimposite filters

public string Member { get; set; }

public string DataType { get; set; }

}

Hope this helps
Jean-Marc (Jim)

answered on 30 May 2011, 10:57 AM

Hi,
unfortunately I cannot share my application (internal to my company).

maybe this can help you a bit more. Use the classes I posted earlier then when you handle the save/restore just put those pieces of code

for saving:

RadFilterSerializer serializer = new RadFilterSerializer();

string xml = serializer.Serialize(currentSelectionGridView.FilterDescriptors);

for restoring

RadFilterSerializer serializer = new RadFilterSerializer();

if

(xml!= String.Empty)



serializer.Rehydrate(xml, (CompositeFilterDescriptorCollection)currentSelectionGridView.FilterDescriptors, currentSelectionGridView.Columns);

the xml is my FilterSet serialized the whole thing is to convert my simple FilterSet to more complex Telerik Composite Filters...
Regards
Jean-Marc