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 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); }
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; } }
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); }
/// <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(); }