Example #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="target"></param>
        /// <returns></returns>
        public override EnsureResult Ensure(object target)
        {
            bool undetermined          = false;
            bool opposite              = Opposite;
            ConditionJoinType joinType = JoinType;

            foreach (Condition subCondition in SubConditions)
            {
                EnsureResult subResult = subCondition == null ? EnsureResult.True : subCondition.Ensure(target);
                if (subResult == EnsureResult.False && joinType == ConditionJoinType.And)
                {
                    return(opposite ? EnsureResult.True : EnsureResult.False);
                }
                else if (subResult == EnsureResult.True && joinType == ConditionJoinType.Or)
                {
                    return(opposite ? EnsureResult.True : EnsureResult.False);
                }
                else if (subResult == EnsureResult.Undetermined)
                {
                    undetermined = true;
                }
            }
            if (undetermined)
            {
                return(EnsureResult.Undetermined);
            }
            else if (joinType == ConditionJoinType.Or && SubConditions.Count > 0)
            {
                return(opposite ? EnsureResult.True : EnsureResult.False);
            }
            else
            {
                return(opposite ? EnsureResult.False : EnsureResult.True);
            }
        }
        /// <summary>
        /// Adds a new condition to the list of selection criteria
        /// </summary>
        /// <param name="conditionOperand">The operand to add the condition with</param>
        private void AddCondition(ConditionJoinType joinType)
        {
            Configuration config = Configuration.GetNewInstance();

            string fieldName         = cbxFieldName.SelectedItem.ToString();
            string friendlyOperand   = cbxOperator.SelectedItem.ToString();
            string friendlyValue     = string.Empty;
            string friendlyCondition = string.Empty;

            if (!friendlyOperand.Equals(SharedStrings.FRIENDLY_OPERATOR_BETWEEN))
            {
                friendlyValue = GetValue();

                if (string.IsNullOrEmpty(friendlyValue) && !(friendlyOperand.Equals(SharedStrings.FRIENDLY_OPERATOR_MISSING) || friendlyOperand.Equals(SharedStrings.FRIENDLY_OPERATOR_NOT_MISSING)))
                {
                    Epi.Windows.MsgBox.ShowInformation(SharedStrings.COMPLETE_ALL_SELECTION_FIELDS);
                    return;
                }

                dashboardHelper.AddDataFilterCondition(friendlyOperand, friendlyValue, fieldName, joinType);
            }
            else if (friendlyOperand.Equals(SharedStrings.FRIENDLY_OPERATOR_EQUAL_TO) && cbxFieldName.SelectedIndex > -1 && dashboardHelper.GetColumnType(cbxFieldName.SelectedItem.ToString()).Equals("System.DateTime"))
            {
                string loValue = GetValue();
                string hiValue = GetValue();

                string friendlyLowValue  = loValue.Trim();
                string friendlyHighValue = hiValue.Trim();

                if (string.IsNullOrEmpty(loValue) || string.IsNullOrEmpty(hiValue))
                {
                    Epi.Windows.MsgBox.ShowInformation(SharedStrings.COMPLETE_ALL_SELECTION_FIELDS);
                    return;
                }

                dashboardHelper.AddDataFilterCondition(friendlyOperand, friendlyLowValue, friendlyHighValue, fieldName, joinType);
            }
            else
            {
                friendlyValue = GetValue();
                string[] values = friendlyValue.Split(';');

                string loValue = values[0];
                string hiValue = values[1];

                string friendlyLowValue  = loValue.Trim();
                string friendlyHighValue = hiValue.Trim();

                if (string.IsNullOrEmpty(loValue) || string.IsNullOrEmpty(hiValue))
                {
                    Epi.Windows.MsgBox.ShowInformation(SharedStrings.COMPLETE_ALL_SELECTION_FIELDS);
                    return;
                }

                dashboardHelper.AddDataFilterCondition(friendlyOperand, friendlyLowValue, friendlyHighValue, fieldName, joinType);
            }

            UpdateFilterConditions();
        }
Example #3
0
        /// <summary>
        /// Converts a joinType enumeration to its corresponding string representation
        /// </summary>
        /// <param name="joinType">The enumerable join type</param>
        /// <returns>String representation of the joinType method parameter</returns>
        private string ConvertJoinType(ConditionJoinType joinType)
        {
            switch (joinType)
            {
            case ConditionJoinType.And:
                return("and");

            case ConditionJoinType.Or:
                return("or");

            default:
                return("and");
            }
        }
