/// <inheritdoc/>
public override AnalysisValueIntermediateResult ResultForQueryRowVariableContext(AnalysisProcessingQueryResultRowExecutionContext rowContext, AnalysisProcessingValueExecutionContext valueExecutionContext)
{
bool complete = true;
var objectResultArray = new List <object>();
int i = 0;
foreach (AnalysisValueFunction func in this.Arguments)
{
AnalysisValueIntermediateResult res = func.ResultForQueryRowVariableContext(rowContext, valueExecutionContext.ChildExecutionContextAtIndex(i++));
if (!res.Complete)
{
complete = false;
}
if (res == null)
{
objectResultArray.Add(new AnalysisValueIntermediateResult(0));
}
else
{
objectResultArray.Add(res);
}
}
if (!complete)
{
return(new AnalysisValueIntermediateResultWithFormula(this, objectResultArray, rowContext, valueExecutionContext));
}
return(this.ObjectResultForArguments(objectResultArray));
}
/// <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));
}
}
/// <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);
}
/// <inheritdoc/>
public override AnalysisValueIntermediateResult ResultForQueryRowVariableContext(AnalysisProcessingQueryResultRowExecutionContext row, AnalysisProcessingValueExecutionContext valueExecutionContext)
{
AnalysisProcessingValueExecutionContext childExecutionContext = valueExecutionContext.ChildExecutionContextAtIndex(0);
AnalysisValueIntermediateResult result = this.ArgumentFunction.ResultForQueryRowVariableContext(row, childExecutionContext);
if (result.Complete)
{
return(this.AnalysisFunction.ResultWithArgumentRowContextValueContext(result.JavascriptResult, row, valueExecutionContext));
}
else
{
return(new AnalysisValueIntermediateResultWithFunction(this, result, row, valueExecutionContext));
}
}
/// <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"));
}
/// <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);
}
/// <summary>
/// Executes computation step
/// </summary>
/// <returns>Boolean value for execute computation step</returns>
public override bool ExecuteComputationStep()
{
this.complete = true;
int i, objectCount = this.objectValues.Count, xObjectCount = this.xObjectValues.Count;
for (i = 0; i < objectCount; i++)
{
AnalysisValueIntermediateResult result = this.objectValues[i] as AnalysisValueIntermediateResult;
if (!result.Complete)
{
result = result.ExecuteStep();
this.objectValues[i] = result;
if (!result.Complete)
{
this.complete = false;
}
}
}
for (i = 0; i < xObjectCount; i++)
{
AnalysisValueIntermediateResult result = this.xObjectValues[i] as AnalysisValueIntermediateResult;
if (!result.Complete)
{
result = result.ExecuteStep();
this.xObjectValues[i] = result;
if (!result.Complete)
{
this.complete = false;
}
}
}
if (this.complete)
{
AnalysisValueOptions valueOptions = this.ProcessingResultColumn.ResultColumn.ValueOptions;
if (objectCount > 0)
{
if (valueOptions.IsStatic && this.objectValues.Count > 1)
{
this.objectValues = new List <object> {
this.objectValues[0]
};
}
if (valueOptions.IsText)
{
foreach (AnalysisValueIntermediateResult result in this.objectValues)
{
this.AddStringValue(result.TextResult);
}
}
else
{
foreach (AnalysisValueIntermediateResult result in this.objectValues)
{
this.AddDoubleValue(result.NumberResult);
}
}
}
if (xObjectCount > 0)
{
if (valueOptions.IsStatic && this.xObjectValues.Count > 1)
{
var resultPerXCategory = new Dictionary <string, object>();
foreach (AnalysisValueIntermediateResult res in this.xObjectValues)
{
if (res.XCategoryKey == null)
{
continue;
}
resultPerXCategory.SetObjectForKey(res, res.XCategoryKey);
}
this.xObjectValues = new List <object>(resultPerXCategory.Values);
}
if (valueOptions.IsText)
{
foreach (AnalysisValueIntermediateResult result in this.xObjectValues)
{
this.AddStringValueXCategoryKey(result.TextResult, result.XCategoryKey);
}
}
else
{
foreach (AnalysisValueIntermediateResult result in this.xObjectValues)
{
this.AddDoubleValueXCategoryKey(result.NumberResult, result.XCategoryKey);
}
}
}
}
return(this.complete);
}
/// <summary>
/// Applies row x category value
/// </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 apply result</returns>
public override bool ApplyRowXCategoryValueArraySumLine(ICrmDataSourceRow dataSourceRow, List <object> xCategoryValueArray, bool sumLine)
{
string significantRowIdentifierForRow = $"{this.YCategoryValue.Key}_{this.SignificantRowIdentifierForRow(dataSourceRow)}";
if (this.significantRows == null)
{
this.significantRows = new Dictionary <string, object> {
{ significantRowIdentifierForRow, 1 }
};
}
else if (this.significantRows.ValueOrDefault(significantRowIdentifierForRow) != null)
{
return(false);
}
else
{
this.significantRows.SetObjectForKey(1, significantRowIdentifierForRow);
}
if (this.ValueFunction.ReturnsNumber)
{
double r = this.ValueFunction.NumberResultForResultRow(dataSourceRow);
this.AddDoubleValue(r);
foreach (AnalysisProcessingXCategoryValue xCategoryValue in xCategoryValueArray)
{
this.AddDoubleValueXCategoryKey(r, xCategoryValue.Key);
}
}
else if (this.ValueFunction.ReturnsObject)
{
AnalysisProcessingQueryResultRowExecutionContext rowExecutionContext = new AnalysisProcessingQueryResultRowExecutionContext(dataSourceRow, this.YCategoryValue, null, this.ProcessingResultColumn.ProcessingContext);
AnalysisValueIntermediateResult objectResult = this.ValueFunction.ResultForQueryRowVariableContext(rowExecutionContext, sumLine ? this.SumExecutionContext : this.ExecutionContext);
if (objectResult != null)
{
if (objectResult.Complete)
{
if (this.ResultColumn.ValueOptions.IsText)
{
this.AddStringValue(objectResult.TextResult);
}
else
{
this.AddDoubleValue(objectResult.NumberResult);
}
}
else
{
if (this.objectValues == null)
{
this.objectValues = new List <object> {
objectResult
};
}
else
{
this.objectValues.Add(objectResult);
}
this.complete = false;
}
}
foreach (AnalysisProcessingXCategoryValue xCategoryValue in xCategoryValueArray)
{
rowExecutionContext = new AnalysisProcessingQueryResultRowExecutionContext(dataSourceRow, this.YCategoryValue, xCategoryValue, this.ProcessingResultColumn.ProcessingContext);
AnalysisValueIntermediateResult xObjectResult = this.ValueFunction.ResultForQueryRowVariableContext(rowExecutionContext, sumLine ? this.SumXExecutionContext : this.XExecutionContext);
if (xObjectResult != null)
{
if (xObjectResult.Complete)
{
if (this.ResultColumn.ValueOptions.IsText)
{
this.AddStringValueXCategoryKey(xObjectResult.TextResult, xCategoryValue.Key);
}
else
{
this.AddDoubleValueXCategoryKey(xObjectResult.NumberResult, xCategoryValue.Key);
}
}
else
{
if (this.xObjectValues == null)
{
this.xObjectValues = new List <object> {
xObjectResult
};
}
else
{
this.xObjectValues.Add(xObjectResult);
}
this.complete = false;
}
return(objectResult.Complete && xObjectResult.Complete);
}
}
return(objectResult.Complete);
}
else if (this.ValueFunction.ReturnsText)
{
string stringValue = this.ValueFunction.TextResultForResultRow(dataSourceRow);
this.AddStringValue(stringValue);
foreach (AnalysisProcessingXCategoryValue xCategoryValue in xCategoryValueArray)
{
this.AddStringValueXCategoryKey(stringValue, xCategoryValue.Key);
}
}
return(true);
}
/// <summary>
/// Result for argument row variable context
/// </summary>
/// <param name="result">Result row</param>
/// <param name="row">Row</param>
/// <param name="valueExecutionContext">Value.AnalysisValueFunction execution context</param>
/// <returns>Returns analysis value intermediate result</returns>
public AnalysisValueIntermediateResult ResultForArgumentRowVariableContext(AnalysisValueIntermediateResult result, AnalysisProcessingQueryResultRowExecutionContext row, AnalysisProcessingValueExecutionContext valueExecutionContext)
{
return(this.AnalysisFunction.ResultWithArgumentRowContextValueContext(result.JavascriptResult, row, valueExecutionContext));
}
