/// <summary>
        /// Empty value
        /// </summary>
        /// <returns>Returns empty value</returns>
        public AnalysisCategoryValue EmptyValue()
        {
            if (this.emptyValue == null)
            {
                this.emptyValue = new AnalysisCategoryValue(this, string.Empty, LocalizedString.TextAnalysesNoValue);
            }

            return(this.emptyValue);
        }
 /// <summary>
 /// Adds to value dictionary
 /// </summary>
 /// <param name="value">Value</param>
 public void AddToValueDictionary(AnalysisCategoryValue value)
 {
     if (this.valueDictionary == null)
     {
         this.valueDictionary = new Dictionary <string, object>();
         this.valueDictionary.Add(value.Key, value);
     }
     else
     {
         this.valueDictionary.SetObjectForKey(value, value.Key);
     }
 }
        /// <summary>
        /// Categories for row
        /// </summary>
        /// <param name="row">Row</param>
        /// <returns>Returns categories for row</returns>
        public virtual List <object> CategoriesForRow(ICrmDataSourceRow row)
        {
            AnalysisCategoryValue v = this.CategoryValueForRow(row);

            if (v == null || v.IsEmptyValue)
            {
                return(new List <object>());
            }

            return(new List <object> {
                v
            });
        }
Ejemplo n.º 4
0
        /// <inheritdoc/>
        public override List <object> CategoriesForRow(ICrmDataSourceRow row)
        {
            var resultArray         = new List <object>();
            AnalysisCategoryValue v = this.CategoryValueForRow(row);

            if (v != null && !v.IsEmptyValue)
            {
                resultArray.Add(v);
            }

            foreach (var subIndices in this.AnalysisField.SubFieldQueryResultFieldIndices)
            {
                string rawValue = row.RawValueAtIndex(subIndices.ToInt());
                if (rawValue != null)
                {
                    v = this.ValueDictionary.ValueOrDefault(rawValue) as AnalysisCategoryValue;
                    if (v == null)
                    {
                        if (!this.AnalysisField.CrmFieldInfo.IsEmptyValue(rawValue))
                        {
                            v = new AnalysisCategoryValue(this, rawValue, row.ValueAtIndex(subIndices.ToInt()));
                            if (v != null)
                            {
                                this.AddToValueDictionary(v);
                            }
                        }
                    }

                    if (v != null)
                    {
                        resultArray.Add(v);
                    }
                }
            }

            if (resultArray.Count > 0)
            {
                return(resultArray);
            }

            return(new List <object> {
                this.EmptyValue()
            });
        }
        /// <inheritdoc/>
        public override AnalysisCategoryValue CategoryValueForRow(ICrmDataSourceRow row)
        {
            string rawValue = this.valueFunction == null ? "invalid" : this.valueFunction.TextResultForResultRow(row);

            if (!string.IsNullOrEmpty(rawValue))
            {
                AnalysisCategoryValue categoryValue = this.ValueDictionary.ValueOrDefault(rawValue) as AnalysisCategoryValue;
                if (categoryValue == null)
                {
                    categoryValue = new AnalysisCategoryValue(this, rawValue, rawValue);
                    if (categoryValue != null)
                    {
                        this.AddToValueDictionary(categoryValue);
                    }
                }

                return(categoryValue);
            }

            return(null);
        }
Ejemplo n.º 6
0
        /// <inheritdoc/>
        public override AnalysisCategoryValue CategoryValueForRow(ICrmDataSourceRow row)
        {
            string rawValue = this.AnalysisField.RawValueForRow(row);

            if (rawValue != null)
            {
                AnalysisCategoryValue v = this.ValueDictionary.ValueOrDefault(rawValue) as AnalysisCategoryValue;
                if (v == null)
                {
                    v = this.AnalysisField.CrmFieldInfo.IsEmptyValue(rawValue)
                        ? this.EmptyValue()
                        : new AnalysisCategoryValue(this, rawValue, this.AnalysisField.StringValueForRow(row));

                    this.AddToValueDictionary(v);
                }

                return(v);
            }

            return(null);
        }
        /// <inheritdoc/>
        public override AnalysisCategoryValue CategoryValueForRow(ICrmDataSourceRow row)
        {
            string rawValue = this.AnalysisField.RawValueForRow(row);

            if (!string.IsNullOrEmpty(rawValue))
            {
                AnalysisCategoryValue v = this.ValueDictionary.ValueOrDefault(rawValue) as AnalysisCategoryValue;
                if (v == null)
                {
                    AnalysisExplicitCategoryValue explicitCategoryValue = this.AnalysisField.ExplicitCategory.CategoryValueForKey(rawValue);
                    if (explicitCategoryValue != null)
                    {
                        v = new AnalysisCategoryValue(this, explicitCategoryValue);
                        this.AddToValueDictionary(v);
                    }
                }

                return(v);
            }

            return(null);
        }
        /// <inheritdoc/>
        public override List <object> CategoriesForRow(ICrmDataSourceRow row)
        {
            List <object> rawValues = this.AnalysisField?.RawValueArrayForRow(row);

            if (rawValues == null || rawValues.Count == 0)
            {
                return(null);
            }

            List <object> valueArray = new List <object>();

            foreach (string rawValue in rawValues)
            {
                AnalysisCategoryValue v = this.ValueDictionary.ValueOrDefault(rawValue) as AnalysisCategoryValue;
                if (v == null)
                {
                    AnalysisExplicitCategoryValue explicitCategoryValue = this.AnalysisField.ExplicitCategory.CategoryValueForKey(rawValue);
                    if (explicitCategoryValue != null)
                    {
                        v = new AnalysisCategoryValue(this, explicitCategoryValue);
                        this.AddToValueDictionary(v);
                    }
                }

                if (v != null)
                {
                    valueArray.Add(v);
                }
            }

            if (valueArray.Count == 0)
            {
                valueArray = null;
            }

            return(valueArray);
        }
        /// <inheritdoc/>
        public override List <object> CategoriesForRow(ICrmDataSourceRow row)
        {
            List <object> stringValueArray;

            if (this.valueFunction == null)
            {
                stringValueArray = new List <object> {
                    "invalid"
                };
            }
            else
            {
                AnalysisValueIntermediateResult result = this.valueFunction.ObjectResultForResultRow(row);
                if (result.IsTextResult)
                {
                    stringValueArray = new List <object> {
                        result.TextResult
                    };
                }
                else if (result.IsObject)
                {
                    stringValueArray = result.ArrayResult;
                    var arr = new List <object>();
                    foreach (object v in stringValueArray)
                    {
                        if (v is string)
                        {
                            arr.Add((string)v);
                        }
                    }

                    stringValueArray = arr;
                }
                else
                {
                    stringValueArray = new List <object> {
                        result.TextResult
                    };
                }
            }

            List <object> categoryValueArray = null;

            foreach (string rawValue in stringValueArray)
            {
                AnalysisCategoryValue categoryValue = this.ValueDictionary.ValueOrDefault(rawValue) as AnalysisCategoryValue;
                if (categoryValue == null)
                {
                    categoryValue = new AnalysisCategoryValue(this, rawValue, rawValue);
                    if (categoryValue != null)
                    {
                        this.AddToValueDictionary(categoryValue);
                    }
                }

                if (categoryValue != null)
                {
                    if (categoryValueArray == null)
                    {
                        categoryValueArray = new List <object> {
                            categoryValue
                        };
                    }
                    else
                    {
                        categoryValueArray.Add(categoryValue);
                    }
                }
            }

            return(categoryValueArray);
        }