Beispiel #1
0
        /// <inheritdoc/>
        public override List <object> RawValueArrayForRow(ICrmDataSourceRow row)
        {
            string parentValue = this.SourceField.RawValueForRow(row);

            if (parentValue?.Length > 0)
            {
                List <object> values = this.ExplicitCategory.CategoryValueArrayForValue(parentValue);
                if (values.Count == 0)
                {
                    return(null);
                }

                List <object> keyArray = new List <object> {
                    values.Count
                };
                foreach (AnalysisExplicitCategoryValue explicitValue in values)
                {
                    keyArray.Add(explicitValue.Key);
                }

                return(keyArray);
            }

            return(null);
        }
Beispiel #2
0
        private AnalysisProcessingXCategoryValue XCategoryForRow(ICrmDataSourceRow row)
        {
            AnalysisCategoryValue categoryValue = this.Settings.XCategory?.CategoryValueForRow(row);

            if (categoryValue == null)
            {
                return(null);
            }
            else
            {
                var xcategory = this.xCategories.ValueOrDefault(categoryValue.Key);
                if (xcategory == null)
                {
                    xcategory = new AnalysisProcessingXCategoryValue(this, categoryValue);
                    if (this.xCategories == null)
                    {
                        this.xCategories = new Dictionary <string, AnalysisProcessingXCategoryValue> {
                            { xcategory.Key, xcategory }
                        };
                        this.xCategoryArray = new List <AnalysisProcessingXCategoryValue> {
                            xcategory
                        };
                    }
                    else
                    {
                        this.xCategories.SetObjectForKey(xcategory, xcategory.Key);
                        this.xCategoryArray.Add(xcategory);
                    }
                }

                return(xcategory);
            }
        }
Beispiel #3
0
        /// <inheritdoc/>
        public override string StringValueForRow(ICrmDataSourceRow row)
        {
            string rawValue = this.RawValueForRow(row);
            AnalysisExplicitCategoryValue categoryValue = this.ExplicitCategory.CategoryValueForValue(rawValue);

            return(categoryValue.Label);
        }
        /// <summary>
        /// String values for result row
        /// </summary>
        /// <param name="dataSourceRow">Data source row</param>
        /// <returns>List of string values for result row</returns>
        public List <string> StringValuesForResultRow(ICrmDataSourceRow dataSourceRow)
        {
            List <object> sourceFields     = this.Result.DetailsFields;
            int           sourceFieldCount = sourceFields.Count;
            List <string> stringArray      = null;

            if (sourceFieldCount > 0)
            {
                stringArray = new List <string>();
                foreach (object field in sourceFields)
                {
                    if (field == null)
                    {
                        stringArray.Add(string.Empty);
                    }
                    else
                    {
                        AnalysisSourceField sourceField = (AnalysisSourceField)field;
                        stringArray.Add(dataSourceRow.ValueAtIndex(sourceField.QueryResultFieldIndex));
                    }
                }
            }

            return(stringArray);
        }
        /// <summary>
        /// Add row x category
        /// </summary>
        /// <param name="row">Row</param>
        /// <param name="xCategoryValue">X category value</param>
        /// <returns>Returns add row x category</returns>
        public bool AddRowXCategory(ICrmDataSourceRow row, AnalysisProcessingXCategoryValue xCategoryValue)
        {
            bool complete = true;

            foreach (AnalysisProcessingResultColumnValue processingResultColumnValue in this.resultColumns)
            {
                if (!processingResultColumnValue.ApplyRowXCategoryValueSumLine(row, xCategoryValue, this.IsSumLine))
                {
                    complete = false;
                }
            }

            if (this.resultRows == null)
            {
                this.resultRows = new List <object> {
                    row
                };
            }
            else
            {
                this.resultRows.Add(row);
            }

            return(complete);
        }
