public void InitTest_CUST_AndPreviouslyApplied()
        {
            NumericFilterVM target = new NumericFilterVM();
            string columnName = "TestColumn1";
            string columnTitle = "Test Column 1";
            NumericFilterSelectionType _filterType = new NumericFilterSelectionType();
            _filterType = NumericFilterSelectionType.CUSTOM;
            FilterColumn _column = new FilterColumn();
            _column.ColumnName = columnName;
            _column.FilterType = FilterSelectionType.NUMERIC_CUST;
            _column.ColumnSelectedDataList = new System.Collections.Generic.List<string>();
            _column.ConditionList = new System.Collections.Generic.List<Condition>();
            Condition cond = new Condition();
            cond.IncludedConditionList = new System.Collections.ObjectModel.ObservableCollection<Condition>();
            cond.LogicalOperatorOfIncludedCondition = LogicOperatorType.AND;

            Condition cond1 = new Condition("TestColumn1", OperatorType.GREATER_THAN_OR_EQUAL);
            Condition cond2 = new Condition("TestColumn1", OperatorType.LESS_THAN_OR_EQUAL);
            cond.IncludedConditionList.Add(cond1);
            cond.IncludedConditionList.Add(cond2);

            _column.ConditionList.Add(cond);
            _column.CurrentRowDataValue = null;

            target.Init(columnName, columnTitle, _filterType, _column);

            Assert.AreEqual(columnName, target.FieldName);
            Assert.AreEqual(columnTitle, target.FieldNameTitle);
            Assert.AreEqual(OperatorType.GREATER_THAN_OR_EQUAL, target.FirstCondition.ConditionOperator);

            Assert.AreEqual(cond1, target.FirstCondition);
            Assert.AreEqual(cond2, target.SecondCondition);
        }
        public void InitTest_EQ()
        {
            NumericFilterVM target = new NumericFilterVM();
            string columnName = "TestColumn1";
            string columnTitle = "Test Column 1";
            NumericFilterSelectionType _filterType = new NumericFilterSelectionType();
            _filterType = NumericFilterSelectionType.EQUAL;
            FilterColumn _column = new FilterColumn();
            _column.ColumnName = columnName;
            _column.ColumnSelectedDataList = new System.Collections.Generic.List<string>();
            _column.ConditionList = new System.Collections.Generic.List<Condition>();
            _column.CurrentRowDataValue = null;

            target.Init(columnName, columnTitle, _filterType, _column);

            Assert.AreEqual(columnName, target.FieldName);
            Assert.AreEqual(columnTitle, target.FieldNameTitle);
            Assert.AreEqual(OperatorType.EQUAL, target.FirstCondition.ConditionOperator);
        }
        public NumericFilterView(string _fieldName, string _fieldTitle, NumericFilterSelectionType _type, FilterColumn _column)
            : this()
        {
            Column = _column;
            if (_type == NumericFilterSelectionType.RANGE)
            {
                this.txtAND.Visibility = System.Windows.Visibility.Visible;
                this.Condition2Operator.Visibility = System.Windows.Visibility.Visible;
                this.Condition2Value.Visibility = System.Windows.Visibility.Visible;
            }
            else if (_type == NumericFilterSelectionType.CUSTOM)
            {
                this.SktPnlLogic.Visibility = System.Windows.Visibility.Visible;
                this.Condition2Operator.Visibility = System.Windows.Visibility.Visible;
                this.Condition2Value.Visibility = System.Windows.Visibility.Visible;
            }

            this.VM.Init(_fieldName, _fieldTitle, _type, _column);
        }
        public void NumericFilterVMConstructorTest()
        {
            string columnName = "TestColumn1";
            NumericFilterSelectionType _filterType = new NumericFilterSelectionType();
            _filterType = NumericFilterSelectionType.EQUAL;
            NumericFilterVM target = new NumericFilterVM(columnName, _filterType);
            Assert.AreNotEqual(columnName, target.FieldName);
            Assert.AreNotEqual(_filterType, target.NumericFilterType);

            Assert.IsTrue(string.IsNullOrEmpty(target.FieldName));
            Assert.AreEqual(NumericFilterSelectionType.CUSTOM, target.NumericFilterType);
        }
        public void InitTest_NE_AndPreviouslyApplied()
        {
            NumericFilterVM target = new NumericFilterVM();
            string columnName = "TestColumn1";
            string columnTitle = "Test Column 1";
            NumericFilterSelectionType _filterType = new NumericFilterSelectionType();
            _filterType = NumericFilterSelectionType.NOT_EQUAL;
            FilterColumn _column = new FilterColumn();
            _column.ColumnName = columnName;
            _column.FilterType = FilterSelectionType.NUMERIC_NE;
            _column.ColumnSelectedDataList = new System.Collections.Generic.List<string>();
            _column.ConditionList = new System.Collections.Generic.List<Condition>();
            Condition cond = new Condition("TestColumn1", OperatorType.NOT_EQUAL);
            _column.ConditionList.Add(cond);

            _column.CurrentRowDataValue = null;

            target.Init(columnName, columnTitle, _filterType, _column);

            Assert.AreEqual(columnName, target.FieldName);
            Assert.AreEqual(columnTitle, target.FieldNameTitle);
            Assert.AreEqual(OperatorType.NOT_EQUAL, target.FirstCondition.ConditionOperator);

            Assert.AreEqual(cond, target.FirstCondition);
        }
