public FilterScheme(Type targetType, string title, ConditionTreeItem root)
        {
            Argument.IsNotNull(() => targetType);
            Argument.IsNotNull(() => title);
            Argument.IsNotNull(() => root);

            TargetType     = targetType;
            Title          = title;
            ConditionItems = new ObservableCollection <ConditionTreeItem>();
            ConditionItems.Add(root);
        }
        public FilterScheme(Type targetType, string title, ConditionTreeItem root)
        {
            Argument.IsNotNull(() => targetType);
            Argument.IsNotNull(() => title);
            Argument.IsNotNull(() => root);

            SuspendValidation = true;

            TargetType = targetType;
            Title = title;
            ConditionItems = new ObservableCollection<ConditionTreeItem>();
            ConditionItems.Add(root);
        }
        public static Expression <Func <T, bool> > BuildLambda <T>(this ConditionTreeItem conditionTreeItem)
        {
            var type = typeof(T);
            var parameterExpression = Expression.Parameter(type, "item");
            var expression          = conditionTreeItem.BuildExpression(parameterExpression);

            if (expression is null)
            {
                return(null);
            }

            return(Expression.Lambda <Func <T, bool> >(expression, parameterExpression));
        }
        private static Expression BuildExpression(this ConditionTreeItem conditionTreeItem,
                                                  ParameterExpression parameterExpression)
        {
            switch (conditionTreeItem)
            {
            case ConditionGroup conditionGroup:
                return(conditionGroup.BuildExpression(parameterExpression));

            case PropertyExpression propertyExpression:
                return(propertyExpression.BuildExpression(parameterExpression));

            default:
                return(null);
            }
        }
Exemple #5
0
        private bool OnDeleteConditionCanExecute(ConditionTreeItem item)
        {
            if (item is null)
            {
                return(false);
            }

            if (!item.IsRoot())
            {
                return(true);
            }

            if (FilterScheme.ConditionItems.Count > 1)
            {
                return(true);
            }

            return(false);
        }
        private int CountInvalidItems(ConditionTreeItem conditionTreeItem)
        {
            var items = conditionTreeItem == null ? null : conditionTreeItem.Items;

            if (items == null || items.Count == 0)
            {
                return(conditionTreeItem == null ? 0 : conditionTreeItem.IsValid ? 0 : 1);
            }

            int invalidCount = 0;

            foreach (var item in items)
            {
                invalidCount += CountInvalidItems(item);
            }
            invalidCount += conditionTreeItem == null ? 0 : conditionTreeItem.IsValid ? 0 : 1;

            return(invalidCount);
        }
Exemple #7
0
        private void OnDeleteCondition(ConditionTreeItem item)
        {
            if (item.Parent is null)
            {
                FilterScheme.ConditionItems.Remove(item);

                foreach (var conditionItem in FilterScheme.ConditionItems)
                {
                    conditionItem.Items.Remove(item);
                }
            }
            else
            {
                item.Parent.Items.Remove(item);
            }

            _isFilterDirty = true;

            UpdatePreviewItems();
        }
        private int CountInvalidItems(ConditionTreeItem conditionTreeItem)
        {
            var items = conditionTreeItem == null ? null : conditionTreeItem.Items;
            if (items == null || items.Count == 0)
            {
                return conditionTreeItem == null ? 0 : conditionTreeItem.IsValid ? 0 : 1;
            }

            int invalidCount = 0;
            foreach (var item in items)
            {
                invalidCount += CountInvalidItems(item);
            }
            invalidCount += conditionTreeItem == null ? 0 : conditionTreeItem.IsValid ? 0 : 1;

            return invalidCount;
        }
        private void OnDeleteCondition(ConditionTreeItem item)
        {
            if (item.Parent == null)
            {
                FilterScheme.ConditionItems.Remove(item);
                
                foreach (var conditionItem in FilterScheme.ConditionItems)
                {
                    conditionItem.Items.Remove(item);
                }
            }
            else
            {
                item.Parent.Items.Remove(item);
            }

            _isFilterDirty = true;

            UpdatePreviewItems();
        }
        private bool OnDeleteConditionCanExecute(ConditionTreeItem item)
        {
            if (item == null)
            {
                return false;
            }

            if (!item.IsRoot())
            {
                return true;
            }

            if (FilterScheme.ConditionItems.Count > 1)
            {
                return true;
            }

            return false;
        }
 private void OnDeleteCondition(ConditionTreeItem item)
 {
     if (item.Parent == null)
     {
         item.Items.Clear();
     }
     else
     {
         item.Parent.Items.Remove(item);
     }
 }