Beispiel #6
0
 /// <summary>
 /// Initializes a new instance of the <see cref="AnalysisProcessingQueryResultRowExecutionContext"/> class.
 /// </summary>
 /// <param name="dataSource">Data source</param>
 /// <param name="yCategoryValue">Y category value</param>
 /// <param name="xCategoryValue">X category value</param>
 /// <param name="processingContext">Processing context</param>
 public AnalysisProcessingQueryResultRowExecutionContext(ICrmDataSourceRow dataSource, AnalysisProcessingYCategoryValue yCategoryValue, AnalysisProcessingXCategoryValue xCategoryValue, AnalysisProcessing processingContext)
 {
     this.Row               = dataSource;
     this.YCategoryValue    = yCategoryValue;
     this.XCategoryValue    = xCategoryValue;
     this.ProcessingContext = processingContext;
 }
Beispiel #7
0
        /// <inheritdoc/>
        public override AnalysisValueIntermediateResult ObjectResultForResultRow(ICrmDataSourceRow row)
        {
            var objectResultArray = new List <JsValue>();

            foreach (AnalysisValueFunction func in this.Arguments)
            {
                AnalysisValueIntermediateResult res = func.ObjectResultForResultRow(row);
                if (res == null || !res.Complete)
                {
                    objectResultArray.Add(new JsValue(0));
                }
                else
                {
                    objectResultArray.Add(res.JavascriptResult);
                }
            }

            JsValue resultValue = this.JavascriptFunction.Invoke(objectResultArray.ToArray());

            if (resultValue.IsString())
            {
                return(new AnalysisValueIntermediateResult(resultValue.ToString()));
            }
            else if (resultValue.IsNumber())
            {
                return(new AnalysisValueIntermediateResult(resultValue.ToDouble()));
            }
            else
            {
                return(new AnalysisValueIntermediateResult(resultValue));
            }
        }
Beispiel #8
0
        /// <inheritdoc/>
        public override bool ApplyRowXCategoryValueArraySumLine(ICrmDataSourceRow dataSourceRow, List <object> xCategoryValueArray, bool sumLine)
        {
            string rid = $"{this.YCategoryValue.Key}:{dataSourceRow.RecordIdentificationAtIndex(this.queryTableIndex)}";

            if (string.IsNullOrEmpty(rid))
            {
                return(false);
            }

            if (this.OccurrenceCountForKey(rid) == 1)
            {
                ++this.count;
            }

            foreach (AnalysisProcessingXCategoryValue xCategoryValue in xCategoryValueArray)
            {
                if (this.OccurrenceCountForKey($"{xCategoryValue.Key}:{rid}") == 1)
                {
                    AnalysisProcessingTableXResultColumnValue num = this.XResultColumnValueForCategoryValueKey(xCategoryValue.Key);
                    num.Count++;
                }
            }

            return(true);
        }
        /// <inheritdoc/>
        public override List <object> RawValueArrayForRow(ICrmDataSourceRow row)
        {
            string v = this.RawValueForRow(row);

            return(v.Length == 0 ? null : new List <object> {
                v
            });
        }
Beispiel #10
0
        /// <inheritdoc/>
        public override string TextResultForResultRow(ICrmDataSourceRow row)
        {
            if (this.CountField.QueryResultTableIndex >= 0)
            {
                return(row.RecordIdentificationAtIndex(this.CountField.QueryResultTableIndex));
            }

            return(string.Empty);
        }
        /// <summary>
        /// Text result for result row
        /// </summary>
        /// <param name="row">Row</param>
        /// <returns>Text result</returns>
        public virtual string TextResultForResultRow(ICrmDataSourceRow row)
        {
            AnalysisValueIntermediateResult res = this.ObjectResultForResultRow(row);

            if (res != null)
            {
                return(res.TextResult);
            }

            return(string.Empty);
        }
Beispiel #12
0
        /// <inheritdoc/>
        public override string RawValueForRow(ICrmDataSourceRow row)
        {
            string parentValue = this.SourceField.RawValueForRow(row);

            if (parentValue?.Length > 0)
            {
                AnalysisExplicitCategoryValue value = this.ExplicitCategory.CategoryValueForValue(parentValue);
                return(value.Key);
            }

            return(null);
        }
        /// <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
            });
        }
