/// <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); } } }