ColumnFilterDescriptor Added Programmatically issue

[jean-Marc]

Hi Telerik team,

I implemented a save/restore feature of my UI including serialization of a RadGridView filters ...After repopulating programatically the ColumnFilterDescriptor everything seems to work fine, the data is filtered properly, the UI display exactly the filtered options....

Only issue is that when modifying my distinct values of one of my ColumnFilterDescriptor added in the code, the grid isn't filtered anymore, the GridFilterDescriptors_ItemChanged event isn't fire when chaning the distinct values ...

Please let me know if it's a known issue or if I missed something here? Maybe there is a proper order i.e. adding the filter before the binding occurs and data is loaded, or after...

Thanks in advanced for help.

Regards
Jean-Marc

[jean-Marc]

Hi Again,

after hours trying to understand my issue, I finally solved it.
While debugging I noticed the FilterDescriptors list from the composite (base) and I was not only adding the distinct values but adding also to this list...I simplified by just setting the specific FieldFilterDescriptor and or DistinctValuesFilterDescriptor and it is now working properly.

Jean-Marc

[Rossen Hristov]

Hello jean-Marc,

Can you take a look at my blog post, in case you haven't. Maybe it will make things clearer.

Greetings
Ross
the Telerik team

[loraine]

Hi Jean-Marc!

i tried the save/load/restore gridview settings as shown in the demo, but it didn't work...it still shows the default settings, and the settings are not change. how did you save the gridview settings?

Regards,
Loraine

[jean-Marc]

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)

[loraine]

Hi Jean-Marc,

thanks for posting your code. i'll try to understand it. it's quite a long code. it would be easier for me to understand clearly your code if you can show me a simple running application that can save the gridview settings.(filter settings) would it be okay with you?

[jean-Marc]

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