Beispiel #14
0
        /// <summary>
        /// Raw value array for row
        /// </summary>
        /// <param name="row">Row</param>
        /// <returns>Returns raw value array for row</returns>
        public virtual List <object> RawValueArrayForRow(ICrmDataSourceRow row)
        {
            string v = this.RawValueForRow(row);

            if (v.Length == 0)
            {
                return(null);
            }

            return(new List <object> {
                v
            });
        }
Beispiel #15
0
        private bool RowMatchesFilters(ICrmDataSourceRow row)
        {
            if (this.Settings.Conditions != null)
            {
                foreach (AnalysisFilter condition in this.Settings.Conditions)
                {
                    if (!condition.MatchesRow(row))
                    {
                        return(false);
                    }
                }
            }

            return(true);
        }
        /// <inheritdoc/>
        public override AnalysisValueIntermediateResult ObjectResultForResultRow(ICrmDataSourceRow row)
        {
            AnalysisValueIntermediateResult argumentResult = this.ArgumentFunction.ObjectResultForResultRow(row);

            if (argumentResult.Complete)
            {
                AnalysisValueIntermediateResult res = this.AnalysisFunction.ResultWithArgumentRowContextValueContext(argumentResult.JavascriptResult, null, null);
                if (res.Complete)
                {
                    return(res);
                }
            }

            return(new AnalysisValueIntermediateResult("configError: incomplete"));
        }
Beispiel #17
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);
        }
Beispiel #19
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);
        }
        private string SignificantRowIdentifierForRow(ICrmDataSourceRow dataSourceRow)
        {
            string sig     = null;
            var    builder = new System.Text.StringBuilder();

            builder.Append(sig);
            foreach (int?num in this.SignificantQueryResultTableIndices)
            {
                var rid = dataSourceRow.RecordIdentificationAtIndex(num.Value);
                if (sig == null)
                {
                    sig = rid ?? "empty_";
                }
                else
                {
                    builder.Append($"_{rid}");
                }
            }

            sig = builder.ToString();
            return(sig);
        }
Beispiel #22
0
        private AnalysisProcessingYCategoryValue YCategoryForRow(ICrmDataSourceRow row)
        {
            AnalysisCategoryValue categoryValue = this.Settings.Category.CategoryValueForRow(row);

            if (categoryValue == null || categoryValue.Key.Length == 0)
            {
                if (this.Settings.ShowEmpty)
                {
                    categoryValue = this.Settings.Category.EmptyValue();
                }
                else
                {
                    return(null);
                }
            }

            var ycategory = this.yCategories.ValueOrDefault(categoryValue.Key);

            if (ycategory == null)
            {
                ycategory = new AnalysisProcessingYCategoryValue(this, categoryValue);
                if (this.yCategories == null)
                {
                    this.yCategories = new Dictionary <string, AnalysisProcessingYCategoryValue> {
                        { ycategory.Key, ycategory }
                    };
                    this.yCategoryArray = new List <AnalysisProcessingYCategoryValue> {
                        ycategory
                    };
                }
                else
                {
                    this.yCategories.SetObjectForKey(ycategory, ycategory.Key);
                    this.yCategoryArray.Add(ycategory);
                }
            }

            return(ycategory);
        }
