/// <summary>
/// Create PropertyFilter for instance of FilterPresenter, if it is possible.
/// </summary>
/// <param name="filterPresenter">filterPresenter for that filter will be created.</param>
/// <param name="key">ItemPropertyInfo cpecified property that PropertyFilter will be use.</param>
/// <returns>Instance of GreaterOrEqualFilter if:
/// filterPresenter.ItemProperties.Contains(propertyInfo)
/// && typeof(IComparable).IsAssignableFrom(propertyInfo.PropertyType)
/// && propertyInfo.PropertyType!=typeof(String)
/// && propertyInfo.PropertyType != typeof(bool)
/// && !propertyType.IsEnum
/// otherwise, null.</returns>
protected override PropertyFilter NewFilter(FilterPresenter filterPresenter, ItemPropertyInfo key)
{
if (filterPresenter == null)
{
return(null);
}
if (key == null)
{
return(null);
}
ItemPropertyInfo propertyInfo = (ItemPropertyInfo)key;
Type propertyType = propertyInfo.PropertyType;
if (filterPresenter.ItemProperties.Contains(propertyInfo) &&
typeof(IComparable).IsAssignableFrom(propertyInfo.PropertyType) &&
propertyInfo.PropertyType != typeof(string) &&
propertyInfo.PropertyType != typeof(bool) &&
!propertyType.IsEnum)
{
try
{
return((PropertyFilter)Activator.CreateInstance(typeof(GreaterOrEqualFilter <>).MakeGenericType(propertyInfo.PropertyType), propertyInfo));
}
catch (System.ArgumentException ex)
{
return(null);
}
}
return(null);
}
public override Filter TryCreateFilter(FilterPresenter filterPresenter, object key)
{
var filter = new UnitPriceEqualFilter();
filter.Attach(filterPresenter);
return(filter);
}
/// <summary>
/// Create LessOrEqualFilter for instance of FilterPresenter, if it is possible.
/// </summary>
/// <param name="filterPresenter">FilterPresenter, which can be attached Filter</param>
/// <param name="key">ItemPropertyInfo for binding to property.</param>
/// <returns>Instance of LessOrEqualFilter class or null</returns>
protected override PropertyFilter NewFilter(FilterPresenter filterPresenter, ItemPropertyInfo propertyInfo)
{
Debug.Assert(filterPresenter != null);
Debug.Assert(propertyInfo != null);
// ItemPropertyInfo propertyInfo = (ItemPropertyInfo)key;
Type propertyType = propertyInfo.PropertyType;
if (filterPresenter.ItemProperties.Contains(propertyInfo) &&
typeof(IComparable).IsAssignableFrom(propertyType) &&
propertyType != typeof(string) &&
propertyType != typeof(bool) &&
!propertyType.IsEnum)
{
Type gt;
try
{
gt = typeof(LessOrEqualFilter <>).MakeGenericType(propertyInfo.PropertyType);
}
catch (System.ArgumentException ex)
{
return(null);
}
return((PropertyFilter)Activator.CreateInstance(gt, propertyInfo));
}
return(null);
}
/// <summary>
/// Handles changes to the ParentCollection property.
/// </summary>
private static void OnParentCollectionChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
CityFilter target = (CityFilter)d;
IEnumerable <CityItem> oldParentCollection = (IEnumerable <CityItem>)e.OldValue;
if (target.filterPresenter != null)
{
bool isActive = target.IsActive;
if (isActive)
{
target.IsActive = false;
}
target.filterPresenter.ReceiveFilterChanged(target);
if (isActive)
{
target.IsActive = true;
}
}
IEnumerable <CityItem> newParentCollection = target.ParentCollection;
target.filterPresenter = FilterPresenter.TryGet(newParentCollection);
if (target.filterPresenter != null)
{
target.filterPresenter.ReceiveFilterChanged(target);
}
target.OnParentCollectionChanged(oldParentCollection, newParentCollection);
}
public void GetFilterControlVm()
{
var items = StateItem.All;
ListCollectionView view = new(items);
IEnumerable <FilterInitializer> initializers = FilterInitializersManager.Default;
FilterPresenter?filterPresenter = FilterPresenter.Get(view);
{
string key = nameof(StateItem.Id);
var vm = filterPresenter.TryGetFilterControlVm(key, initializers);
var filterTypes = vm.Select(v => v.GetType()).ToList();
Assert.Contains(typeof(ObjectEqualFilter), filterTypes);
}
{
string key = nameof(StateItem.StateId);
var vm = filterPresenter.TryGetFilterControlVm(key, initializers);
var filterTypes = vm.Select(v => v.GetType()).ToList();
Assert.Contains(typeof(EqualFilter <int>), filterTypes);
Assert.Contains(typeof(LessOrEqualFilter <int>), filterTypes);
Assert.Contains(typeof(GreaterOrEqualFilter <int>), filterTypes);
Assert.Contains(typeof(RangeFilter <int>), filterTypes);
}
{
string key = nameof(StateItem.State);
var vm = filterPresenter.TryGetFilterControlVm(key, initializers);
var filterTypes = vm.Select(v => v.GetType()).ToList();
Assert.Contains(typeof(EnumFilter <StateEnum>), filterTypes);
}
{
string key = nameof(StateItem.StateText);
var vm = filterPresenter.TryGetFilterControlVm(key, initializers);
var filterTypes = vm.Select(v => v.GetType()).ToList();
Assert.Contains(typeof(EqualFilter <string>), filterTypes);
Assert.Contains(typeof(StringFilter), filterTypes);
}
}
public void TryGetFilter()
{
#pragma warning disable CS8604 // Possible null reference argument.
#pragma warning disable CS8602 // Dereference of a possibly null reference.
var items = StateItem.All;
ListCollectionView view = new(items);
Assert.IsTrue(view.CanFilter);
Assert.IsNotNull(view.ItemProperties);
FilterPresenter?filterPresenter = FilterPresenter.Get(view);
Assert.IsNotNull(filterPresenter);
EqualFilterInitializer initializer = new();
EqualFilter? filter = initializer.TryCreateFilter(filterPresenter, nameof(StateItem.StateId)) as EqualFilter;
Assert.IsNotNull(filter);
Assert.IsFalse(filter.IsActive);
Assert.AreSame(filterPresenter, filter.FilterPresenter);
Assert.AreEqual(items.Count, view.Count);
List <int> selected = new(new int[] { (int)StateEnum.State1, (int)StateEnum.State4 });
List <int> unselected = new();
filter.SelectedValuesChanged(addedItems: selected, removedItems: unselected);
Assert.IsTrue(filter.IsActive);
var filtered = FilterPresenterTest.GetCollection(view);
Assert.AreEqual(selected.Count, filtered.Count);
Assert.AreEqual(selected[0], ((StateItem)filtered[0]).StateId);
Assert.AreEqual(selected[1], ((StateItem)filtered[1]).StateId);
//filterPresenter.IsFilterActive = false;
filtered = FilterPresenterTest.GetCollection(view);
Assert.AreEqual(items.Count, filtered.Count);
#pragma warning restore CS8602 // Dereference of a possibly null reference.
#pragma warning restore CS8604 // Possible null reference argument.
}
public void TryGetFilter()
{
#pragma warning disable CS8604 // Possible null reference argument.
#pragma warning disable CS8602 // Dereference of a possibly null reference.
var items = StateItem.All;
var compareFrom = StateEnum.State2;
var compareTo = StateEnum.State3;
var expected = Enum.GetValues <StateEnum>()
.Where(st => st >= compareFrom & st <= compareTo)
.Select(st => new StateItem(st))
.ToList();
ListCollectionView view = new(items);
Assert.IsTrue(view.CanFilter);
Assert.IsNotNull(view.ItemProperties);
FilterPresenter?filterPresenter = FilterPresenter.Get(view);
Assert.IsNotNull(filterPresenter);
RangeFilterInitializer initializer = new();
RangeFilter <int>? filter = initializer.TryCreateFilter(filterPresenter, nameof(StateItem.StateId)) as RangeFilter <int>;
Assert.IsNotNull(filter);
Assert.IsFalse(filter.IsActive);
Assert.AreSame(filterPresenter, filter.FilterPresenter);
Assert.AreEqual(view.Count, items.Count);
filter.CompareTo = (int)compareTo;
filter.CompareFrom = (int)compareFrom;
Assert.IsTrue(filter.IsActive);
var filtered = FilterPresenterTest.GetCollection(view);
Assert.AreEqual(expected.Count, filtered.Count);
Assert.AreEqual(expected[0].StateId, ((StateItem)filtered[0]).StateId);
Assert.AreEqual(expected[^ 1].StateId, ((StateItem)filtered[^ 1]).StateId);
/// <summary>
/// Returns a query that returns the unique item property values in the ItemsSource collection..
/// </summary>
public static IEnumerable GetAvailableValuesQuery(FilterPresenter filterPresenter, ItemPropertyInfo propInfo)
{
IEnumerable source = filterPresenter.CollectionView.SourceCollection;
if (source == null)
{
return(new object[0]);
}
var propertyDescriptor = propInfo.Descriptor as PropertyDescriptor;
var sourceQuery = source.OfType <object>().Select(item => propertyDescriptor.GetValue(item));
var propType = propertyDescriptor.PropertyType;
if (typeof(IComparable).IsAssignableFrom(propType))
{
sourceQuery = sourceQuery.OrderBy(item => item);
}
else
{
sourceQuery = sourceQuery.OrderBy(item => item == null ? string.Empty : item.ToString());
}
sourceQuery = sourceQuery.Distinct();
return(sourceQuery);
}
/// <summary>
/// Generate new instance of Filter class, if it is possible for filterPresenter and key.
/// </summary>
/// <param name="filterPresenter">FilterPresenter, which can be attached Filter</param>
/// <param name="key">Key for generated Filter. For PropertyFilter, key used as the name for binding property in filterPresenter.Parent collection.</param>
/// <returns>Instance of Filter class or null.</returns>
public override Model.Filter NewFilter(FilterPresenter filterPresenter, object key)
{
Debug.Assert(filterPresenter != null);
Debug.Assert(key != null);
EqualFilter <object> filter = new EqualFilter <object>(item => item, filterPresenter.CollectionView.SourceCollection);
return(filter);
}
/// <summary>
/// Determines whether the specified target is a match.
/// </summary>
public override void IsMatch(FilterPresenter sender, FilterEventArgs e)
{
if (IsActive && e.Accepted)
{
object?value = getter(e.Item);
e.Accepted = SelectedValues.Any <object>(val => Object.Equals(value, val));
}
}
public void Attach(FilterPresenter presenter)
{
filterPresenter = presenter;
if (filterPresenter != null)
{
filterPresenter.ReceiveFilterChanged(this);
}
OnAttachPresenter(presenter);
}
internal void Attach(FilterPresenter presenter)
{
FilterPresenter = presenter;
if (FilterPresenter != null)
{
FilterPresenter.ReceiveFilterChanged(this);
}
OnAttachPresenter(presenter);
}
public override Filter?TryCreateFilter(FilterPresenter filterPresenter, object key)
{
if (key != null && filterPresenter.CollectionView.SourceCollection is IEnumerable <Customer> )
{
var filter = new CustomersComboBoxFilter();
filter.Attach(filterPresenter);
return(filter);
}
return(null);
}
/// <summary>
/// Generate new instance of Filter class, if it is possible for filterPresenter and key.
/// </summary>
/// <param name="filterPresenter">FilterPresenter, which can be attached Filter</param>
/// <param name="key">Key for generated Filter. For PropertyFilter, key used as the name for binding property in filterPresenter.Parent collection.</param>
/// <returns>Instance of Filter class or null.</returns>
public override Model.Filter TryCreateFilter(FilterPresenter filterPresenter, object key)
{
#if DEBUG
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsNotNull(filterPresenter);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsNotNull(key);
#endif
ObjectEqualFilter filter = new(item => item, filterPresenter.CollectionView.SourceCollection);
filter.Attach(filterPresenter);
return(filter);
}
/// <summary>
/// Report attached listeners that filter changed.
/// </summary>
protected void RaiseFilterChanged()
{
if (FilterPresenter != null)
{
FilterPresenter.ReceiveFilterChanged(this);
}
foreach (var vm in attachedFilterControlVmodels)
{
vm.FilterChanged(this);
}
}
/// <summary>
/// Generate new instance of EnumFilter class, if it is possible for a pair of filterPresenter and propertyInfo.
/// </summary>
/// <param name="filterPresenter">FilterPresenter, which can be attached Filter</param>
/// <param name="key">Key, used as the name for binding property in filterPresenter.Parent collection.</param>
/// <returns>Instance of EnumFilter class or null.</returns>
protected override PropertyFilter NewFilter(FilterPresenter filterPresenter, ItemPropertyInfo propertyInfo)
{
Debug.Assert(filterPresenter != null);
Debug.Assert(propertyInfo != null);
Type propertyType = propertyInfo.PropertyType;
if (filterPresenter.ItemProperties.Contains(propertyInfo) && propertyType.IsEnum)
{
return((PropertyFilter)Activator.CreateInstance(typeof(EnumFilter <>).MakeGenericType(propertyInfo.PropertyType), propertyInfo));
}
return(null);
}
public void CTOR()
{
int[] source = { 1, 2, 3 };
//var fp_empty = FilterPresenter.Get(null);
//Assert.IsNull(fp_empty);
var fp1 = FilterPresenter.Get(source);
Assert.IsNotNull(fp1);
var fp2 = FilterPresenter.Get(source);
Assert.AreSame(fp1, fp2);
}
/// <summary>
/// Generate new instance of Filter class, if it is possible for filterPresenter and key.
/// </summary>
/// <param name="filterPresenter">FilterPresenter, which can be attached Filter</param>
/// <param name="key">Key for generated Filter. For PropertyFilter, key used as the name for binding property in filterPresenter.Parent collection.</param>
/// <returns>Instance of Filter class or null.</returns>
#pragma warning disable CA1822 // Mark members as static
public Model.Filter TrygetFilter <T>(FilterPresenter filterPresenter, T key)
#pragma warning restore CA1822 // Mark members as static
where T : class
{
#if DEBUG
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsNotNull(filterPresenter);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsNotNull(key);
#endif
ObjectEqualFilter filter = new(item => item, filterPresenter.CollectionView.SourceCollection);
filter.Attach(filterPresenter);
return(filter);
}
public void TryGetFilter()
{
#pragma warning disable CS8604 // Possible null reference argument.
#pragma warning disable CS8602 // Dereference of a possibly null reference.
var items = StateItem.All;
var compareTo = StateEnum.State3;
ListCollectionView view = new(items);
Assert.IsTrue(view.CanFilter);
Assert.IsNotNull(view.ItemProperties);
FilterPresenter?filterPresenter = FilterPresenter.Get(view);
Assert.IsNotNull(filterPresenter);
StringFilterInitializer initializer = new();
StringFilter? filter = initializer.TryCreateFilter(filterPresenter, nameof(StateItem.StateText)) as StringFilter;
Assert.IsNotNull(filter);
Assert.IsFalse(filter.IsActive);
Assert.AreSame(filterPresenter, filter.FilterPresenter);
Assert.AreEqual(view.Count, items.Count);
filter.Value = compareTo.ToString();
filter.Mode = StringFilterMode.Equals;
var expected = Enum.GetValues <StateEnum>()
.Where(st => st == compareTo)
.Select(st => new StateItem(st))
.ToList();
Assert.IsTrue(filter.IsActive);
var filtered = FilterPresenterTest.GetCollection(view);
Assert.AreEqual(1, filtered.Count);
Assert.AreEqual(expected[0].StateId, ((StateItem)filtered[0]).StateId);
filter.Value = "4";
filter.Mode = StringFilterMode.EndsWith;
compareTo = StateEnum.State4;
expected = Enum.GetValues <StateEnum>()
.Where(st => st == compareTo)
.Select(st => new StateItem(st))
.ToList();
Assert.IsTrue(filter.IsActive);
filtered = FilterPresenterTest.GetCollection(view);
Assert.AreEqual(1, filtered.Count);
Assert.AreEqual(expected[0].StateId, ((StateItem)filtered[0]).StateId);
filter.Value = "St";
filter.Mode = StringFilterMode.StartsWith;
expected = Enum.GetValues <StateEnum>()
.Select(st => new StateItem(st))
.ToList();
Assert.IsTrue(filter.IsActive);
filtered = FilterPresenterTest.GetCollection(view);
Assert.AreEqual(expected.Count, filtered.Count);
Assert.AreEqual(expected[0].StateId, ((StateItem)filtered[0]).StateId);
Assert.AreEqual(expected[^ 1].StateId, ((StateItem)filtered[^ 1]).StateId);
/// <summary>
/// Create new instance of StringFilter, if it is possible for filterPresenter in current state and key.
/// </summary>
protected override PropertyFilter NewFilter(FilterPresenter filterPresenter, ItemPropertyInfo propertyInfo)
{
Debug.Assert(filterPresenter != null);
Debug.Assert(propertyInfo != null);
Type propertyType = propertyInfo.PropertyType;
if (filterPresenter.ItemProperties.Contains(propertyInfo) && typeof(String).IsAssignableFrom(propertyInfo.PropertyType) && !propertyType.IsEnum)
{
return(new StringFilter(propertyInfo));
}
return(null);
}
internal void Detach(FilterPresenter presenter)
{
if (presenter != null)
{
presenter.Filter -= IsMatch;
if (presenter == filterPresenter)
{
filterPresenter = null;
}
OnDetachPresenter(presenter);
}
}
public CategoryFilterView()
{
InitializeComponent();
// Define Filter that must be use.
EqualFilterInitializer initializer = new EqualFilterInitializer();
// Get FilterPresenter that connected to default collection view for Workspace.This.Products collection.
FilterPresenter productsCollectionViewFilterPresenter = FilterPresenter.TryGet(Workspace.This.Products);
// Get EqualFilter that use Category item property.
EqualFilter filter = ((EqualFilter)(productsCollectionViewFilterPresenter.TryGetFilter("Category", initializer)));
// Use instance of EqualFilter as Model.
Model = filter;
}
#pragma warning restore IDE0051 // Remove unused private members
public override Filter?TryCreateFilter(FilterPresenter filterPresenter, object key)
{
if (key is ItemPropertyInfo info)
{
return(NewFilter(filterPresenter, info));
}
if (key is string str &&
filterPresenter.ItemProperties.FirstOrDefault(item => item.Name == str) is ItemPropertyInfo propertyInfo)
{
return(NewFilter(filterPresenter, propertyInfo));
}
return(null);
}
/// <summary>
/// Determines whether the specified target is a match.
/// </summary>
public override void IsMatch(FilterPresenter sender, FilterEventArgs e)
{
if (IsActive && e.Accepted)
{
if (e.Item != null && getter(e.Item) is T value)
{
e.Accepted = (!_compareFrom.HasValue || value.CompareTo(_compareFrom) >= 0) &&
(!_compareTo.HasValue || value.CompareTo(_compareTo) <= 0);
}
else
{
e.Accepted = false;
}
}
}
/// <summary>
/// Determines whether the specified target is a match.
/// </summary>
public override void IsMatch(FilterPresenter sender, FilterEventArgs e)
{
if (e.Accepted)
{
if (e.Item == null)
{
e.Accepted = false;
}
else
{
var value = getter(e.Item);
e.Accepted = value.CompareTo(_compareTo.Value) >= 0;
}
}
}
protected override PropertyFilter NewFilter(FilterPresenter filterPresenter, ItemPropertyInfo propertyInfo)
{
Debug.Assert(filterPresenter != null);
Debug.Assert(propertyInfo != null);
Type propertyType = propertyInfo.PropertyType;
if (filterPresenter.ItemProperties.Contains(propertyInfo) && !propertyType.IsEnum)
{
PropertyFilter filter = (PropertyFilter)Activator.CreateInstance(typeof(EqualFilter <>).MakeGenericType(propertyInfo.PropertyType), propertyInfo,
GetAvailableValuesQuery(filterPresenter, propertyInfo));
return(filter);
}
return(null);
}
/// <summary>
/// Determines whether the specified target is a match.
/// </summary>
public override void IsMatch(FilterPresenter sender, FilterEventArgs e)
{
if (e.Accepted)
{
if (e.Item == null)
{
e.Accepted = false;
}
else
{
T value = this.getter(e.Item);
e.Accepted = value.CompareTo(this.compareTo) <= 0;
}
}
}
public override void IsMatch(FilterPresenter sender, FilterEventArgs e)
{
if (e.Accepted)
{
if (e.Item == null)
{
e.Accepted = false;
}
else
{
object value = base.getter(e.Item);
e.Accepted = base.SelectedValues.Contains(value);
}
}
}
/// <summary>
/// Generate new instance of BooleanFilter class, if it is possible for a pair of filterPresenter and propertyInfo.
/// </summary>
/// <param name="filterPresenter">FilterPresenter, which can be attached Filter</param>
/// <param name="key">Key, used as the name for binding property in filterPresenter.Parent collection.</param>
/// <returns>Instance of EnumFilter class or null.</returns>
protected override PropertyFilter NewFilter(FilterPresenter filterPresenter, ItemPropertyInfo propertyInfo)
{
Debug.Assert(filterPresenter != null);
Debug.Assert(propertyInfo != null);
Type propertyType = propertyInfo.PropertyType;
if (filterPresenter.ItemProperties.Contains(propertyInfo) &&
typeof(IComparable).IsAssignableFrom(propertyType) &&
propertyType == typeof(bool))
{
return(new BooleanFilter(propertyInfo));
}
return(null);
}
/// <summary>
/// Determines whether the specified target is a match.
/// </summary>
public override void IsMatch(FilterPresenter sender, FilterEventArgs e)
{
if (e.Accepted)
{
if (e.Item == null)
{
e.Accepted = false;
}
else
{
T value = getter(e.Item);
e.Accepted = (Object.ReferenceEquals(_compareFrom, null) | value.CompareTo(_compareFrom) >= 0) &&
(Object.ReferenceEquals(_compareTo, null) | value.CompareTo(_compareTo) <= 0);
}
}
}