Example #4
0
        /// <summary>
        /// Adds a new filter condition to the data filter
        /// </summary>
        /// <param name="condition">The condition to add</param>
        /// <returns>Boolean; whether the addition was successful</returns>
        public bool AddFilterCondition(FilterCondition condition, ConditionJoinType joinType)
        {
            #region Input Validation
            if (condition == null || string.IsNullOrEmpty(condition.ColumnName))
            {
                throw new ApplicationException("Invalid filter condition. Cannot add condition to data filter.");
            }
            #endregion // Input Validation

            // check for duplicate conditions
            foreach (DataRow row in ConditionTable.Rows)
            {
                FilterCondition rCondition = (FilterCondition)row[COLUMN_FILTER];

                if (rCondition.FriendlyCondition.Equals(condition.FriendlyCondition))
                {
                    // cannot add a duplicate condition, so return false
                    return(false);
                }
            }

            // find the highest ID value of all the conditions presently in the table
            int maxInt = int.MinValue;

            foreach (DataRow row in ConditionTable.Rows)
            {
                int value = row.Field <int>(COLUMN_ID);
                maxInt = Math.Max(maxInt, value);
            }

            // get the string representation of the joinType enum
            string join = ConvertJoinType(joinType);

            if (this.Count == 0)
            {
                maxInt = 0;
                join   = string.Empty;
            }

            // assume group = 1
            ConditionTable.Rows.Add(maxInt + 1, join, condition, 1);

            // sort by ID
            this.conditionTable = ConditionTable.Select("", COLUMN_ID).CopyToDataTable().DefaultView.ToTable("FilterTable");

            return(true);
        }
Example #5
0
 /// <summary>
 /// 指定连接类型,以子查询条件集合初始化
 /// </summary>
 /// <param name="joinType">连接类型</param>
 /// <param name="subConditions">子查询条件集合</param>
 public ConditionSet(ConditionJoinType joinType, params Condition[] subConditions)
 {
     this.joinType = joinType;
     this.subConditions.AddRange(subConditions);
 }
Example #6
0
 /// <summary>
 /// 指定连接类型,以子查询条件集合初始化
 /// </summary>
 /// <param name="joinType">连接类型</param>
 /// <param name="subConditions">子查询条件集合</param>
 public ConditionSet(ConditionJoinType joinType, IEnumerable <Condition> subConditions)
 {
     this.joinType = joinType;
     this.subConditions.AddRange(subConditions);
 }