Beispiel #23
0
        private List <object> XCategoriesForRow(ICrmDataSourceRow row)
        {
            List <object> categoryValues = this.Settings.XCategory.CategoriesForRow(row);

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

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

            foreach (AnalysisCategoryValue categoryValue in categoryValues)
            {
                var xcategory = this.xCategories.ValueOrDefault(categoryValue.Key);
                if (xcategory == null)
                {
                    xcategory = new AnalysisProcessingXCategoryValue(this, categoryValue);
                    if (this.xCategories == null)
                    {
                        this.xCategories = new Dictionary <string, AnalysisProcessingXCategoryValue> {
                            { xcategory.Key, xcategory }
                        };
                        this.xCategoryArray = new List <AnalysisProcessingXCategoryValue> {
                            xcategory
                        };
                    }
                    else
                    {
                        this.xCategories.SetObjectForKey(xcategory, xcategory.Key);
                        this.xCategoryArray.Add(xcategory);
                    }
                }

                apCategoryValues.Add(xcategory);
            }

            return(apCategoryValues);
        }
        /// <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);
        }
        private void ProcessSearchPage(UPMGridPage searchPage, IReadOnlyList <string> contextMenuOptions, ICrmDataSourceRow crmRow, UPMResultRow listRow, AnalysisResult analysisResult, Page oldPage, int i)
        {
            var dataSource = analysisResult.DataSource;

            for (var j = 0; j < dataSource.NumberOfResultTables; j++)
            {
                var label = contextMenuOptions[j];
                if (string.IsNullOrEmpty(label))
                {
                    continue;
                }

                var recordIdentification = crmRow.RecordIdentificationAtIndex(j);
                if (recordIdentification?.Length > 0)
                {
                    var showRecordAction = new UPMOrganizerAnalysisShowRecordAction(StringIdentifier.IdentifierWithStringId($"action.row {i} record {j}"))
                    {
                        RecordIdentification = recordIdentification
                    };

                    showRecordAction.SetTargetAction(this, this.PerformShowRecordAction);
                    showRecordAction.LabelText = label;
                    listRow.AddDetailAction(showRecordAction);
                }

                var backAction = new UPMOrganizerAnalysisBackAction(StringIdentifier.IdentifierWithStringId("action.back"))
                {
                    AnalysisResult = analysisResult
                };

                backAction.SetTargetAction(this, this.PerformBackToAnalysis);
                backAction.LabelText = LocalizedString.TextAnalysesBackToAnalysis;
                searchPage.AddHeadOption(new UPMGridHeadOption(backAction.LabelText, backAction));
                searchPage.FixedFirstColumn = false;
                searchPage.SumRowAtEnd      = false;
                var hasOnlyEmptyLabels = true;
                foreach (var lbl in contextMenuOptions)
                {
                    if (lbl.Length > 0)
                    {
                        hasOnlyEmptyLabels = false;
                        break;
                    }
                }

                searchPage.ShowMenu  = !hasOnlyEmptyLabels;
                this.TopLevelElement = searchPage;
                this.InformAboutDidChangeTopLevelElement(oldPage, searchPage, null, null);
            }
        }
        /// <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);
        }
 /// <inheritdoc/>
 public override string KeyForRow(ICrmDataSourceRow row)
 {
     return(this.valueFunction == null ? "invalid" : this.valueFunction.TextResultForResultRow(row));
 }
Beispiel #28
0
 /// <summary>
 /// Initializes a new instance of the <see cref="AnalysisRowDetails"/> class.
 /// </summary>
 /// <param name="resultRow">Result row</param>
 /// <param name="dataSourceRow">Data source row</param>
 public AnalysisRowDetails(AnalysisRow resultRow, ICrmDataSourceRow dataSourceRow)
 {
     this.DataSourceRow     = dataSourceRow;
     this.AnalysisResultRow = resultRow;
 }
 /// <summary>
 /// Applies row x category value array
 /// </summary>
 /// <param name="dataSourceRow">Data source row</param>
 /// <param name="xCategoryValue">X Category value array</param>
 /// <param name="sumLine">Sum line</param>
 /// <returns>Boolean value for result</returns>
 public bool ApplyRowXCategoryValueSumLine(ICrmDataSourceRow dataSourceRow, AnalysisProcessingXCategoryValue xCategoryValue, bool sumLine)
 {
     return(this.ApplyRowXCategoryValueArraySumLine(dataSourceRow, xCategoryValue != null ? new List <object> {
         xCategoryValue
     } : null, sumLine));
 }
 /// <summary>
 /// Applies row x category value array
 /// </summary>
 /// <param name="dataSourceRow">Data source row</param>
 /// <param name="xCategoryValueArray">X category value array</param>
 /// <param name="sumLine">Sum line</param>
 /// <returns>Boolean value for result</returns>
 public virtual bool ApplyRowXCategoryValueArraySumLine(ICrmDataSourceRow dataSourceRow, List <object> xCategoryValueArray, bool sumLine)
 {
     return(true);
 }