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

ColumnFilterDescriptor Added Programmatically issue

6 Answers 352 Views
GridView
This is a migrated thread and some comments may be shown as answers.
jean-Marc
Top achievements
Rank 1
jean-Marc asked on 28 May 2011, 06:29 PM
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

6 Answers, 1 is accepted

Sort by
0
jean-Marc
Top achievements
Rank 1
answered on 28 May 2011, 07:44 PM
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
0
Rossen Hristov
Telerik team
answered on 30 May 2011, 08:43 AM
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
Do you want to have your say when we set our development plans? Do you want to know when a feature you care about is added or when a bug fixed? Explore the Telerik Public Issue Tracking system and vote to affect the priority of the items
0
loraine
Top achievements
Rank 1
answered on 30 May 2011, 10:01 AM
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
0
jean-Marc
Top achievements
Rank 1
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)
0
loraine
Top achievements
Rank 1
answered on 30 May 2011, 10:25 AM
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?
0
jean-Marc
Top achievements
Rank 1
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
Tags
GridView
Asked by
jean-Marc
Top achievements
Rank 1
Answers by
jean-Marc
Top achievements
Rank 1
Rossen Hristov
Telerik team
loraine
Top achievements
Rank 1
Share this question
or