예제 #1
0
        /// <summary>
        /// Converts JSON string to aggregate definition.
        /// </summary>
        /// <param name="jsonString">The json string.</param>
        /// <returns>AggregateDefinition.</returns>
        public static AggregateDefinition FromJson(string jsonString)
        {
            if (string.IsNullOrWhiteSpace(jsonString))
                throw new ArgumentNullException("jsonString");

            var def = new AggregateDefinition();
            JsonConvert.PopulateObject(jsonString, def);

            return def;
        }
예제 #2
0
        /// <summary>
        /// Afters the calculate aggregates.
        /// </summary>
        /// <param name="value">The value.</param>
        /// <param name="criteria">The criteria.</param>
        /// <returns>System.Object.</returns>
        private static object AfterCalculateAggregates(object value, AggregateDefinition criteria)
        {
            if (criteria == null)
                return null;

            if (value != null && value.ToString() == Constants.BlockedResult)
                return value;

            switch (criteria.SummaryType)
            {
                case SummaryTypes.Count:
                case SummaryTypes.CountAll:
                    return value;

                case SummaryTypes.Min:
                case SummaryTypes.MinAll:
                case SummaryTypes.Max:
                case SummaryTypes.MaxAll:
                    if (value == null)
                    {
                        return Constants.Empty;
                    }
                    break;

                case SummaryTypes.Sum:
                case SummaryTypes.SumAll:
                    if (value == null)
                    {
                        return 0;
                    }
                    break;

                case SummaryTypes.Avg:
                case SummaryTypes.AvgAll:
                    value = value == null ? (object)0 : Convert.ToDecimal(value, CultureInfo.InvariantCulture).ToString("F2", CultureInfo.InvariantCulture);
                    break;
            }

            if (AfterBeforeList.Contains(Type.GetType(criteria.TypeName)))
            {
                try
                {
                    var converter = GetConverter(criteria.CustomConverter);
                    if (converter != null)
                        value = converter.Convert(value, Type.GetType(criteria.TargetType), criteria.ConverterParameter, CultureInfo.CurrentCulture);
                }
                catch (Exception)
                {
                }
            }

            return value;
        }
예제 #3
0
        /// <summary>
        /// Updates aggregate criterias in the column item specified.
        /// </summary>
        /// <param name="aggregateDefinition">The aggregate definition.</param>
        /// <param name="columnItem">The column item.</param>
        private static void UpdateCriteriaList(AggregateDefinition aggregateDefinition, IColumnItem columnItem)
        {
            if (columnItem == null)
                return;

            var criteriaList = columnItem.AggregateCriteriaList;

            if (criteriaList.All(x => x.FunctionName != aggregateDefinition.FunctionName))
            {
                criteriaList.Add(aggregateDefinition);
            }
        }
예제 #4
0
        /// <summary>
        /// Befores the calculate aggregates.
        /// </summary>
        /// <param name="value">The value.</param>
        /// <param name="criteria">The criteria.</param>
        /// <returns>System.Object.</returns>
        private static object BeforeCalculateAggregates(object value, AggregateDefinition criteria)
        {
            if (criteria == null)
                return null;

            if (criteria.ColumnName == Constants.DerivedProcessDisplayNameColumnName)
            {
                var derivedProcess = value as string;
                if (!string.IsNullOrEmpty(derivedProcess))
                {
                    var derivedProcessTokens = derivedProcess.Split('|');
                    return derivedProcessTokens.Length > 2 ? derivedProcessTokens[2] : derivedProcessTokens[0];
                }

                return derivedProcess;
            }

            var propertyType = Type.GetType(criteria.TypeName);

            var converter = GetConverter(criteria.CustomConverter);
            if (converter != null)
            {
                if (!AfterBeforeList.Contains(propertyType))
                {
                    if (converter.GetType() == typeof(NumberToPercentConverter))
                    {
                        return value;
                    }

                    value = converter.Convert(value, Type.GetType(criteria.TargetType), criteria.ConverterParameter, CultureInfo.CurrentCulture);
                }
            }

            if (value == null)
                return null;

            var s = value as string;
            if (s != null && string.IsNullOrEmpty(s))
                value = null;

            if (value is bool)
                value = value.ToString();

            return value;
        }
예제 #5
0
        /// <summary>
        /// Updates aggregate function according to aggregation result.
        /// </summary>
        /// <param name="gridColumn">The grid column.</param>
        /// <param name="columnItem">The column item.</param>
        /// <param name="aggregateDefinition">The aggregate definition.</param>
        /// <param name="result">The aggregate result.</param>
        private static void UpdateAggregationResult(GridViewColumn gridColumn, IColumnItem columnItem, AggregateDefinition aggregateDefinition, AggregateResult result)
        {
            if (aggregateDefinition == null || result == null)
                return;

            UpdateFunctions(aggregateDefinition.FunctionName, result, gridColumn);
            UpdateCriteriaList(aggregateDefinition, columnItem);
        }