public RecordsetGroup(IBinaryDataListEntry sourceEntry, IList<IDev2Definition> definitions, Func<IDev2Definition, string> inputExpressionExtractor, Func<IDev2Definition, string> outputExpressionExtractor)
{
if(sourceEntry == null)
{
throw new ArgumentNullException("sourceEntry");
}
if(definitions == null)
{
throw new ArgumentNullException("definitions");
}
if(inputExpressionExtractor == null)
{
throw new ArgumentNullException("inputExpressionExtractor");
}
if(outputExpressionExtractor == null)
{
throw new ArgumentNullException("outputExpressionExtractor");
}
SourceEntry = sourceEntry;
Definitions = definitions;
InputExpressionExtractor = inputExpressionExtractor;
OutputExpressionExtractor = outputExpressionExtractor;
}
public List <IDebugItem> GetDebugInputs(IBinaryDataList dataList, IDataListCompiler compiler, IDev2LanguageParser parser)
{
IList <IDev2Definition> inputs = parser.Parse(InputMapping);
var results = new List <IDebugItem>();
foreach (IDev2Definition dev2Definition in inputs)
{
ErrorResultTO errors;
IBinaryDataListEntry tmpEntry = compiler.Evaluate(dataList.UID, enActionType.User, dev2Definition.RawValue, false, out errors);
DebugItem itemToAdd = new DebugItem();
AddDebugItem(new DebugItemVariableParams(dev2Definition.RawValue, "", tmpEntry, dataList.UID), itemToAdd);
if (errors.HasErrors())
{
itemToAdd.FlushStringBuilder();
throw new DebugCopyException(errors.MakeDisplayReady(), itemToAdd);
}
results.Add(itemToAdd);
}
foreach (IDebugItem debugInput in results)
{
debugInput.FlushStringBuilder();
}
return(results);
}
private void AddDebugInputItem(string expression, string labelText, IBinaryDataListEntry valueEntry, Guid executionId)
{
DebugItem itemToAdd = new DebugItem();
if (labelText == "Where")
{
AddDebugItem(new DebugItemStaticDataParams(SearchType, "Where"), itemToAdd);
AddDebugItem(new DebugItemVariableParams(expression, labelText, valueEntry, executionId), itemToAdd);
_debugInputs.Add(itemToAdd);
return;
}
if (!string.IsNullOrWhiteSpace(labelText))
{
itemToAdd.Add(new DebugItemResult {
Type = DebugItemResultType.Label, Value = labelText
});
}
if (valueEntry != null)
{
AddDebugItem(new DebugItemVariableParams(expression, labelText, valueEntry, executionId), itemToAdd);
}
_debugInputs.Add(itemToAdd);
}
void GetValues(IBinaryDataListEntry dlEntry, string value, int iterCnt, IIndexIterator idxItr, enRecordsetIndexType indexType, IList <IDebugItemResult> results, string initExpression, string labelText, string fieldName = null)
{
string error;
int index = idxItr.FetchNextIndex();
if (string.IsNullOrEmpty(fieldName))
{
IList <IBinaryDataListItem> record = dlEntry.FetchRecordAt(index, out error);
// ReSharper disable LoopCanBeConvertedToQuery
foreach (IBinaryDataListItem recordField in record)
// ReSharper restore LoopCanBeConvertedToQuery
{
GetValue(dlEntry, value, iterCnt, fieldName, indexType, results, initExpression, recordField, index, false, labelText);
}
}
else
{
IBinaryDataListItem recordField = dlEntry.TryFetchRecordsetColumnAtIndex(fieldName, index, out error);
bool ignoreCompare = false;
if (recordField == null)
{
if (dlEntry.Columns.Count == 1)
{
recordField = dlEntry.TryFetchIndexedRecordsetUpsertPayload(index, out error);
ignoreCompare = true;
}
}
GetValue(dlEntry, value, iterCnt, fieldName, indexType, results, initExpression, recordField, index, ignoreCompare, labelText);
}
}
public override List <DebugItem> GetDebugOutputs(IBinaryDataList dataList)
{
IDev2LanguageParser parser = DataListFactory.CreateOutputParser();
IList <IDev2Definition> inputs = parser.Parse(OutputMapping);
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
var results = new List <DebugItem>();
foreach (IDev2Definition dev2Definition in inputs)
{
ErrorResultTO errors;
IBinaryDataListEntry tmpEntry = compiler.Evaluate(dataList.UID, enActionType.User, dev2Definition.RawValue, false, out errors);
if (tmpEntry != null)
{
DebugItem itemToAdd = new DebugItem();
AddDebugItem(new DebugItemVariableParams(dev2Definition.RawValue, "", tmpEntry, dataList.UID), itemToAdd);
results.Add(itemToAdd);
}
else
{
if (errors.HasErrors())
{
throw new Exception(errors.MakeDisplayReady());
}
}
}
foreach (IDebugItem debugOutput in results)
{
debugOutput.FlushStringBuilder();
}
return(results);
}
public static ActivityUpsertTO CreateEntriesFromOutputTOs(IList <OutputTO> outputToList, IDataListCompiler compiler, Guid dlId, out ErrorResultTO errors)
{
errors = new ErrorResultTO();
ActivityUpsertTO result = new ActivityUpsertTO();
foreach (OutputTO outputTo in outputToList)
{
// I first need to detect if the entry is a recordset!!!!!!!!!!!
// Then if scalar upsert scalar else upsert a recordset-- how was this to ever work?!?!
// Break into parts so we can correctly create the required entry......
IBinaryDataListEntry entry = Dev2BinaryDataListFactory.CreateEntry(RecsetName, string.Empty, dlId);
int idx = 1;
foreach (string output in outputTo.OutputStrings)
{
IBinaryDataListItem itemToAdd = Dev2BinaryDataListFactory.CreateBinaryItem(output, RecsetName, FieldName, idx);
idx++;
string error;
entry.TryAppendRecordItem(itemToAdd, out error);
if (error != string.Empty)
{
errors.AddError(error);
}
}
// push entry one time, no looping ;)
result.AddEntry(entry, outputTo.OutPutDescription);
}
return(result);
}
/// <summary>
/// Fetches the index of the recordset.
/// </summary>
/// <param name="part">The part.</param>
/// <param name="entry">The entry.</param>
/// <param name="isFramed"></param>
/// <returns></returns>
public int FetchRecordsetIndex(IIntellisenseResult part, IBinaryDataListEntry entry, bool isFramed)
{
// figure out the index type ;)
enRecordsetIndexType idxType = DataListUtil.GetRecordsetIndexTypeRaw(part.Option.RecordsetIndex);
int result = 1;
if (idxType == enRecordsetIndexType.Numeric)
{
// fix index insert ;)
if (!Int32.TryParse(part.Option.RecordsetIndex, out result))
{
result = -1;
}
}
else if (idxType == enRecordsetIndexType.Blank)
{
// append mode
if (!_recordsetAppendIndexs.TryGetValue(part.Option.Recordset, out result))
{
if (entry != null)
{
result = entry.FetchAppendRecordsetIndex();
_recordsetAppendIndexs[part.Option.Recordset] = result; // stash in cache
}
}
// Assign behavior ;)
if (!isFramed)
{
// duplicate match ;)
if (nonFramedTokens.Contains(part))
{
// reset the framing ;)
nonFramedTokens.Clear();
nonFramedTokens.Add(part);
// inc this index ;)
_recordsetAppendIndexs[part.Option.Recordset]++;
result++;
}
else
{
// current append indexes are alright ;)
nonFramedTokens.Add(part);
}
}
}
else if (idxType == enRecordsetIndexType.Star)
{
// overwrite mode from idx 1
if (!_recordsetOverwriteIndexs.TryGetValue(part.Option.Recordset, out result))
{
result = 1;
_recordsetOverwriteIndexs[part.Option.Recordset] = result;
}
}
return(result);
}
/// <summary>
/// Fetches the index of the recordset.
/// </summary>
/// <param name="part">The part.</param>
/// <param name="entry">The entry.</param>
/// <param name="isFramed"></param>
/// <returns></returns>
public int FetchRecordsetIndex(IIntellisenseResult part, IBinaryDataListEntry entry, bool isFramed)
{
// figure out the index type ;)
enRecordsetIndexType idxType = DataListUtil.GetRecordsetIndexTypeRaw(part.Option.RecordsetIndex);
int result = 1;
if(idxType == enRecordsetIndexType.Numeric)
{
// fix index insert ;)
if(!Int32.TryParse(part.Option.RecordsetIndex, out result))
{
result = -1;
}
}
else if(idxType == enRecordsetIndexType.Blank)
{
// append mode
if(!_recordsetAppendIndexs.TryGetValue(part.Option.Recordset, out result))
{
if(entry != null)
{
result = entry.FetchAppendRecordsetIndex();
_recordsetAppendIndexs[part.Option.Recordset] = result; // stash in cache
}
}
// Assign behavior ;)
if(!isFramed)
{
// duplicate match ;)
if(nonFramedTokens.Contains(part))
{
// reset the framing ;)
nonFramedTokens.Clear();
nonFramedTokens.Add(part);
// inc this index ;)
_recordsetAppendIndexs[part.Option.Recordset]++;
result++;
}
else
{
// current append indexes are alright ;)
nonFramedTokens.Add(part);
}
}
}
else if(idxType == enRecordsetIndexType.Star)
{
// overwrite mode from idx 1
if(!_recordsetOverwriteIndexs.TryGetValue(part.Option.Recordset, out result))
{
result = 1;
_recordsetOverwriteIndexs[part.Option.Recordset] = result;
}
}
return result;
}
public void Merge(IBinaryDataListEntry toMerge, out string error)
{
error = string.Empty;
if (IsRecordset && toMerge.IsRecordset)
{
IIndexIterator ii = toMerge.FetchRecordsetIndexes();
while (ii.HasMore())
{
int next = ii.FetchNextIndex();
// merge toMerge into this
foreach (IBinaryDataListItem item in toMerge.FetchRecordAt(next, out error))
{
TryAppendRecordItem(item, out error);
}
}
}
else if (!IsRecordset && !toMerge.IsRecordset)
{
TryPutScalar(toMerge.FetchScalar(), out error); // over write this with toMerge
}
else
{
error = "Type mis-match, one side is Recordset while the other is a scalar";
}
}
public List <DebugItem> GetDebugInputs(IList <IDev2Definition> inputs, IBinaryDataList dataList, ErrorResultTO errors)
{
if (errors == null)
{
throw new ArgumentNullException("errors");
}
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
var results = new List <DebugItem>();
foreach (IDev2Definition dev2Definition in inputs)
{
IBinaryDataListEntry tmpEntry = compiler.Evaluate(dataList.UID, enActionType.User, GetVariableName(dev2Definition), false, out errors);
var val = tmpEntry.FetchScalar();
val.TheValue += "";
DebugItem itemToAdd = new DebugItem();
AddDebugItem(new DebugItemVariableParams(GetVariableName(dev2Definition), "", tmpEntry, dataList.UID), itemToAdd);
results.Add(itemToAdd);
}
foreach (IDebugItem debugInput in results)
{
debugInput.FlushStringBuilder();
}
return(results);
}
public RecordsetGroup(IBinaryDataListEntry sourceEntry, IList <IDev2Definition> definitions, Func <IDev2Definition, string> inputExpressionExtractor, Func <IDev2Definition, string> outputExpressionExtractor)
{
if (sourceEntry == null)
{
throw new ArgumentNullException("sourceEntry");
}
if (definitions == null)
{
throw new ArgumentNullException("definitions");
}
if (inputExpressionExtractor == null)
{
throw new ArgumentNullException("inputExpressionExtractor");
}
if (outputExpressionExtractor == null)
{
throw new ArgumentNullException("outputExpressionExtractor");
}
SourceEntry = sourceEntry;
Definitions = definitions;
InputExpressionExtractor = inputExpressionExtractor;
OutputExpressionExtractor = outputExpressionExtractor;
}
public List <DebugItem> GetDebugValues(IList <IDev2Definition> values, IBinaryDataList dataList, out ErrorResultTO errors)
{
errors = new ErrorResultTO();
IDataListCompiler compiler = _getDataListCompiler();
var results = new List <DebugItem>();
var added = new List <string>();
foreach (IDev2Definition dev2Definition in values)
{
IBinaryDataListEntry tmpEntry = compiler.Evaluate(dataList.UID, enActionType.User, GetVariableName(dev2Definition), false, out errors);
GetValue(tmpEntry, dev2Definition);
var defn = GetVariableName(dev2Definition);
if (added.Any(a => a == defn))
{
continue;
}
added.Add(defn);
DebugItem itemToAdd = new DebugItem();
_add(new DebugItemVariableParams(GetVariableName(dev2Definition), "", tmpEntry, dataList.UID), itemToAdd);
results.Add(itemToAdd);
}
foreach (IDebugItem debugInput in results)
{
debugInput.FlushStringBuilder();
}
return(results);
}
/// <summary>
/// Fetches the switch data.
/// </summary>
/// <param name="variableName">Name of the variable.</param>
/// <param name="oldAmbientData">The old ambient data.</param>
/// <returns></returns>
public string FetchSwitchData(string variableName, IList <string> oldAmbientData)
{
ErrorResultTO errors;
Guid dlId = FetchDataListID(oldAmbientData);
IBinaryDataListEntry tmp = EvaluateForSwitch(variableName, dlId, out errors);
if (errors.HasErrors())
{
Compiler.UpsertSystemTag(dlId, enSystemTag.Dev2Error, errors.MakeDataListReady(), out errors);
}
if (tmp != null)
{
if (tmp.IsRecordset)
{
string error;
return(tmp.TryFetchLastIndexedRecordsetUpsertPayload(out error).TheValue);
}
var scalar = tmp.FetchScalar();
return(scalar.TheValue);
}
return(string.Empty);
}
public DebugItemVariableParams(string expression, string labelText, IBinaryDataListEntry valueEntry, Guid executionId, bool groupedItem = false)
{
_expression = expression;
_labelText = labelText;
_valueEntry = valueEntry;
_executionId = executionId;
_groupedItem = groupedItem;
}
private void AddDebugOutputItemFromEntry(string expression, IBinaryDataListEntry value, int indexCount, Guid dlId)
{
DebugItem itemToAdd = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", indexCount.ToString(CultureInfo.InvariantCulture)), itemToAdd);
AddDebugItem(new DebugItemVariableParams(expression, "", value, dlId), itemToAdd);
_debugOutputs.Add(itemToAdd);
}
internal Dev2DataListEvaluateIterator(IBinaryDataListEntry entry)
{
_entry = entry;
if (_entry.IsRecordset)
{
_idxItr = entry.FetchRecordsetIndexes();
}
}
public DebugItemVariableParams(string expression, string labelText, IBinaryDataListEntry valueEntry, Guid executionId, bool groupedItem = false)
{
_expression = expression;
_labelText = labelText;
_valueEntry = valueEntry;
_executionId = executionId;
_groupedItem = groupedItem;
}
public void Can_Sub_Recordset_With_Index_Expect()
{
var dataListCompiler = DataListFactory.CreateDataListCompiler();
ErrorResultTO errors;
IBinaryDataListEntry binaryDataListEntry = dataListCompiler.Evaluate(_dl2.UID, enActionType.User, "[[recset(1).f1]]", false, out errors);
Assert.AreEqual("r1.f1.value", binaryDataListEntry.FetchScalar().TheValue);
}
internal Dev2DataListEvaluateIterator(IBinaryDataListEntry entry)
{
_entry = entry;
if (_entry.IsRecordset)
{
_idxItr = entry.FetchRecordsetIndexes();
}
}
public static IBinaryDataListEntry CreateScalarEntry(string valueForScalar, Guid dlId, out string error)
{
IBinaryDataListEntry entry = Dev2BinaryDataListFactory.CreateEntry(GlobalConstants.NullEntryNamespace, string.Empty, dlId);
IBinaryDataListItem item = Dev2BinaryDataListFactory.CreateBinaryItem(valueForScalar, string.Empty);
entry.TryPutScalar(item, out error);
return(entry);
}
public EvaluateRuleSet(EvaluateRuleSet prevIter)
{
Errors = new ErrorResultTO();
Errors.MergeErrors(prevIter.Errors);
_result = prevIter._result;
_ns = prevIter._ns;
IsDebug = prevIter.IsDebug;
EvaluateToRootOnly = prevIter.EvaluateToRootOnly;
}
public static DebugOutputBase EvaluateEmptyRecordsetBeforeAddingToDebugOutput(string expression, string labelText, Guid executionID, IBinaryDataListEntry expressionsEntry)
{
if(DataListUtil.IsValueRecordset(expression))
{
return new DebugItemVariableParams(expression, labelText, expressionsEntry, executionID);
}
return new DebugItemVariableParams(expression, labelText, expressionsEntry, executionID);
}
/// <summary>
/// A new version of GetValue since Evaluate will now handle complex expressions it is now possible to create gnarly looking debug items
/// This method handles these ;)
/// </summary>
/// <param name="dlEntry">The dl entry.</param>
/// <param name="indexType">Type of the index.</param>
/// <param name="results">The results.</param>
/// <param name="initExpression">The init expression.</param>
/// <param name="recordField">The record field.</param>
/// <param name="index">The index.</param>
/// <param name="labelText"></param>
void NewGetValue(IBinaryDataListEntry dlEntry, enRecordsetIndexType indexType, IList <IDebugItemResult> results, string initExpression, IBinaryDataListItem recordField, int index, string labelText)
{
string injectVal = string.Empty;
ComplexExpressionAuditor auditorObj = dlEntry.ComplexExpressionAuditor;
if (indexType == enRecordsetIndexType.Star && auditorObj != null)
{
string instanceData;
IList <ComplexExpressionAuditItem> auditData = auditorObj.FetchAuditItems();
if (index <= auditData.Count && index > 0)
{
ComplexExpressionAuditItem useData = auditData[index - 1];
instanceData = useData.TokenBinding;
injectVal = useData.BoundValue;
}
else
{
string recsetName = DataListUtil.CreateRecordsetDisplayValue(dlEntry.Namespace,
recordField.FieldName,
index.ToString(CultureInfo.InvariantCulture));
instanceData = DataListUtil.AddBracketsToValueIfNotExist(recsetName);
}
results.Add(new DebugItemResult
{
Label = labelText,
Type = DebugItemResultType.Variable,
Value = injectVal,
Operator = string.IsNullOrEmpty(instanceData) ? "" : "=",
Variable = instanceData,
GroupName = initExpression,
GroupIndex = index
});
}
else
{
injectVal = recordField.TheValue;
string displayValue = recordField.DisplayValue;
if (displayValue.IndexOf(GlobalConstants.NullEntryNamespace, StringComparison.Ordinal) >= 0)
{
displayValue = DataListUtil.CreateRecordsetDisplayValue("Evaluated", GlobalConstants.EvaluationRsField, index.ToString(CultureInfo.InvariantCulture));
}
results.Add(new DebugItemResult
{
Type = DebugItemResultType.Variable,
Variable = DataListUtil.AddBracketsToValueIfNotExist(displayValue),
Operator = string.IsNullOrEmpty(displayValue) ? "" : "=",
GroupName = initExpression,
Value = injectVal,
GroupIndex = index
});
}
}
void AddDebugInputItem(string inputColumn, string outputColumnName, IBinaryDataListEntry expressionsEntry, string outputColumnDataType, Guid executionId, int indexCounter)
{
var itemToAdd = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", indexCounter.ToString(CultureInfo.InvariantCulture)), itemToAdd);
AddDebugItem(new DebugItemVariableParams(inputColumn, "", expressionsEntry, executionId), itemToAdd);
AddDebugItem(new DebugItemStaticDataParams(outputColumnName, "To Field"), itemToAdd);
AddDebugItem(new DebugItemStaticDataParams(outputColumnDataType, "Type"), itemToAdd);
_debugInputs.Add(itemToAdd);
}
protected override void AddItemsToIterator(Guid executionId, IDataListCompiler compiler, List <ErrorResultTO> errors)
{
ErrorResultTO error;
IBinaryDataListEntry archPassEntry = compiler.Evaluate(executionId, enActionType.User, ArchivePassword, false,
out error);
errors.Add(error);
_archPassItr = Dev2ValueObjectFactory.CreateEvaluateIterator(archPassEntry);
ColItr.AddIterator(_archPassItr);
}
private void AddDebugInputItem(string expression, IBinaryDataListEntry valueEntry, Guid executionId, string fromType, string toType)
{
var itemToAdd = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", _indexCounter.ToString(CultureInfo.InvariantCulture)), itemToAdd);
AddDebugItem(new DebugItemVariableParams(expression, "Convert", valueEntry, executionId), itemToAdd);
AddDebugItem(new DebugItemStaticDataParams(fromType, "From"), itemToAdd);
AddDebugItem(new DebugItemStaticDataParams(toType, "To"), itemToAdd);
_debugInputs.Add(itemToAdd);
}
/// <summary>
/// Processes the record set.
/// </summary>
/// <param name="entry">The entry.</param>
/// <param name="error">The error.</param>
/// <returns></returns>
private string ProcessRecordSet(IBinaryDataListEntry entry, out string error)
{
StringBuilder result = new StringBuilder();
error = string.Empty;
// MAKE RS START ;)
result.Append("\"");
result.Append(entry.Namespace);
result.Append("\" : [");
IIndexIterator idxItr = entry.FetchRecordsetIndexes();
int rsCnt = 0;
while (idxItr.HasMore() && !entry.IsEmpty())
{
int idx = idxItr.FetchNextIndex();
IList <IBinaryDataListItem> rowData = entry.FetchRecordAt(idx, out error);
result.Append("{");
int colIdx = 0;
foreach (IBinaryDataListItem col in rowData)
{
result.Append("\"");
result.Append(col.FieldName);
result.Append("\":\"");
result.Append(col.TheValue);
result.Append("\"");
// add , if need be ;)
colIdx++;
if (colIdx < rowData.Count)
{
result.Append(",");
}
}
result.Append("}");
// append , for row data ;)
rsCnt++;
if (rsCnt < idxItr.Count)
{
result.Append(", ");
}
}
// END RS ;)
result.Append("]");
return(result.ToString());
}
/// <summary>
/// Adds the bound item.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="binding">The binding.</param>
public void AddBoundItem(IIntellisenseResult token, IBinaryDataListEntry binding)
{
if (binding == null)
{
Errors.AddError("Could not evaluate { " + token.Option.DisplayValue + " }");
return;
}
_internalKeyMap[token] = binding;
}
void GetValue(IBinaryDataListEntry dlEntry, string value, int iterCnt, string fieldName, enRecordsetIndexType indexType, IList <IDebugItemResult> results, string initExpression, IBinaryDataListItem recordField, int index, bool ignoreCompare, string labelText)
{
if (!ignoreCompare)
{
OldGetValue(dlEntry, value, iterCnt, fieldName, indexType, results, initExpression, recordField, index, labelText);
}
else
{
NewGetValue(dlEntry, indexType, results, initExpression, recordField, index, labelText);
}
}
private static void GetValue(IBinaryDataListEntry tmpEntry, IDev2Definition defn)
{
if (String.IsNullOrEmpty(defn.RecordSetName))
{
tmpEntry.FetchScalar(); // ask trav what this side effect means
}
else
{
string error;
tmpEntry.MakeRecordsetEvaluateReady(GlobalConstants.AllIndexes, GlobalConstants.AllColumns, out error);
}
}
public void AddEntry(IBinaryDataListEntry val, string expression, int pos) {
if (pos >= _expressions.Count)
{
_entriesB.Insert(pos, val);
_expressions.Insert(pos, expression);
}
else
{
_entriesB[pos] = val;
_expressions[pos] = expression;
}
}
public ForEachBootstrapTOOld(enForEachExecutionType typeOf, int maxExe, IBinaryDataListEntry data)
{
ExeType = typeOf;
MaxExecutions = maxExe;
if (data != null)
{
DataIterator = Dev2ValueObjectFactory.CreateEvaluateIterator(data);
}
else
{
DataIterator = null;
}
}
public void AddEntry(IBinaryDataListEntry val, string expression, int pos)
{
if (pos >= _expressions.Count)
{
_entriesB.Insert(pos, val);
_expressions.Insert(pos, expression);
}
else
{
_entriesB[pos] = val;
_expressions[pos] = expression;
}
}
IDev2DataListEvaluateIterator CreateDataListEvaluateIterator(string expression, Guid executionId, IDataListCompiler compiler, IDev2IteratorCollection iteratorCollection, ErrorResultTO allErrors)
{
ErrorResultTO errors;
IBinaryDataListEntry expressionEntry = compiler.Evaluate(executionId, enActionType.User, expression, false, out errors);
allErrors.MergeErrors(errors);
IDev2DataListEvaluateIterator expressionIterator = Dev2ValueObjectFactory.CreateEvaluateIterator(expressionEntry);
iteratorCollection.AddIterator(expressionIterator);
return(expressionIterator);
}
public ForEachBootstrapTOOld(enForEachExecutionType typeOf, int maxExe, IBinaryDataListEntry data)
{
ExeType = typeOf;
MaxExecutions = maxExe;
if(data != null)
{
DataIterator = Dev2ValueObjectFactory.CreateEvaluateIterator(data);
}
else
{
DataIterator = null;
}
}
private void AddDebugInputItem(string expression, string labelText, IBinaryDataListEntry valueEntry, Guid executionId)
{
if (valueEntry != null)
{
//Added for Bug 9479 - Massimo Guerrera
if (expression.Contains("()."))
{
expression = expression.Replace("().", "(*).");
}
}
AddDebugInputItem(new DebugItemVariableParams(expression, labelText, valueEntry, executionId));
AddDebugInputItem(new DebugItemStaticDataParams(SelectedSort, "Sort Order"));
}
void OldGetValue(IBinaryDataListEntry dlEntry, string value, int iterCnt, string fieldName, enRecordsetIndexType indexType, IList <IDebugItemResult> results, string initExpression, IBinaryDataListItem recordField, int index, string labelText)
{
if ((string.IsNullOrEmpty(fieldName) || recordField.FieldName.Equals(fieldName, StringComparison.InvariantCultureIgnoreCase)))
{
string injectVal;
try
{
injectVal = recordField.TheValue;
}
catch (Exception)
{
injectVal = "";
}
if (!string.IsNullOrEmpty(value) && recordField.ItemCollectionIndex == (iterCnt + 1))
{
injectVal = value;
_rsCachedValues[recordField.DisplayValue] = injectVal;
}
else if (string.IsNullOrEmpty(injectVal) && recordField.ItemCollectionIndex != (iterCnt + 1))
{
// is it in the cache? ;)
_rsCachedValues.TryGetValue(recordField.DisplayValue, out injectVal);
if (injectVal == null)
{
injectVal = string.Empty;
}
}
string recsetName;
if (indexType == enRecordsetIndexType.Star)
{
recsetName = DataListUtil.CreateRecordsetDisplayValue(dlEntry.Namespace,
recordField.FieldName,
index.ToString(CultureInfo.InvariantCulture));
recsetName = DataListUtil.AddBracketsToValueIfNotExist(recsetName);
}
else
{
recsetName = DataListUtil.AddBracketsToValueIfNotExist(recordField.DisplayValue);
}
results.Add(new DebugItemResult
{
Label = labelText,
Type = DebugItemResultType.Variable,
Variable = recsetName,
Operator = string.IsNullOrEmpty(recsetName) ? "" : "=",
Value = injectVal,
GroupName = initExpression,
GroupIndex = index
});
}
}
internal static void DoRecordSetAppending(ErrorResultTO errors, IBinaryDataListEntry entry, StringBuilder result)
{
var cnt = entry.FetchLastRecordsetIndex();
var cols = entry.Columns;
if(!cols.Any(c => c.ColumnIODirection == enDev2ColumnArgumentDirection.Both || c.ColumnIODirection == enDev2ColumnArgumentDirection.Input))
{
return;
}
for(var i = 1; i <= cnt; i++)
{
string error;
var rowData = entry.FetchRecordAt(i, out error);
errors.AddError(error);
result.Append("<");
result.Append(entry.Namespace);
result.Append(">");
foreach(var col in rowData)
{
var fName = col.FieldName;
if(cols.Any(c => c.ColumnName == fName &&
(c.ColumnIODirection == enDev2ColumnArgumentDirection.Both || c.ColumnIODirection == enDev2ColumnArgumentDirection.Input)))
{
result.Append("<");
result.Append(fName);
result.Append(">");
try
{
result.Append(col.TheValue);
}
// ReSharper disable EmptyGeneralCatchClause
catch (Exception)
{
}
result.Append("</");
result.Append(fName);
result.Append(">");
}
}
result.Append("</");
result.Append(entry.Namespace);
result.Append(">");
}
}
public List<IDebugItemResult> CreateDebugItemsFromEntry(string expression, IBinaryDataListEntry dlEntry, Guid dlId, enDev2ArgumentType argumentType, string labelText, int indexToUse = -1)
{
var results = new List<IDebugItemResult>();
IDataListCompiler compiler = DataListFactory.CreateDataListCompiler();
IBinaryDataList dataList = compiler.FetchBinaryDataList(dlId, out ErrorsTo);
if(
!(expression.Contains(GlobalConstants.CalculateTextConvertPrefix) &&
expression.Contains(GlobalConstants.CalculateTextConvertSuffix)))
{
if(!expression.ContainsSafe("[["))
{
results.Add(new DebugItemResult
{
Label = labelText,
Type = DebugItemResultType.Value,
Value = expression
});
return results;
}
}
else
{
expression =
expression.Replace(GlobalConstants.CalculateTextConvertPrefix, string.Empty)
.Replace(GlobalConstants.CalculateTextConvertSuffix, string.Empty);
}
if(dlEntry != null && dlEntry.ComplexExpressionAuditor == null)
{
int groupIndex = 0;
enRecordsetIndexType rsType = DataListUtil.GetRecordsetIndexType(expression);
if(dlEntry.IsRecordset &&
(DataListUtil.IsValueRecordset(expression) &&
(rsType == enRecordsetIndexType.Star ||
(rsType == enRecordsetIndexType.Numeric &&
DataListUtil.ExtractFieldNameFromValue(expression) == string.Empty) ||
(rsType == enRecordsetIndexType.Blank &&
DataListUtil.ExtractFieldNameFromValue(expression) == string.Empty))))
{
// Added IsEmpty check for Bug 9263 ;)
if(!dlEntry.IsEmpty())
{
IList<IDebugItemResult> collection = CreateRecordsetDebugItems(expression, dlEntry, string.Empty,
-1, labelText);
if(collection.Count < 2 && collection.Count > 0)
{
collection[0].GroupName = "";
}
results.AddRange(collection);
}
else
{
results.Add(new DebugItemResult
{
Type = DebugItemResultType.Variable,
Label = labelText,
Variable = expression,
Operator = string.IsNullOrEmpty(expression) ? "" : "=",
Value = "",
});
}
}
else
{
if(DataListUtil.IsValueRecordset(expression) &&
(DataListUtil.GetRecordsetIndexType(expression) == enRecordsetIndexType.Blank))
{
if(indexToUse == -1)
{
IBinaryDataListEntry tmpEntry;
string error;
dataList.TryGetEntry(DataListUtil.ExtractRecordsetNameFromValue(expression),
out tmpEntry, out error);
if(tmpEntry != null)
{
int index = tmpEntry.FetchAppendRecordsetIndex() - 1;
if(index > 0)
{
groupIndex = index;
expression = expression.Replace("().", string.Concat("(", index, ")."));
}
}
}
else
{
expression = expression.Replace("().", string.Concat("(", indexToUse, ")."));
}
}
if(dlEntry.IsRecordset)
{
var strIndx = DataListUtil.ExtractIndexRegionFromRecordset(expression);
int indx;
if(int.TryParse(strIndx, out indx))
{
if(indx > 0)
{
IBinaryDataListItem item = dlEntry.FetchScalar();
try
{
CreateScalarDebugItems(expression, item.TheValue, labelText, results, "", groupIndex);
}
catch(NullValueInVariableException)
{
CreateScalarDebugItems(expression, "", labelText, results, "", groupIndex);
}
}
else
{
CreateScalarDebugItems(expression, "", labelText, results, "", groupIndex);
}
}
else
{
IBinaryDataListItem itemx = dlEntry.FetchScalar();
if(!string.IsNullOrEmpty(strIndx))
{
IBinaryDataListEntry indexBinaryEntry;
IBinaryDataListItem indexItem = null;
string error;
if(DataListUtil.IsValueRecordset(strIndx))
{
dataList.TryGetEntry(DataListUtil.ExtractRecordsetNameFromValue(strIndx),
out indexBinaryEntry, out error);
var fieldName = DataListUtil.ExtractFieldNameFromValue(strIndx);
int index;
if(int.TryParse(DataListUtil.ExtractIndexRegionFromRecordset(strIndx), out index))
{
indexItem = indexBinaryEntry.TryFetchRecordsetColumnAtIndex(fieldName, index, out error);
}
}
else
{
dataList.TryGetEntry(strIndx, out indexBinaryEntry, out error);
indexItem = indexBinaryEntry.FetchScalar();
}
if(indexItem != null)
{
expression = expression.Replace(string.Format("({0})", strIndx), string.Format("({0})", indexItem.TheValue));
}
}
try
{
CreateScalarDebugItems(expression, itemx.TheValue, labelText, results, "", groupIndex);
}
// ReSharper disable EmptyGeneralCatchClause
catch(Exception)
// ReSharper restore EmptyGeneralCatchClause
{
}
}
}
else
{
IBinaryDataListItem item = dlEntry.FetchScalar();
try
{
CreateScalarDebugItems(expression, item.TheValue, labelText, results, "", groupIndex);
}
catch(Exception)
{
CreateScalarDebugItems(expression, null, labelText, results, "", groupIndex);
}
}
}
}
else
{
// Complex expressions are handled differently ;)
if(dlEntry != null)
{
ComplexExpressionAuditor auditor = dlEntry.ComplexExpressionAuditor;
int idx = 1;
foreach(ComplexExpressionAuditItem item in auditor.FetchAuditItems())
{
int grpIdx = idx;
string groupName = item.RawExpression;
string displayExpression = item.RawExpression;
if(displayExpression.Contains("()."))
{
displayExpression = displayExpression.Replace("().",
string.Concat("(", auditor.GetMaxIndex(), ")."));
}
if(displayExpression.Contains("(*)."))
{
displayExpression = displayExpression.Replace("(*).", string.Concat("(", idx, ")."));
}
results.Add(new DebugItemResult
{
Type = DebugItemResultType.Variable,
Label = labelText,
Variable = displayExpression,
Operator = string.IsNullOrEmpty(displayExpression) ? "" : "=",
GroupName = groupName,
Value = item.BoundValue,
GroupIndex = grpIdx
});
idx++;
}
}
}
return results;
}
static void AddEntryToBuilder(StringBuilder result, IBinaryDataListEntry entry)
{
result.Append("<");
result.Append(entry.Namespace);
result.Append(" " + Description + "=\"");
result.Append(entry.Description);
result.Append("\" ");
result.Append(IsEditable + "=\"");
result.Append(entry.IsEditable);
result.Append("\" ");
// Travis.Frisinger - Added Column direction
result.Append(GlobalConstants.DataListIoColDirection + "=\"");
result.Append(entry.ColumnIODirection);
result.Append("\" ");
}
IList<IDebugItemResult> CreateRecordsetDebugItems(string expression, IBinaryDataListEntry dlEntry, string value, int iterCnt, string labelText)
{
var results = new List<IDebugItemResult>();
if(dlEntry.ComplexExpressionAuditor == null)
{
string initExpression = expression;
string fieldName = DataListUtil.ExtractFieldNameFromValue(expression);
enRecordsetIndexType indexType = DataListUtil.GetRecordsetIndexType(expression);
if(indexType == enRecordsetIndexType.Blank && string.IsNullOrEmpty(fieldName))
{
indexType = enRecordsetIndexType.Star;
}
if(indexType == enRecordsetIndexType.Star || indexType == enRecordsetIndexType.Numeric)
{
IIndexIterator idxItr = dlEntry.FetchRecordsetIndexes();
while(idxItr.HasMore())
{
GetValues(dlEntry, value, iterCnt, idxItr, indexType, results, initExpression, labelText, fieldName);
}
}
}
else
{
// Complex expressions are handled differently ;)
ComplexExpressionAuditor auditor = dlEntry.ComplexExpressionAuditor;
enRecordsetIndexType indexType = DataListUtil.GetRecordsetIndexType(expression);
foreach(ComplexExpressionAuditItem item in auditor.FetchAuditItems())
{
int grpIdx = -1;
try
{
grpIdx = Int32.Parse(DataListUtil.ExtractIndexRegionFromRecordset(item.TokenBinding));
}
// ReSharper disable EmptyGeneralCatchClause
catch(Exception)
// ReSharper restore EmptyGeneralCatchClause
{
// Best effort ;)
}
if(indexType == enRecordsetIndexType.Star)
{
string displayExpression = item.Expression.Replace(item.Token, item.RawExpression);
results.Add(new DebugItemResult { Type = DebugItemResultType.Variable, Value = displayExpression, GroupName = displayExpression, GroupIndex = grpIdx });
results.Add(new DebugItemResult { Type = DebugItemResultType.Label, Value = GlobalConstants.EqualsExpression, GroupName = displayExpression, GroupIndex = grpIdx });
results.Add(new DebugItemResult { Type = DebugItemResultType.Value, Value = item.BoundValue, GroupName = displayExpression, GroupIndex = grpIdx });
}
}
}
return results;
}
void GetValues(IBinaryDataListEntry dlEntry, string value, int iterCnt, IIndexIterator idxItr, enRecordsetIndexType indexType, IList<IDebugItemResult> results, string initExpression, string labelText, string fieldName = null)
{
string error;
int index = idxItr.FetchNextIndex();
if(string.IsNullOrEmpty(fieldName))
{
IList<IBinaryDataListItem> record = dlEntry.FetchRecordAt(index, out error);
// ReSharper disable LoopCanBeConvertedToQuery
foreach(IBinaryDataListItem recordField in record)
// ReSharper restore LoopCanBeConvertedToQuery
{
GetValue(dlEntry, value, iterCnt, fieldName, indexType, results, initExpression, recordField, index, false, labelText);
}
}
else
{
IBinaryDataListItem recordField = dlEntry.TryFetchRecordsetColumnAtIndex(fieldName, index, out error);
bool ignoreCompare = false;
if(recordField == null)
{
if(dlEntry.Columns.Count == 1)
{
recordField = dlEntry.TryFetchIndexedRecordsetUpsertPayload(index, out error);
ignoreCompare = true;
}
}
GetValue(dlEntry, value, iterCnt, fieldName, indexType, results, initExpression, recordField, index, ignoreCompare, labelText);
}
}
public void AddEntry(IBinaryDataListEntry val, string expression) {
_entriesB.Add(val);
_expressions.Add(expression);
}
static void GetValue(IBinaryDataListEntry entry, DebugTO debugTo, string labelText, List<string> regions, List<IDebugItemResult> results)
{
ComplexExpressionAuditor auditor = entry.ComplexExpressionAuditor;
if(auditor != null)
{
int grpIdx = 0;
IList<ComplexExpressionAuditItem> complexExpressionAuditItems = auditor.FetchAuditItems();
foreach(ComplexExpressionAuditItem item in complexExpressionAuditItems)
{
string groupName = null;
string displayExpression = item.Expression;
string rawExpression = item.RawExpression;
if(regions != null && regions.Count > 0)
{
//
}
if(displayExpression.Contains("().") || displayExpression.Contains("(*)."))
{
grpIdx++;
groupName = displayExpression;
displayExpression = rawExpression;
}
else
{
if(regions != null && regions.Count > 0)
{
string indexRegionFromRecordset = DataListUtil.ExtractIndexRegionFromRecordset(displayExpression);
int indexForRecset;
int.TryParse(indexRegionFromRecordset, out indexForRecset);
if(indexForRecset > 0)
{
int indexOfOpenningBracket = displayExpression.IndexOf("(", StringComparison.Ordinal) + 1;
string group = displayExpression.Substring(0, indexOfOpenningBracket) + "*" + displayExpression.Substring(indexOfOpenningBracket + indexRegionFromRecordset.Length);
if(regions.Contains(@group))
{
grpIdx++;
groupName = @group;
}
}
}
}
int count = complexExpressionAuditItems.Count(i => i.Expression.Equals(item.Expression));
if(count < 2)
{
groupName = "";
}
var debugOperator = "";
var debugType = DebugItemResultType.Value;
if(DataListUtil.IsEvaluated(displayExpression))
{
debugOperator = "=";
debugType = DebugItemResultType.Variable;
}
else
{
displayExpression = null;
}
results.Add(new DebugItemResult
{
Type = debugType,
Label = labelText,
Variable = displayExpression,
Operator = debugOperator,
GroupName = groupName,
Value = item.BoundValue,
GroupIndex = grpIdx
});
}
}
else
{
//Could not evaluate
results.Add(new DebugItemResult
{
Type = DebugItemResultType.Value,
Label = labelText,
Variable = debugTo.Expression,
Operator = "=",
GroupName = "",
Value = ""
});
}
}
public bool TryGetEntry(string theNameSpace, out IBinaryDataListEntry entry, out string error)
{
error = string.Empty;
theNameSpace = DataListUtil.StripBracketsFromValue(theNameSpace);
bool result = _templateDict.TryGetValue(theNameSpace, out entry);
var isSystemTag = DataListUtil.IsSystemTag(theNameSpace) || theNameSpace=="Datalist";
if(!result && !isSystemTag)
{
error = theNameSpace + " could not be found in the DataList";
}
return result;
}
/// <summary>
/// Depths the merge.
/// </summary>
/// <param name="depth">The depth.</param>
/// <param name="cloned">The cloned.</param>
/// <param name="key"></param>
/// <param name="errors">The errors.</param>
private void DepthMerge(enTranslationDepth depth, IBinaryDataListEntry cloned, string key, out IList<string> errors)
{
errors = new List<string>();
if(key != null)
{
if(depth == enTranslationDepth.Data || depth == enTranslationDepth.Data_With_Blank_OverWrite)
{
// safe to add
if(cloned.IsRecordset)
{
// Inject into the intellisense options...
CreateIntelliseneResult(key, cloned.Columns);
//Massimo.Guerrera - 21-01-2013 - Added for the DeleteRecordOperation, it need to over write the data with blank values.
if(depth == enTranslationDepth.Data_With_Blank_OverWrite)
{
_templateDict[key] = cloned;
}
else
{
// merge all the cloned rows into this reference
#pragma warning disable 219
// ReSharper disable NotAccessedVariable
int insertIdx = 1; // always default to start of recordset
// ReSharper restore NotAccessedVariable
#pragma warning restore 219
// fetch last row id and build from there
IBinaryDataListEntry tmpRec;
bool isFound = _templateDict.TryGetValue(key, out tmpRec);
// verify that the key exist first ;)
IIndexIterator ii = cloned.FetchRecordsetIndexes();
while(ii.HasMore())
{
int next = ii.FetchNextIndex();
string error;
IList<IBinaryDataListItem> cols = cloned.FetchRecordAt(next, out error);
if(error != string.Empty)
{
errors.Add(error);
}
if(!isFound)
{
// we need to boot strap the recordset ;)
// intellisense takecare of with template method ;)
TryCreateRecordsetTemplate(cloned.Namespace, cloned.Description, cloned.Columns, true, out error);
if(error != string.Empty)
{
errors.Add(error);
}
isFound = true;
}
foreach(IBinaryDataListItem itm in cols)
{
_templateDict[key].TryPutRecordItemAtIndex(itm, next, out error);
if(error != string.Empty)
{
errors.Add(error);
}
}
insertIdx++;
}
}
}
else
{
IBinaryDataListEntry thisTmp;
// we have an entry, better check clone for empty
if(_templateDict.TryGetValue(key, out thisTmp))
{
string theValue = null;
try
{
theValue = cloned.FetchScalar().TheValue;
}
catch(Exception e)
{
Dev2Logger.Log.Error(e);
}
if(theValue != string.Empty && depth == enTranslationDepth.Data)
{
// The clone has data, over write it on the merge ;)
_templateDict[key] = cloned;
// Inject into the intellisense options...
CreateIntelliseneResult(key);
}
else if(depth == enTranslationDepth.Data_With_Blank_OverWrite)
{
// The user wants to over-write Blank data on the right with existing data on the left ;)
_templateDict[key] = cloned;
// Inject into the intellisense options...
CreateIntelliseneResult(key);
}
}
else
{
// no entry, just place it there as there is no harm ;)
_templateDict[key] = cloned;
// Inject into the intellisense options...
CreateIntelliseneResult(key);
}
}
}
else if(depth == enTranslationDepth.Shape)
{
_templateDict[key] = cloned; // set blank data ;)
// Inject into the intellisense options...
CreateIntelliseneResult(key);
}
}
}
/// <summary>
/// Creates the evaluate iterator.
/// </summary>
/// <param name="entry">The entry.</param>
/// <returns></returns>
public static IDev2DataListEvaluateIterator CreateEvaluateIterator(IBinaryDataListEntry entry)
{
return new Dev2DataListEvaluateIterator(entry ?? DataListConstants.baseEntry);
}
IList<IDataListItem> ConvertIBinaryDataListEntryToIDataListItem(IBinaryDataListEntry dataListEntry)
{
IList<IDataListItem> result = new List<IDataListItem>();
if(dataListEntry.IsRecordset)
{
var sizeOfCollection = dataListEntry.ItemCollectionSize();
if(sizeOfCollection == 0) { sizeOfCollection++; }
var count = 0;
var fields = dataListEntry.Columns.Where(c => c.ColumnIODirection == enDev2ColumnArgumentDirection.Both || c.ColumnIODirection == enDev2ColumnArgumentDirection.Input).ToList();
while(count < sizeOfCollection)
{
string error;
var items = dataListEntry.FetchRecordAt(count + 1, out error);
foreach(var item in items)
{
// check field mapping ;)
if(fields.Any(f => f.ColumnName == item.FieldName))
{
IDataListItem singleRes = new DataListItem();
singleRes.IsRecordset = true;
singleRes.Recordset = item.Namespace;
singleRes.Field = item.FieldName;
singleRes.RecordsetIndex = (count + 1).ToString(CultureInfo.InvariantCulture);
try
{
singleRes.Value = item.TheValue;
}
catch(Exception)
{
singleRes.Value = null;
}
singleRes.DisplayValue = item.DisplayValue;
var desc = dataListEntry.Columns.FirstOrDefault(c => c.ColumnName == item.FieldName);
singleRes.Description = desc == null ? null : desc.ColumnDescription;
result.Add(singleRes);
}
}
count++;
}
}
else
{
var item = dataListEntry.FetchScalar();
if(item != null)
{
IDataListItem singleRes = new DataListItem();
singleRes.IsRecordset = false;
singleRes.Field = item.FieldName;
singleRes.DisplayValue = item.FieldName;
try
{
singleRes.Value = item.TheValue;
}
catch(Exception)
{
singleRes.Value = null;
}
var desc = dataListEntry.Description;
singleRes.Description = string.IsNullOrWhiteSpace(desc) ? null : desc;
result.Add(singleRes);
}
}
return result;
}
public void AddRemovedRegion(IBinaryDataListEntry region) {
RemovedRegions.Add(region);
}
public List<IDebugItemResult> CreateDebugItemsFromEntry(string expression, IBinaryDataListEntry dlEntry, Guid dlId, enDev2ArgumentType argumentType, int indexToUse = -1)
{
return CreateDebugItemsFromEntry(expression, dlEntry, dlId, argumentType, "", indexToUse);
}
void OldGetValue(IBinaryDataListEntry dlEntry, string value, int iterCnt, string fieldName, enRecordsetIndexType indexType, IList<IDebugItemResult> results, string initExpression, IBinaryDataListItem recordField, int index, string labelText)
{
if((string.IsNullOrEmpty(fieldName) || recordField.FieldName.Equals(fieldName, StringComparison.InvariantCultureIgnoreCase)))
{
string injectVal;
try
{
injectVal = recordField.TheValue;
}
catch(Exception)
{
injectVal = "";
}
if(!string.IsNullOrEmpty(value) && recordField.ItemCollectionIndex == (iterCnt + 1))
{
injectVal = value;
_rsCachedValues[recordField.DisplayValue] = injectVal;
}
else if(string.IsNullOrEmpty(injectVal) && recordField.ItemCollectionIndex != (iterCnt + 1))
{
// is it in the cache? ;)
_rsCachedValues.TryGetValue(recordField.DisplayValue, out injectVal);
if(injectVal == null)
{
injectVal = string.Empty;
}
}
string recsetName;
if(indexType == enRecordsetIndexType.Star)
{
recsetName = DataListUtil.CreateRecordsetDisplayValue(dlEntry.Namespace,
recordField.FieldName,
index.ToString(CultureInfo.InvariantCulture));
recsetName = DataListUtil.AddBracketsToValueIfNotExist(recsetName);
}
else
{
recsetName = DataListUtil.AddBracketsToValueIfNotExist(recordField.DisplayValue);
}
results.Add(new DebugItemResult
{
Label = labelText,
Type = DebugItemResultType.Variable,
Variable = recsetName,
Operator = string.IsNullOrEmpty(recsetName) ? "" : "=",
Value = injectVal,
GroupName = initExpression,
GroupIndex = index
});
}
}
/// <summary>
/// A new version of GetValue since Evaluate will now handle complex expressions it is now possible to create gnarly looking debug items
/// This method handles these ;)
/// </summary>
/// <param name="dlEntry">The dl entry.</param>
/// <param name="indexType">Type of the index.</param>
/// <param name="results">The results.</param>
/// <param name="initExpression">The init expression.</param>
/// <param name="recordField">The record field.</param>
/// <param name="index">The index.</param>
/// <param name="labelText"></param>
void NewGetValue(IBinaryDataListEntry dlEntry, enRecordsetIndexType indexType, IList<IDebugItemResult> results, string initExpression, IBinaryDataListItem recordField, int index, string labelText)
{
string injectVal = string.Empty;
ComplexExpressionAuditor auditorObj = dlEntry.ComplexExpressionAuditor;
if(indexType == enRecordsetIndexType.Star && auditorObj != null)
{
string instanceData;
IList<ComplexExpressionAuditItem> auditData = auditorObj.FetchAuditItems();
if(index <= auditData.Count && index > 0)
{
ComplexExpressionAuditItem useData = auditData[index - 1];
instanceData = useData.TokenBinding;
injectVal = useData.BoundValue;
}
else
{
string recsetName = DataListUtil.CreateRecordsetDisplayValue(dlEntry.Namespace,
recordField.FieldName,
index.ToString(CultureInfo.InvariantCulture));
instanceData = DataListUtil.AddBracketsToValueIfNotExist(recsetName);
}
results.Add(new DebugItemResult
{
Label = labelText,
Type = DebugItemResultType.Variable,
Value = injectVal,
Operator = string.IsNullOrEmpty(instanceData) ? "" : "=",
Variable = instanceData,
GroupName = initExpression,
GroupIndex = index
});
}
else
{
injectVal = recordField.TheValue;
string displayValue = recordField.DisplayValue;
if(displayValue.IndexOf(GlobalConstants.NullEntryNamespace, StringComparison.Ordinal) >= 0)
{
displayValue = DataListUtil.CreateRecordsetDisplayValue("Evaluated", GlobalConstants.EvaluationRsField, index.ToString(CultureInfo.InvariantCulture));
}
results.Add(new DebugItemResult
{
Type = DebugItemResultType.Variable,
Variable = DataListUtil.AddBracketsToValueIfNotExist(displayValue),
Operator = string.IsNullOrEmpty(displayValue) ? "" : "=",
GroupName = initExpression,
Value = injectVal,
GroupIndex = index
});
}
}
public DebugTO(IBinaryDataListEntry targetEntry, IBinaryDataListEntry leftEntry, string expression)
{
TargetEntry = targetEntry;
LeftEntry = leftEntry;
Expression = expression;
}
void GetValue(IBinaryDataListEntry dlEntry, string value, int iterCnt, string fieldName, enRecordsetIndexType indexType, IList<IDebugItemResult> results, string initExpression, IBinaryDataListItem recordField, int index, bool ignoreCompare, string labelText)
{
if(!ignoreCompare)
{
OldGetValue(dlEntry, value, iterCnt, fieldName, indexType, results, initExpression, recordField, index, labelText);
}
else
{
NewGetValue(dlEntry, indexType, results, initExpression, recordField, index, labelText);
}
}
/// <summary>
/// Adds the bound item.
/// </summary>
/// <param name="token">The token.</param>
/// <param name="binding">The binding.</param>
public void AddBoundItem(IIntellisenseResult token, IBinaryDataListEntry binding)
{
if(binding == null)
{
Errors.AddError("Could not evaluate { " + token.Option.DisplayValue + " }");
return;
}
_internalKeyMap[token] = binding;
}
/// <summary>
/// Processes the record set.
/// </summary>
/// <param name="entry">The entry.</param>
/// <param name="error">The error.</param>
/// <returns></returns>
private string ProcessRecordSet(IBinaryDataListEntry entry, out string error)
{
StringBuilder result = new StringBuilder();
error = string.Empty;
// MAKE RS START ;)
result.Append("\"");
result.Append(entry.Namespace);
result.Append("\" : [");
IIndexIterator idxItr = entry.FetchRecordsetIndexes();
int rsCnt = 0;
while(idxItr.HasMore() && !entry.IsEmpty())
{
int idx = idxItr.FetchNextIndex();
IList<IBinaryDataListItem> rowData = entry.FetchRecordAt(idx, out error);
result.Append("{");
int colIdx = 0;
foreach(IBinaryDataListItem col in rowData)
{
result.Append("\"");
result.Append(col.FieldName);
result.Append("\":\"");
result.Append(col.TheValue);
result.Append("\"");
// add , if need be ;)
colIdx++;
if(colIdx < rowData.Count)
{
result.Append(",");
}
}
result.Append("}");
// append , for row data ;)
rsCnt++;
if(rsCnt < idxItr.Count)
{
result.Append(", ");
}
}
// END RS ;)
result.Append("]");
return result.ToString();
}
public void AddNewRegion(IBinaryDataListEntry region) {
AddedRegions.Add(region);
}
public EvaluateRuleSet(EvaluateRuleSet prevIter)
{
Errors = new ErrorResultTO();
Errors.MergeErrors(prevIter.Errors);
_result = prevIter._result;
_ns = prevIter._ns;
IsDebug = prevIter.IsDebug;
EvaluateToRootOnly = prevIter.EvaluateToRootOnly;
}
/// <summary>
/// Binds the compiled expression.
/// </summary>
/// <returns></returns>
public IBinaryDataListEntry BindCompiledExpression()
{
// very short circuit if no items ;)
if(_internalKeyMap.Keys.Count == 0)
{
CompiledExpression = null;
return null;
}
// short circuit the long eval for mix mode data ;)
if(_internalMap.Keys.Count <= 1 && FetchEvaluationIterationCount(Expression) == 1 && CompiledExpression.Length == 3)
{
return _internalKeyMap.Values.FirstOrDefault();
}
var replaceValue = string.Empty;
// Right now we assume there are not ;)
foreach(var idx in _internalMap.Keys)
{
var token = BuildSubToken(idx);
var otherKey = _internalMap[idx];
IBinaryDataListEntry value;
if(_internalKeyMap.TryGetValue(otherKey, out value))
{
if(value != null)
{
if(!value.IsRecordset)
{
var scalar = value.FetchScalar();
if(scalar != null)
{
if(_result == null)
{
var toReplace = scalar.TheValue;
CompiledExpression = CompiledExpression.Replace(token, toReplace);
}
else
{
var itr = _result.FetchRecordsetIndexes();
string replaceVal;
try
{
replaceVal = scalar.TheValue;
}
catch(NullValueInVariableException)
{
replaceVal = null;
}
while(itr.HasMore())
{
var val = itr.FetchNextIndex();
// Fetch the next value from result ;)
try
{
string error;
string template = _result.TryFetchRecordsetColumnAtIndex(GlobalConstants.EvaluationRsField, val, out error).TheValue;
Errors.AddError(error);
template = template.Replace(token, replaceVal);
_result.TryPutRecordItemAtIndex(new BinaryDataListItem(template, _ns, GlobalConstants.EvaluationRsField, val), val, out error);
Errors.AddError(error);
}
catch(NullValueInVariableException)
{
//Do nothing got null
}
}
CompiledExpression = CompiledExpression.Replace(token, replaceVal);
}
}
}
else
{
string error;
// build up the complex expression result - this means debug will be out of sync of complex expressions ;)
if(_result == null)
{
IList<Dev2Column> cols = new List<Dev2Column> { new Dev2Column(GlobalConstants.EvaluationRsField, enDev2ColumnArgumentDirection.Both) };
_result = Dev2BinaryDataListFactory.CreateEntry(_ns, string.Empty, cols, BinaryDataList.UID);
var max = _internalKeyMap.Values.OrderByDescending(c => c.ItemCollectionSize()).FirstOrDefault();
if(max != null)
{
var itrToVal = max.ItemCollectionSize();
if(itrToVal == 0)
{
itrToVal = 1;
}
for(int i = 0; i < itrToVal; i++)
{
int idxT = (i + 1);
_result.TryPutRecordItemAtIndex(new BinaryDataListItem(CompiledExpression, _ns, GlobalConstants.EvaluationRsField, idxT), idxT, out error);
Errors.AddError(error);
}
}
if(IsDebug)
{
// attach audit object for debug ;)
_result.ComplexExpressionAuditor = new ComplexExpressionAuditor();
}
}
var idxItr = value.FetchRecordsetIndexes();
int expIdx = 1;
// we need to treat this as a scalar ;)
if(idxItr.Count == 1)
{
int curVal = idxItr.FetchNextIndex();
int amt = _result.ItemCollectionSize();
// ensure we always iterate once ;)
if(amt == 0)
{
amt = 1;
}
idxItr = new LoopedIndexIterator(curVal, amt);
}
// else iterate across the recordset cuz it had a star ;)
while(idxItr.HasMore())
{
try
{
var val = idxItr.FetchNextIndex();
// Fetch the next value from result ;)
var template = _result.TryFetchRecordsetColumnAtIndex(GlobalConstants.EvaluationRsField,
expIdx, out error).TheValue;
Errors.AddError(error);
var binaryValue = value.TryFetchIndexedRecordsetUpsertPayload(val, out error);
Errors.AddError(error);
// now bind this result row with the correct data list data ;)
if(binaryValue != null)
{
var preTemplate = template;
var toReplace = binaryValue.TheValue;
template = template.Replace(token, toReplace);
// In cases when [[[{0}]] is the result, we need to inject the template value
// In cases when [[rec({0}).a]] we need to replace the template pattern ;)
var tmp = CompiledExpression.Replace("[", "").Replace("]", "").Replace(token, string.Empty);
// ReSharper disable ConvertIfStatementToConditionalTernaryExpression
if(tmp.Length > 0)
// ReSharper restore ConvertIfStatementToConditionalTernaryExpression
{
// we have a [[rec({0}.a]] case ;)
replaceValue = toReplace;
}
else
{
replaceValue = template;
}
_result.TryPutRecordItemAtIndex(new BinaryDataListItem(template, _ns, GlobalConstants.EvaluationRsField, expIdx), expIdx, out error);
Errors.AddError(error);
if(IsDebug)
{
var displayValue = DataListUtil.AddBracketsToValueIfNotExist(binaryValue.DisplayValue);
_result.ComplexExpressionAuditor.AddAuditStep(preTemplate, displayValue, token, idx, template, Expression);
_result.ComplexExpressionAuditor.SetMaxIndex(expIdx);
}
}
expIdx++; // inc result index ;)
}
catch(NullValueInVariableException)
{
//Do Nothing got null value
}
}
replaceValue = DataListUtil.RemoveLanguageBrackets(replaceValue);
CompiledExpression = CompiledExpression.Replace(token, replaceValue);
}
}
else
{
CompiledExpression = CompiledExpression.Replace(token, string.Empty);
}
}
}
return _result;
}
/// <summary>
/// Processes the scalar.
/// </summary>
/// <param name="entry">The entry.</param>
/// <returns></returns>
private string ProcessScalar(IBinaryDataListEntry entry)
{
StringBuilder result = new StringBuilder();
string fName = entry.Namespace;
IBinaryDataListItem val = entry.FetchScalar();
if(val != null)
{
result.Append("\"");
result.Append(fName);
result.Append("\":\"");
result.Append(val.TheValue);
result.Append("\"");
}
return result.ToString();
}