Example #7
0
 /// <summary>
 /// 指定连接类型创建查查询条件集合
 /// </summary>
 /// <param name="joinType">连接类型</param>
 public ConditionSet(ConditionJoinType joinType)
 {
     this.joinType = joinType;
 }
        /// <summary>
        /// Adds a new condition to the list of selection criteria
        /// </summary>
        /// <param name="conditionOperand">The operand to add the condition with</param>
        private void AddCondition(ConditionJoinType joinType)
        {
            string fieldName = cmbFieldName.SelectedItem.ToString();
            string friendlyOperand = cmbOperator.SelectedItem.ToString();
            string friendlyValue = string.Empty;
            string friendlyCondition = string.Empty;

            if (!friendlyOperand.Equals(SharedStrings.FRIENDLY_OPERATOR_BETWEEN))
            {
                friendlyValue = GetValue();

                if (string.IsNullOrEmpty(friendlyValue) && !friendlyOperand.Contains("missing"))
                {
                    Epi.Windows.MsgBox.ShowInformation(SharedStrings.COMPLETE_ALL_SELECTION_FIELDS);
                    return;
                }

                AddDataFilterCondition(friendlyOperand, friendlyValue, fieldName, joinType);
            }
            else if (friendlyOperand.Equals(SharedStrings.FRIENDLY_OPERATOR_EQUAL_TO) && cmbFieldName.SelectedIndex > -1 && dashboardHelper.GetColumnType(cmbFieldName.SelectedItem.ToString()).Equals("System.DateTime"))
            {
                string loValue = GetValue();
                string hiValue = GetValue();

                string friendlyLowValue = loValue.Trim();
                string friendlyHighValue = hiValue.Trim();

                if (string.IsNullOrEmpty(loValue) || string.IsNullOrEmpty(hiValue))
                {
                    Epi.Windows.MsgBox.ShowInformation(SharedStrings.COMPLETE_ALL_SELECTION_FIELDS);
                    return;
                }

                AddDataFilterCondition(friendlyOperand, friendlyLowValue, friendlyHighValue, fieldName, joinType);
            }
            else
            {
                friendlyValue = GetValue();
                string[] values = friendlyValue.Split(';');

                string loValue = values[0];
                string hiValue = values[1];

                string friendlyLowValue = loValue.Trim();
                string friendlyHighValue = hiValue.Trim();

                if (string.IsNullOrEmpty(loValue) || string.IsNullOrEmpty(hiValue))
                {
                    Epi.Windows.MsgBox.ShowInformation(SharedStrings.COMPLETE_ALL_SELECTION_FIELDS);
                    return;
                }

                AddDataFilterCondition(friendlyOperand, friendlyLowValue, friendlyHighValue, fieldName, joinType);
            }

            UpdateFilterConditions();
        }
        /// <summary>
        /// Adds a new data filtering condition using the between operator
        /// </summary>
        /// <param name="friendlyCondition">The human-readable condition</param>
        /// <param name="condition">The condition to add</param>
        /// <returns>Whether the addition was successful</returns>
        public bool AddDataFilterCondition(string friendlyOperand, string friendlyLowValue, string friendlyHighValue, string columnName, ConditionJoinType joinType)
        {
            #region Input Validation
            if (string.IsNullOrEmpty(friendlyOperand.Trim()))
            {
                throw new ArgumentNullException("friendlyOperand");
            }
            else if (string.IsNullOrEmpty(columnName.Trim()))
            {
                throw new ArgumentNullException("columnName");
            }
            else if (string.IsNullOrEmpty(friendlyLowValue.Trim()))
            {
                throw new ArgumentNullException("friendlyLowValue");
            }
            else if (string.IsNullOrEmpty(friendlyHighValue.Trim()))
            {
                throw new ArgumentNullException("friendlyHighValue");
            }
            #endregion // Input Validation

            string columnType = dashboardHelper.GetColumnType(columnName);
            string rawColumnName = columnName;

            if (!dashboardHelper.IsUsingEpiProject)
            {
                columnName = Util.InsertInSquareBrackets(columnName);
            }

            if (columnType.Equals("System.DateTime"))
            {
                DateTime lowVal = DateTime.Parse(friendlyLowValue, System.Globalization.CultureInfo.CurrentCulture);
                friendlyLowValue = lowVal.ToString("M/d/yyyy", System.Globalization.CultureInfo.InvariantCulture);

                DateTime highVal = DateTime.Parse(friendlyHighValue, System.Globalization.CultureInfo.CurrentCulture);
                friendlyHighValue = highVal.ToString("M/d/yyyy", System.Globalization.CultureInfo.InvariantCulture);
            }

            bool added = false;
            FilterCondition newCondition = this.DataFilters.GenerateFilterCondition(columnName, rawColumnName, columnType, friendlyOperand, friendlyLowValue, friendlyHighValue);
            this.DataFilters.AddFilterCondition(newCondition, joinType);

            return added;
        }
        /// <summary>
        /// Adds a new data filtering condition
        /// </summary>
        /// <param name="friendlyCondition">The human-readable condition</param>
        /// <param name="friendlyOperand">The human-readable operand</param>
        /// <param name="friendlyValue">The human-readable value</param>
        /// <param name="columnName">The name of the column</param>
        /// <param name="joinType">The type of join to use in including this condition in the list of conditions</param>
        /// <returns>Whether the addition was successful</returns>
        public bool AddDataFilterCondition(string friendlyOperand, string friendlyValue, string columnName, ConditionJoinType joinType)
        {
            #region Input Validation
            if (string.IsNullOrEmpty(friendlyOperand.Trim()))
            {
                throw new ArgumentNullException("friendlyOperand");
            }
            else if (string.IsNullOrEmpty(columnName.Trim()))
            {
                throw new ArgumentNullException("columnName");
            }
            #endregion // Input Validation

            bool added = false;
            string columnType = dashboardHelper.GetColumnType(columnName);
            string rawColumnName = columnName;

            columnName = Util.InsertInSquareBrackets(columnName);

            if (columnType.Equals("System.DateTime") && friendlyOperand.Equals(SharedStrings.FRIENDLY_OPERATOR_EQUAL_TO))
            {
                DateTime lowVal = DateTime.Parse(friendlyValue, System.Globalization.CultureInfo.CurrentCulture);
                string friendlyLowValue = lowVal.ToString("M/d/yyyy", System.Globalization.CultureInfo.InvariantCulture);

                DateTime highVal = DateTime.Parse(friendlyValue, System.Globalization.CultureInfo.CurrentCulture);
                string friendlyHighValue = highVal.ToString("M/d/yyyy", System.Globalization.CultureInfo.InvariantCulture);

                FilterCondition newCondition = this.DataFilters.GenerateFilterCondition(columnName, rawColumnName, columnType, friendlyOperand, friendlyLowValue, friendlyHighValue);
                this.DataFilters.AddFilterCondition(newCondition, joinType);
            }
            else if (columnType.Equals("System.DateTime") && friendlyOperand.Equals(SharedStrings.FRIENDLY_OPERATOR_LESS_THAN_OR_EQUAL))
            {
                DateTime dateVal = DateTime.Parse(friendlyValue, System.Globalization.CultureInfo.CurrentCulture);

                if (dateVal.Hour == 0)
                    dateVal = dateVal.AddHours(23);
                if (dateVal.Minute == 0)
                    dateVal = dateVal.AddMinutes(59);
                if (dateVal.Second == 0)
                    dateVal = dateVal.AddSeconds(59);
                if (dateVal.Millisecond == 0)
                    dateVal = dateVal.AddMilliseconds(999);

                friendlyValue = dateVal.ToString("M/d/yyyy HH:mm:ss", System.Globalization.CultureInfo.InvariantCulture);

                FilterCondition newCondition = this.DataFilters.GenerateFilterCondition(columnName, rawColumnName, columnType, friendlyOperand, friendlyValue);
                this.DataFilters.AddFilterCondition(newCondition, joinType);
            }
            else if (columnType.Equals("System.DateTime") && friendlyOperand.Equals(SharedStrings.FRIENDLY_OPERATOR_GREATER_THAN))
            {
                DateTime dateVal = DateTime.Parse(friendlyValue, System.Globalization.CultureInfo.CurrentCulture);

                if (dateVal.Hour == 0)
                    dateVal = dateVal.AddHours(23);
                if (dateVal.Minute == 0)
                    dateVal = dateVal.AddMinutes(59);
                if (dateVal.Second == 0)
                    dateVal = dateVal.AddSeconds(59);
                if (dateVal.Millisecond == 0)
                    dateVal = dateVal.AddMilliseconds(999);

                friendlyValue = dateVal.ToString("M/d/yyyy HH:mm:ss", System.Globalization.CultureInfo.InvariantCulture);

                FilterCondition newCondition = this.DataFilters.GenerateFilterCondition(columnName, rawColumnName, columnType, friendlyOperand, friendlyValue);
                this.DataFilters.AddFilterCondition(newCondition, joinType);
            }
            else if (columnType.Equals("System.DateTime"))
            {
                if (string.IsNullOrEmpty(friendlyValue))
                {
                    friendlyValue = config.Settings.RepresentationOfMissing;
                }
                else
                {
                    DateTime dateVal = DateTime.Parse(friendlyValue, System.Globalization.CultureInfo.CurrentCulture);
                    friendlyValue = dateVal.ToString("M/d/yyyy", System.Globalization.CultureInfo.InvariantCulture);
                }

                FilterCondition newCondition = this.DataFilters.GenerateFilterCondition(columnName, rawColumnName, columnType, friendlyOperand, friendlyValue);
                this.DataFilters.AddFilterCondition(newCondition, joinType);
            }
            else
            {
                FilterCondition newCondition = this.DataFilters.GenerateFilterCondition(columnName, rawColumnName, columnType, friendlyOperand, friendlyValue);
                this.DataFilters.AddFilterCondition(newCondition, joinType);
            }

            return added;
        }