Exemple #6
0
 public NumericFilterVM(string columnName, NumericFilterSelectionType _filterType)
     : base()
 {
 }
Exemple #7
0
        public void Init(string columnName, string columnTitle, NumericFilterSelectionType _filterType, FilterColumn _column)
        {
            this.NumericFilterType = _filterType;
            this.FieldName = columnName;
            this.FieldNameTitle = columnTitle;
            bool previouslyExist = false;
            if (_filterType == NumericFilterSelectionType.RANGE)
            {
                if (_column.FilterType == FilterSelectionType.NUMERIC_RNG)
                {
                    previouslyExist = true;
                }
                FirstCondition = new Condition(columnName, OperatorType.GREATER_THAN_OR_EQUAL);
                SecondCondition = new Condition(columnName, OperatorType.LESS_THAN_OR_EQUAL);
            }
            else if (_filterType == NumericFilterSelectionType.EQUAL)
            {
                if (_column.FilterType == FilterSelectionType.NUMERIC_EQ)
                {
                    previouslyExist = true;
                }
                FirstCondition = new Condition(columnName, OperatorType.EQUAL);
            }
            else if (_filterType == NumericFilterSelectionType.NOT_EQUAL)
            {
                if (_column.FilterType == FilterSelectionType.NUMERIC_NE)
                {
                    previouslyExist = true;
                }
                FirstCondition = new Condition(columnName, OperatorType.NOT_EQUAL);
            }
            else if (_filterType == NumericFilterSelectionType.GREATER_THAN)
            {
                if (_column.FilterType == FilterSelectionType.NUMERIC_GT)
                {
                    previouslyExist = true;
                }
                FirstCondition = new Condition(columnName, OperatorType.GREATER_THAN);
            }
            else if (_filterType == NumericFilterSelectionType.GREATER_THAN_OR_EQUALTO)
            {
                if (_column.FilterType == FilterSelectionType.NUMERIC_GE)
                {
                    previouslyExist = true;
                }
                FirstCondition = new Condition(columnName, OperatorType.GREATER_THAN_OR_EQUAL);
            }
            else if (_filterType == NumericFilterSelectionType.LESS_THAN)
            {
                if (_column.FilterType == FilterSelectionType.NUMERIC_LT)
                {
                    previouslyExist = true;
                }
                FirstCondition = new Condition(columnName, OperatorType.LESS_THAN);
            }
            else if (_filterType == NumericFilterSelectionType.LESS_THAN_OR_EQUALTO)
            {
                if (_column.FilterType == FilterSelectionType.NUMERIC_LE)
                {
                    previouslyExist = true;
                }
                FirstCondition = new Condition(columnName, OperatorType.LESS_THAN_OR_EQUAL);
            }
            else if (_filterType == NumericFilterSelectionType.CUSTOM)
            {
                if (_column.FilterType == FilterSelectionType.NUMERIC_CUST)
                {
                    previouslyExist = true;
                }
                FirstCondition = new Condition(columnName, OperatorType.GREATER_THAN_OR_EQUAL);
                SecondCondition = new Condition(columnName, OperatorType.GREATER_THAN_OR_EQUAL);
            }

            if (previouslyExist && _column.ConditionList != null && _column.ConditionList.Count > 0)
            {
                if (_filterType == NumericFilterSelectionType.RANGE || _filterType == NumericFilterSelectionType.CUSTOM)
                {
                    if (_column.ConditionList[0].IsLogicalOperatorOfIncludedConditionSpecified == true &&
                            _column.ConditionList[0].IncludedConditionList != null
                            && _column.ConditionList[0].IncludedConditionList.Count > 1)
                        FirstCondition = _column.ConditionList[0].IncludedConditionList[0];
                    SecondCondition = _column.ConditionList[0].IncludedConditionList[1];
                }
                else
                {
                    FirstCondition = _column.ConditionList[0];
                }
            }

            if (FirstCondition != null)
            {
                FirstCondition.FieldToMatchValueType = ValueDataType.NUMERIC;
            }

            if (SecondCondition != null)
            {
                SecondCondition.FieldToMatchValueType = ValueDataType.NUMERIC;
            }
        }
        private void ShowNumericView(NumericFilterSelectionType _type)
        {
            FilterColumn column = this.autofilterDataGrid.GetFilterColumnByName(this.selectedColumn);
            if (column == null)
            {
                column = new FilterColumn();
                column.ColumnName = this.selectedColumn;
            }

            NumericFilterView view = new NumericFilterView(this.selectedColumn, columnTitle, _type, column);
            bool? status = view.ShowDialog();
            if (status != null && status == true)
            {
                this.autofilterDataGrid.FilterDataGrid(column);
                this.Close();
            }
        }