void AddEvaluatedDebugItem(IExecutionEnvironment environment, int innerCount, IAssignValue assignValue, int update, DebugItem debugItem)
{
var oldValueResult = environment.Eval(assignValue.Name, update);
var newValueResult = environment.Eval(assignValue.Value, update);
AddDebugItem(new DebugItemStaticDataParams("", innerCount.ToString(CultureInfo.InvariantCulture)), debugItem);
if (oldValueResult.IsWarewolfAtomResult && newValueResult.IsWarewolfAtomResult)
{
AddScalarValueResult(environment, assignValue, update, debugItem, oldValueResult, newValueResult);
}
else if (newValueResult.IsWarewolfAtomResult && oldValueResult.IsWarewolfAtomListresult)
{
AddDebugItem(new DebugItemWarewolfAtomListResult(null, newValueResult, environment.EvalToExpression(assignValue.Value, update), environment.EvalToExpression(assignValue.Name, update), VariableLabelText, NewFieldLabelText, "="), debugItem);
}
else if (oldValueResult.IsWarewolfAtomResult && newValueResult.IsWarewolfAtomListresult)
{
AddDebugItem(new DebugItemWarewolfAtomListResult(null, newValueResult, environment.EvalToExpression(assignValue.Value, update), environment.EvalToExpression(assignValue.Name, update), VariableLabelText, NewFieldLabelText, "="), debugItem);
}
else
{
if (oldValueResult.IsWarewolfAtomListresult && newValueResult.IsWarewolfAtomListresult)
{
var recSetResult = oldValueResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
AddDebugItem(new DebugItemWarewolfAtomListResult(recSetResult, newValueResult, environment.EvalToExpression(assignValue.Value, update), environment.EvalToExpression(assignValue.Name, update), VariableLabelText, NewFieldLabelText, "="), debugItem);
}
}
}
void AddEvaluatedDebugInputItem(IExecutionEnvironment environment, int innerCount, IAssignValue assignValue, int update, DebugItem debugItem, string VariableLabelText, string NewFieldLabelText)
{
var oldValueResult = environment.Eval(assignValue.Name, update);
var newValueResult = environment.Eval(assignValue.Value, update);
AddDefaultDebugItem(innerCount, debugItem);
if (oldValueResult.IsWarewolfAtomResult && newValueResult.IsWarewolfAtomResult)
{
var valueResult = newValueResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomResult;
var scalarResult = oldValueResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomResult;
if (valueResult != null && scalarResult != null)
{
AddDebugItem(new DebugItemWarewolfAtomResult(ExecutionEnvironment.WarewolfAtomToString(scalarResult.Item), ExecutionEnvironment.WarewolfAtomToString(valueResult.Item), assignValue.Name, environment.EvalToExpression(assignValue.Value, update), VariableLabelText, NewFieldLabelText, "="), debugItem);
}
}
else if (newValueResult.IsWarewolfAtomResult && oldValueResult.IsWarewolfAtomListresult || oldValueResult.IsWarewolfAtomResult && newValueResult.IsWarewolfAtomListresult)
{
AddDebugItem(new DebugItemWarewolfAtomListResult(null, newValueResult, environment.EvalToExpression(assignValue.Value, update), environment.EvalToExpression(assignValue.Name, update), VariableLabelText, NewFieldLabelText, "="), debugItem);
}
else
{
if (oldValueResult.IsWarewolfAtomListresult && newValueResult.IsWarewolfAtomListresult)
{
var recSetResult = oldValueResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
AddDebugItem(new DebugItemWarewolfAtomListResult(recSetResult, newValueResult, environment.EvalToExpression(assignValue.Value, update), environment.EvalToExpression(assignValue.Name, update), VariableLabelText, NewFieldLabelText, "="), debugItem);
}
}
}
public DebugEvalResult(string inputVariable, string label, IExecutionEnvironment environment, bool isDataMerge = false)
{
_inputVariable = inputVariable.Trim();
_label = label;
try
{
if (ExecutionEnvironment.IsRecordsetIdentifier(_inputVariable) && DataListUtil.IsEvaluated(_inputVariable))
{
if (DataListUtil.GetRecordsetIndexType(_inputVariable) == enRecordsetIndexType.Blank)
{
var length = environment.GetLength(DataListUtil.ExtractRecordsetNameFromValue(_inputVariable));
_inputVariable = DataListUtil.ReplaceRecordsetBlankWithIndex(_inputVariable, length);
}
}
if (isDataMerge)
{
var evalForDataMerge = environment.EvalForDataMerge(_inputVariable);
var innerIterator = new WarewolfListIterator();
var innerListOfIters = new List <WarewolfIterator>();
foreach (var listOfIterator in evalForDataMerge)
{
var inIterator = new WarewolfIterator(listOfIterator);
innerIterator.AddVariableToIterateOn(inIterator);
innerListOfIters.Add(inIterator);
}
var atomList = new List <DataASTMutable.WarewolfAtom>();
while (innerIterator.HasMoreData())
{
var stringToUse = "";
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (var warewolfIterator in innerListOfIters)
{
stringToUse += warewolfIterator.GetNextValue();
}
atomList.Add(DataASTMutable.WarewolfAtom.NewDataString(stringToUse));
}
var finalString = string.Join("", atomList);
_evalResult = WarewolfDataEvaluationCommon.WarewolfEvalResult.NewWarewolfAtomListresult(new WarewolfAtomList <DataASTMutable.WarewolfAtom>(DataASTMutable.WarewolfAtom.Nothing, atomList));
if (DataListUtil.IsFullyEvaluated(finalString))
{
_inputVariable = finalString;
_evalResult = environment.Eval(finalString);
}
}
else
{
var evalToExpression = environment.EvalToExpression(_inputVariable);
if (DataListUtil.IsEvaluated(evalToExpression))
{
_inputVariable = evalToExpression;
}
_evalResult = environment.Eval(_inputVariable);
}
}
catch (Exception e)
{
Dev2Logger.Log.Error(e.Message, e);
_evalResult = WarewolfDataEvaluationCommon.WarewolfEvalResult.NewWarewolfAtomResult(DataASTMutable.WarewolfAtom.Nothing);
}
}
private (IEnumerable <INameValue> head, string query, string data, IEnumerable <IFormDataParameters> conditions) GetEnvironmentInputVariables(IExecutionEnvironment environment, int update)
{
IEnumerable <INameValue> head = null;
if (Headers != null)
{
head = Headers.Select(a => new NameValue(ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval(a.Name, update)), ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval(a.Value, update))));
if (IsFormDataChecked)
{
var headersHelper = new WebRequestHeadersHelper(notEvaluatedHeaders: Headers, evaluatedHeaders: head);
head = headersHelper.CalculateFormDataContentType();
}
}
var query = string.Empty;
if (QueryString != null)
{
query = ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval(QueryString, update));
}
var postData = string.Empty;
if (PostData != null && IsManualChecked)
{
postData = ExecutionEnvironment.WarewolfEvalResultToString(environment.Eval(PostData, update, true));
}
var conditions = new List <IFormDataParameters>();
if ((Conditions ?? (Conditions = new List <FormDataConditionExpression>())).Any() && IsFormDataChecked)
{
_errorsTo = new ErrorResultTO();
conditions = Conditions.SelectMany(o => o.Eval(GetArgumentsFunc, _errorsTo.HasErrors())).ToList();
}
IEnumerable <string[]> GetArgumentsFunc(string col1s, string col2s, string col3s)
{
var col1 = environment.EvalAsList(col1s, 0, true);
var col2 = environment.EvalAsList(col2s ?? "", 0, true);
var col3 = environment.EvalAsList(col3s ?? "", 0, true);
var iter = new WarewolfListIterator();
var c1 = new WarewolfAtomIterator(col1);
var c2 = new WarewolfAtomIterator(col2);
var c3 = new WarewolfAtomIterator(col3);
iter.AddVariableToIterateOn(c1);
iter.AddVariableToIterateOn(c2);
iter.AddVariableToIterateOn(c3);
while (iter.HasMoreData())
{
var item = new[] { iter.FetchNextValue(c1), iter.FetchNextValue(c2), iter.FetchNextValue(c3) };
yield return(item);
}
yield break;
}
return(head, query, postData, conditions);
}
#pragma warning disable S3776 // Cognitive Complexity of methods should not be too high
public List <IDebugItem> GetDebugInputs(IExecutionEnvironment env, IDev2LanguageParser parser, int update)
#pragma warning restore S3776 // Cognitive Complexity of methods should not be too high
{
var results = new List <IDebugItem>();
if (Inputs != null && Inputs.Count > 0)
{
foreach (var serviceInput in Inputs)
{
if (string.IsNullOrEmpty(serviceInput.Value))
{
continue;
}
var tmpEntry = env.Eval(serviceInput.Value, update);
var itemToAdd = new DebugItem();
if (tmpEntry.IsWarewolfAtomResult)
{
AddWarewolfAtomResults(results, serviceInput, tmpEntry, itemToAdd);
}
else
{
AddWarewolfAtomListResults(results, serviceInput, tmpEntry, itemToAdd);
}
}
}
else
{
var inputs = parser.Parse(InputMapping);
foreach (IDev2Definition dev2Definition in inputs)
{
if (string.IsNullOrEmpty(dev2Definition.RawValue))
{
continue;
}
var tmpEntry = env.Eval(dev2Definition.RawValue, update);
var itemToAdd = new DebugItem();
if (tmpEntry.IsWarewolfAtomResult)
{
AddWarewolfAtomResults(results, dev2Definition, tmpEntry, itemToAdd);
}
else
{
AddWarewolfAtomList(results, dev2Definition, tmpEntry, itemToAdd);
}
}
}
foreach (IDebugItem debugInput in results)
{
debugInput.FlushStringBuilder();
}
return(results);
}
protected override void AddItemsToIterator(IExecutionEnvironment environment, int update)
{
_compresItr = new WarewolfIterator(environment.Eval(CompressionRatio, update));
ColItr.AddVariableToIterateOn(_compresItr);
_archNameItr = new WarewolfIterator(environment.Eval(ArchiveName, update));
ColItr.AddVariableToIterateOn(_archNameItr);
_archPassItr = new WarewolfIterator(environment.Eval(DecryptedArchivePassword, update));
ColItr.AddVariableToIterateOn(_archPassItr);
}
public void WarewolfListIterator_AddVariableToIterateOn_Should()
{
_expr3 = new WarewolfIterator(_environment.Eval("[[RecSet()]]", 0));
Assert.IsNotNull(_warewolfListIterator);
var privateObj = new PrivateObject(_warewolfListIterator);
var variablesToIterateOn = privateObj.GetField("_variablesToIterateOn") as List <IWarewolfIterator>;
Assert.IsNotNull(variablesToIterateOn);
Assert.AreEqual(2, variablesToIterateOn.Count);
_warewolfListIterator.AddVariableToIterateOn(_expr3);
Assert.AreEqual(3, variablesToIterateOn.Count);
}
public void TestInitialize()
{
_environment = new ExecutionEnvironment();
_warewolfListIterator = new WarewolfListIterator();
_environment.Assign(Result, "Success", 0);
_expr1 = new WarewolfIterator(_environment.Eval(Result, 0));
_expr2 = new WarewolfIterator(_environment.Eval("[[@Parent()]]", 0));
_warewolfListIterator.AddVariableToIterateOn(_expr1);
_warewolfListIterator.AddVariableToIterateOn(_expr2);
}
public void CreateScalarInputs(IExecutionEnvironment outerEnvironment, IEnumerable <IDev2Definition> inputScalarList, IExecutionEnvironment env, int update)
{
foreach (var dev2Definition in inputScalarList)
{
if (!string.IsNullOrEmpty(dev2Definition.Name))
{
env.AssignDataShape("[[" + dev2Definition.Name + "]]");
}
if (!dev2Definition.IsRecordSet)
{
if (!string.IsNullOrEmpty(dev2Definition.RawValue))
{
var warewolfEvalResult = outerEnvironment.Eval(dev2Definition.RawValue, update);
if (warewolfEvalResult.IsWarewolfAtomListresult)
{
ScalarAtomList(warewolfEvalResult, env, dev2Definition);
}
else
{
ScalarAtom(warewolfEvalResult, env, dev2Definition);
}
}
}
}
}
public void CreateObjectInputs(IExecutionEnvironment outerEnvironment, IEnumerable <IDev2Definition> inputObjectList, IExecutionEnvironment env, int update)
{
foreach (var dev2Definition in inputObjectList)
{
if (!string.IsNullOrEmpty(dev2Definition.RawValue))
{
if (DataListUtil.RemoveLanguageBrackets(dev2Definition.RawValue).StartsWith("@"))
{
var jVal = outerEnvironment.EvalJContainer(dev2Definition.RawValue);
env.AddToJsonObjects(DataListUtil.AddBracketsToValueIfNotExist(dev2Definition.Name), jVal);
}
else
{
var result = outerEnvironment.Eval(dev2Definition.RawValue, update);
if (result.IsWarewolfAtomListresult)
{
var data = result as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
if (data != null && data.Item.Any())
{
env.AssignWithFrame(new AssignValue(DataListUtil.AddBracketsToValueIfNotExist(dev2Definition.Name), ExecutionEnvironment.WarewolfAtomToString(data.Item.Last())), 0);
}
}
else
{
var data = result as CommonFunctions.WarewolfEvalResult.WarewolfAtomResult;
if (data != null)
{
env.AssignWithFrame(new AssignValue(DataListUtil.AddBracketsToValueIfNotExist(dev2Definition.Name), ExecutionEnvironment.WarewolfAtomToString(data.Item)), 0);
}
}
}
}
}
}
void AddSingleInputDebugItemAfterException(IExecutionEnvironment environment, IAssignValue assignValue, int update, DebugItem debugItem, string VariableLabelText, string NewFieldLabelText)
{
if (DataListUtil.IsEvaluated(assignValue.Value))
{
var newValueResult = environment.Eval(assignValue.Value, update);
if (newValueResult.IsWarewolfAtomResult)
{
if (newValueResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult valueResult)
{
AddDebugItem(new DebugItemWarewolfAtomResult("", ExecutionEnvironment.WarewolfAtomToString(valueResult.Item), environment.EvalToExpression(assignValue.Name, update), assignValue.Value, VariableLabelText, NewFieldLabelText, "="), debugItem);
}
}
else
{
if (newValueResult.IsWarewolfAtomListresult)
{
AddDebugItem(new DebugItemWarewolfAtomListResult(null, newValueResult, environment.EvalToExpression(assignValue.Value, update), assignValue.Name, VariableLabelText, NewFieldLabelText, "="), debugItem);
}
}
}
else
{
AddDebugItem(new DebugItemWarewolfAtomResult("", assignValue.Value, environment.EvalToExpression(assignValue.Name, update), "", VariableLabelText, NewFieldLabelText, "="), debugItem);
}
}
static void EvalAssignRecordSets(IExecutionEnvironment innerEnvironment, IExecutionEnvironment environment, int update, IDev2Definition outPutRecSet, IDev2Definition outputColumnDefinitions)
{
var correctRecSet = "[[" + outputColumnDefinitions.RecordSetName + "(*)." + outputColumnDefinitions.Name + "]]";
var warewolfEvalResult = innerEnvironment.Eval(correctRecSet, 0);
if (warewolfEvalResult.IsWarewolfAtomListresult)
{
var recsetResult = warewolfEvalResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
if (outPutRecSet.IsRecordSet)
{
var enRecordsetIndexType = DataListUtil.GetRecordsetIndexType(outputColumnDefinitions.RawValue);
if (enRecordsetIndexType == enRecordsetIndexType.Star && recsetResult != null)
{
environment.EvalAssignFromNestedStar(outputColumnDefinitions.RawValue, recsetResult, update);
}
if (enRecordsetIndexType == enRecordsetIndexType.Blank && recsetResult != null)
{
environment.EvalAssignFromNestedLast(outputColumnDefinitions.RawValue, recsetResult, 0);
}
if (enRecordsetIndexType == enRecordsetIndexType.Numeric && recsetResult != null)
{
environment.EvalAssignFromNestedNumeric(outputColumnDefinitions.RawValue, recsetResult, 0);
}
}
}
}
private void RegularItem(IExecutionEnvironment environment, int update, bool isCalculate)
{
var evalToExpression = environment.EvalToExpression(_inputVariable, update);
if (DataListUtil.IsEvaluated(evalToExpression))
{
_inputVariable = evalToExpression;
}
_evalResult = environment.Eval(_inputVariable, update);
string cleanExpression;
var isCalcExpression = DataListUtil.IsCalcEvaluation(_inputVariable, out cleanExpression);
if (isCalcExpression && !isCalculate)
{
if (_evalResult.IsWarewolfAtomResult)
{
var atomResult = _evalResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomResult;
if (atomResult != null)
{
var res = atomResult.Item.ToString();
string resValue;
DataListUtil.IsCalcEvaluation(res, out resValue);
_evalResult = CommonFunctions.WarewolfEvalResult.NewWarewolfAtomResult(DataStorage.WarewolfAtom.NewDataString(resValue));
}
}
_inputVariable = cleanExpression;
}
}
private void DoCalculation(IExecutionEnvironment environment, string fieldName, string cleanExpression, int update)
{
var functionEvaluator = new FunctionEvaluator();
var warewolfEvalResult = environment.Eval(cleanExpression, update);
if (warewolfEvalResult.IsWarewolfAtomResult)
{
var result = warewolfEvalResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomResult;
if (result != null)
{
var eval = PerformCalcForAtom(result.Item, functionEvaluator);
var doCalculation = new AssignValue(fieldName, eval);
environment.AssignWithFrame(doCalculation, update);
}
}
if (warewolfEvalResult.IsWarewolfAtomListresult)
{
var result = warewolfEvalResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
if (result != null)
{
var counter = 1;
foreach (var item in result.Item)
{
var eval = PerformCalcForAtom(item, functionEvaluator);
var doCalculation = new AssignValue(fieldName, eval);
environment.AssignWithFrame(doCalculation, update == 0 ? counter : update);
counter++;
}
}
}
}
static Func <DataStorage.WarewolfAtom, DataStorage.WarewolfAtom> TryConvertFunc(ICaseConvertTO conversionType, IExecutionEnvironment env, int update)
{
var convertFunct = CaseConverter.GetFuncs();
if (convertFunct.TryGetValue(conversionType.ConvertType, out Func <string, string> returnedFunc) && returnedFunc != null)
{
return(a =>
{
var upper = returnedFunc.Invoke(a.ToString());
var evalled = env.Eval(upper, update);
if (evalled.IsWarewolfAtomResult)
{
if (evalled is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult warewolfAtomResult)
{
return warewolfAtomResult.Item;
}
return DataStorage.WarewolfAtom.Nothing;
}
return DataStorage.WarewolfAtom.NewDataString(CommonFunctions.evalResultToString(evalled));
});
}
throw new Exception(ErrorResource.ConvertOptionDoesNotExist);
}
IEnumerable <string> BuildQueryFromTo(SharepointSearchTo sharepointSearchTo, IExecutionEnvironment env, ISharepointFieldTo sharepointFieldTo, int update)
{
var warewolfEvalResult = env.Eval(sharepointSearchTo.ValueToMatch, update);
var fieldType = sharepointFieldTo.GetFieldType();
if (sharepointSearchTo.SearchType == "In")
{
var startSearchTerm = $"{SharepointSearchOptions.GetStartTagForSearchOption(sharepointSearchTo.SearchType)}<FieldRef Name=\"{sharepointSearchTo.InternalName}\"></FieldRef>";
startSearchTerm += "<Values>";
if (warewolfEvalResult.IsWarewolfAtomListresult)
{
startSearchTerm = AddAtomListResult(sharepointFieldTo, warewolfEvalResult, fieldType, startSearchTerm);
}
else
{
startSearchTerm = AddAtomResult(sharepointFieldTo, warewolfEvalResult, fieldType, startSearchTerm);
}
startSearchTerm += "</Values>";
startSearchTerm += SharepointSearchOptions.GetEndTagForSearchOption(sharepointSearchTo.SearchType);
yield return(startSearchTerm);
}
else
{
var iterator = new WarewolfIterator(warewolfEvalResult);
while (iterator.HasMoreData())
{
yield return($"{SharepointSearchOptions.GetStartTagForSearchOption(sharepointSearchTo.SearchType)}<FieldRef Name=\"{sharepointSearchTo.InternalName}\"></FieldRef><Value Type=\"{fieldType}\">{CastWarewolfValueToCorrectType(iterator.GetNextValue(), sharepointFieldTo.Type)}</Value>{SharepointSearchOptions.GetEndTagForSearchOption(sharepointSearchTo.SearchType)}");
}
}
}
public override List <DebugItem> GetDebugInputs(IExecutionEnvironment env, int update)
{
if (env == null)
{
return(new List <DebugItem>());
}
base.GetDebugInputs(env, update);
var head = Headers.Select(a => new NameValue(ExecutionEnvironment.WarewolfEvalResultToString(env.Eval(a.Name, update)), ExecutionEnvironment.WarewolfEvalResultToString(env.Eval(a.Value, update)))).Where(a => !(String.IsNullOrEmpty(a.Name) && String.IsNullOrEmpty(a.Value)));
var query = ExecutionEnvironment.WarewolfEvalResultToString(env.Eval(QueryString, update));
var url = ResourceCatalog.GetResource <WebSource>(Guid.Empty, SourceId);
var headerString = string.Join(" ", head.Select(a => a.Name + " : " + a.Value));
var debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", "URL"), debugItem);
AddDebugItem(new DebugEvalResult(url.Address, "", env, update), debugItem);
_debugInputs.Add(debugItem);
debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", "Query String"), debugItem);
AddDebugItem(new DebugEvalResult(query, "", env, update), debugItem);
_debugInputs.Add(debugItem);
debugItem = new DebugItem();
AddDebugItem(new DebugItemStaticDataParams("", "Headers"), debugItem);
AddDebugItem(new DebugEvalResult(headerString, "", env, update), debugItem);
_debugInputs.Add(debugItem);
return(_debugInputs);
}
Func <DataStorage.WarewolfAtom, DataStorage.WarewolfAtom> TryConvertFunc(BaseConvertTO item, IExecutionEnvironment env, int update) => a =>
{
var from = _fac.CreateConverter((enDev2BaseConvertType)Dev2EnumConverter.GetEnumFromStringDiscription(item.FromType, typeof(enDev2BaseConvertType)));
var to = _fac.CreateConverter((enDev2BaseConvertType)Dev2EnumConverter.GetEnumFromStringDiscription(item.ToType, typeof(enDev2BaseConvertType)));
var broker = _fac.CreateBroker(@from, to);
var value = a.ToString();
if (a.IsNothing)
{
throw new Exception(string.Format(ErrorResource.NullScalarValue, item.FromExpression));
}
if (String.IsNullOrEmpty(value))
{
return(DataStorage.WarewolfAtom.NewDataString(""));
}
var upper = broker.Convert(value);
var evalled = env.Eval(upper, update);
if (evalled.IsWarewolfAtomResult)
{
if (evalled is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult warewolfAtomResult)
{
return(warewolfAtomResult.Item);
}
return(DataStorage.WarewolfAtom.Nothing);
}
return(DataStorage.WarewolfAtom.NewDataString(CommonFunctions.evalResultToString(evalled)));
};
private void AddErrorDebugItem(IExecutionEnvironment environment, int innerCount, IAssignValue assignValue, int update, DebugItem debugItem, string VariableLabelText, string NewFieldLabelText)
{
AddDebugItem(new DebugItemStaticDataParams("", innerCount.ToString(CultureInfo.InvariantCulture)), debugItem);
if (DataListUtil.IsEvaluated(assignValue.Value))
{
var newValueResult = environment.Eval(assignValue.Value, update);
if (newValueResult.IsWarewolfAtomResult)
{
if (newValueResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult valueResult)
{
AddDebugItem(new DebugItemWarewolfAtomResult("", ExecutionEnvironment.WarewolfAtomToString(valueResult.Item), environment.EvalToExpression(assignValue.Name, update), assignValue.Value, VariableLabelText, NewFieldLabelText, "="), debugItem);
}
}
else
{
if (newValueResult.IsWarewolfAtomListresult)
{
AddDebugItem(new DebugItemWarewolfAtomListResult(null, newValueResult, environment.EvalToExpression(assignValue.Value, update), assignValue.Name, VariableLabelText, NewFieldLabelText, "="), debugItem);
}
}
}
else
{
AddDebugItem(new DebugItemWarewolfAtomResult("", assignValue.Value, environment.EvalToExpression(assignValue.Name, update), "", VariableLabelText, NewFieldLabelText, "="), debugItem);
}
}
void CreateDebugInput(IExecutionEnvironment environment, int innerCount, IAssignValue assignValue, int update, DebugItem debugItem, string VariableLabelText, string NewFieldLabelText)
{
if (!DataListUtil.IsEvaluated(assignValue.Value))
{
var evalResult = environment.Eval(assignValue.Name, update);
AddDebugItem(new DebugItemStaticDataParams("", innerCount.ToString(CultureInfo.InvariantCulture)), debugItem);
if (evalResult.IsWarewolfAtomResult)
{
if (evalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult scalarResult)
{
AddDebugItem(new DebugItemWarewolfAtomResult(ExecutionEnvironment.WarewolfAtomToString(scalarResult.Item), assignValue.Value, environment.EvalToExpression(assignValue.Name, update), "", VariableLabelText, NewFieldLabelText, "="), debugItem);
}
}
else
{
AddWarewolfAtomListDebugResult(environment, assignValue, update, debugItem, VariableLabelText, NewFieldLabelText, evalResult);
}
}
else
{
if (DataListUtil.IsEvaluated(assignValue.Value))
{
AddEvaluatedDebugItem(environment, innerCount, assignValue, update, NewFieldLabelText, VariableLabelText, debugItem);
}
}
}
protected void GetRecordSetFieldValueFromDataList(IExecutionEnvironment environment, string recordSet, string fieldNameToRetrieve, out IList <string> result, out string error)
{
var variableName = recordSet;
result = new List <string>();
error = "";
try
{
if (!string.IsNullOrEmpty(fieldNameToRetrieve))
{
variableName = DataListUtil.CreateRecordsetDisplayValue(recordSet, fieldNameToRetrieve, "*");
}
var warewolfEvalResult = environment.Eval(DataListUtil.AddBracketsToValueIfNotExist(variableName), 0, true);
if (warewolfEvalResult == null)
{
return;
}
if (warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult listResult)
{
foreach (var res in listResult.Item)
{
result.Add(ExecutionEnvironment.WarewolfAtomToString(res));
}
}
}
catch (Exception e)
{
error = e.Message;
}
}
static void CreateScalarInputs(IExecutionEnvironment outerEnvironment, IDev2Definition dev2Definition, IExecutionEnvironment env, int update)
{
void ScalarAtomList(CommonFunctions.WarewolfEvalResult warewolfEvalResult)
{
if (warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult data && data.Item.Any())
{
env.AssignWithFrame(new AssignValue("[[" + dev2Definition.Name + "]]", ExecutionEnvironment.WarewolfAtomToString(data.Item.Last())), 0);
}
}
void ScalarAtom(CommonFunctions.WarewolfEvalResult warewolfEvalResult)
{
if (warewolfEvalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult data)
{
env.AssignWithFrame(new AssignValue("[[" + dev2Definition.Name + "]]", ExecutionEnvironment.WarewolfAtomToString(data.Item)), 0);
}
}
if (!string.IsNullOrEmpty(dev2Definition.Name))
{
env.AssignDataShape("[[" + dev2Definition.Name + "]]");
}
if (!dev2Definition.IsRecordSet && !string.IsNullOrEmpty(dev2Definition.RawValue))
{
var warewolfEvalResult = outerEnvironment.Eval(dev2Definition.RawValue, update);
if (warewolfEvalResult.IsWarewolfAtomListresult)
{
ScalarAtomList(warewolfEvalResult);
}
else
{
ScalarAtom(warewolfEvalResult);
}
}
}
void AddEvaluatedDebugOutputItem(IExecutionEnvironment environment, int innerCount, IAssignValue assignValue, int update, string VariableLabelText, string NewFieldLabelText, DebugItem debugItem)
{
var evalResult = environment.Eval(assignValue.Name, update);
AddDefaultDebugItem(innerCount, debugItem);
if (evalResult.IsWarewolfAtomResult && evalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult scalarResult)
{
AddDebugItem(new DebugItemWarewolfAtomResult(ExecutionEnvironment.WarewolfAtomToString(scalarResult.Item), "", environment.EvalToExpression(assignValue.Name, update), "", VariableLabelText, NewFieldLabelText, "="), debugItem);
}
var evalResult2 = environment.Eval(assignValue.Value, update);
if (evalResult.IsWarewolfAtomListresult && evalResult is CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult recSetResult)
{
AddDebugItem(DataListUtil.GetRecordsetIndexType(assignValue.Name) == enRecordsetIndexType.Blank ? new DebugItemWarewolfAtomListResult(recSetResult, evalResult2, "", assignValue.Name, VariableLabelText, NewFieldLabelText, "=") : new DebugItemWarewolfAtomListResult(recSetResult, environment.EvalToExpression(assignValue.Value, update), "", environment.EvalToExpression(assignValue.Name, update), VariableLabelText, NewFieldLabelText, "="), debugItem);
}
}
static void CreateObjectInputs(IExecutionEnvironment outerEnvironment, IDev2Definition dev2Definition, IExecutionEnvironment env, int update)
{
if (DataListUtil.RemoveLanguageBrackets(dev2Definition.RawValue).StartsWith("@"))
{
var jVal = outerEnvironment.EvalJContainer(dev2Definition.RawValue);
env.AddToJsonObjects(DataListUtil.AddBracketsToValueIfNotExist(dev2Definition.Name), jVal);
}
else
{
var result = outerEnvironment.Eval(dev2Definition.RawValue, update);
if (result.IsWarewolfAtomListresult)
{
if (result is CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult data && data.Item.Any())
{
env.AssignWithFrame(new AssignValue(DataListUtil.AddBracketsToValueIfNotExist(dev2Definition.Name), ExecutionEnvironment.WarewolfAtomToString(data.Item.Last())), 0);
}
}
else
{
if (result is CommonFunctions.WarewolfEvalResult.WarewolfAtomResult data)
{
env.AssignWithFrame(new AssignValue(DataListUtil.AddBracketsToValueIfNotExist(dev2Definition.Name), ExecutionEnvironment.WarewolfAtomToString(data.Item)), 0);
}
}
}
}
private Func <DataASTMutable.WarewolfAtom, DataASTMutable.WarewolfAtom> TryConvertFunc(ICaseConvertTO conversionType, IExecutionEnvironment env, int update)
{
var convertFunct = CaseConverter.GetFuncs();
Func <string, string> returnedFunc;
if (convertFunct.TryGetValue(conversionType.ConvertType, out returnedFunc))
{
if (returnedFunc != null)
{
return(a =>
{
var upper = returnedFunc.Invoke(a.ToString());
var evalled = env.Eval(upper, update);
if (evalled.IsWarewolfAtomResult)
{
var warewolfAtomResult = evalled as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
if (warewolfAtomResult != null)
{
return warewolfAtomResult.Item;
}
return DataASTMutable.WarewolfAtom.Nothing;
}
return DataASTMutable.WarewolfAtom.NewDataString(WarewolfDataEvaluationCommon.EvalResultToString(evalled));
});
}
}
throw new Exception("Convert option does not exist");
}
void CreateRecordSetsInputs(IExecutionEnvironment outerEnvironment, IRecordSetDefinition recordSetDefinition, IExecutionEnvironment env, int update)
{
var emptyList = new List <string>();
foreach (var dev2ColumnDefinition in recordSetDefinition.Columns)
{
if (dev2ColumnDefinition.IsRecordSet)
{
var defn = "[[" + dev2ColumnDefinition.RecordSetName + "()." + dev2ColumnDefinition.Name + "]]";
if (string.IsNullOrEmpty(dev2ColumnDefinition.RawValue) && !emptyList.Contains(defn))
{
emptyList.Add(defn);
continue;
}
var warewolfEvalResult = outerEnvironment.Eval(dev2ColumnDefinition.RawValue, update);
if (warewolfEvalResult.IsWarewolfAtomListresult)
{
AtomListInputs(warewolfEvalResult, dev2ColumnDefinition, env);
}
if (warewolfEvalResult.IsWarewolfAtomResult)
{
AtomInputs(warewolfEvalResult, dev2ColumnDefinition, env);
}
}
}
foreach (var defn in emptyList)
{
env.AssignDataShape(defn);
}
}
Func <DataASTMutable.WarewolfAtom, DataASTMutable.WarewolfAtom> TryConvertFunc(BaseConvertTO item, IExecutionEnvironment env, int update)
{
return(a =>
{
IBaseConverter from = _fac.CreateConverter((enDev2BaseConvertType)Dev2EnumConverter.GetEnumFromStringDiscription(item.FromType, typeof(enDev2BaseConvertType)));
IBaseConverter to = _fac.CreateConverter((enDev2BaseConvertType)Dev2EnumConverter.GetEnumFromStringDiscription(item.ToType, typeof(enDev2BaseConvertType)));
IBaseConversionBroker broker = _fac.CreateBroker(@from, to);
var value = a.ToString();
if (a.IsNothing)
{
throw new Exception(string.Format("Scalar value {{{0}}} is NULL", item.FromExpression));
}
if (String.IsNullOrEmpty(value))
{
return DataASTMutable.WarewolfAtom.NewDataString("");
}
var upper = broker.Convert(value);
var evalled = env.Eval(upper, update);
if (evalled.IsWarewolfAtomResult)
{
var warewolfAtomResult = evalled as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
if (warewolfAtomResult != null)
{
return warewolfAtomResult.Item;
}
return DataASTMutable.WarewolfAtom.Nothing;
}
return DataASTMutable.WarewolfAtom.NewDataString(WarewolfDataEvaluationCommon.EvalResultToString(evalled));
});
}
private static void EvalAssignScalars(IExecutionEnvironment innerEnvironment, IExecutionEnvironment environment, int update, IEnumerable <IDev2Definition> outputScalarList)
{
foreach (var dev2Definition in outputScalarList)
{
if (!dev2Definition.IsRecordSet && !dev2Definition.IsObject)
{
var warewolfEvalResult = innerEnvironment.Eval(DataListUtil.AddBracketsToValueIfNotExist(dev2Definition.Name), update);
if (warewolfEvalResult.IsWarewolfAtomListresult)
{
var data = warewolfEvalResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
if (data != null && data.Item.Any())
{
environment.Assign("[[" + dev2Definition.Value + "]]", ExecutionEnvironment.WarewolfAtomToString(data.Item.Last()), update);
}
}
else
{
var data = warewolfEvalResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomResult;
if (data != null)
{
environment.Assign(DataListUtil.AddBracketsToValueIfNotExist(dev2Definition.Value), ExecutionEnvironment.WarewolfAtomToString(data.Item), update);
}
}
}
}
}
#pragma warning disable S1541 // Methods and properties should not be too complex
private void AddEvaluatedDebugInputItem(IExecutionEnvironment environment, int innerCount, IAssignValue assignValue, int update, DebugItem debugItem, string VariableLabelText, string NewFieldLabelText)
#pragma warning restore S1541 // Methods and properties should not be too complex
{
if (assignValue.Name.EndsWith("()]]"))
{
throw new Exception("Append data to array");
}
var oldValueResult = environment.Eval(assignValue.Name, update);
var newValueResult = environment.Eval(assignValue.Value, update);
AddDebugItem(new DebugItemStaticDataParams("", innerCount.ToString(CultureInfo.InvariantCulture)), debugItem);
if (oldValueResult.IsWarewolfAtomResult && newValueResult.IsWarewolfAtomResult)
{
var valueResult = newValueResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomResult;
var scalarResult = oldValueResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomResult;
if (valueResult != null && scalarResult != null)
{
AddDebugItem(new DebugItemWarewolfAtomResult(ExecutionEnvironment.WarewolfAtomToString(scalarResult.Item), ExecutionEnvironment.WarewolfAtomToString(valueResult.Item), assignValue.Name, environment.EvalToExpression(assignValue.Value, update), VariableLabelText, NewFieldLabelText, "="), debugItem);
}
}
else if (newValueResult.IsWarewolfAtomResult && oldValueResult.IsWarewolfAtomListresult)
{
AddDebugItem(new DebugItemWarewolfAtomListResult(null, newValueResult, environment.EvalToExpression(assignValue.Value, update), assignValue.Name, VariableLabelText, NewFieldLabelText, "="), debugItem);
}
else if (oldValueResult.IsWarewolfAtomResult && newValueResult.IsWarewolfAtomListresult)
{
AddDebugItem(new DebugItemWarewolfAtomListResult(null, newValueResult, environment.EvalToExpression(assignValue.Value, update), assignValue.Name, VariableLabelText, NewFieldLabelText, "="), debugItem);
}
else
{
if (oldValueResult.IsWarewolfAtomListresult && newValueResult.IsWarewolfAtomListresult)
{
var old = (CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult)oldValueResult;
if (!old.Item.Any())
{
AddDebugItem(new DebugItemWarewolfAtomListResult(null, newValueResult, environment.EvalToExpression(assignValue.Value, update), assignValue.Name, VariableLabelText, NewFieldLabelText, "="), debugItem);
}
else
{
var recSetResult = oldValueResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomListresult;
AddDebugItem(new DebugItemWarewolfAtomListResult(recSetResult, newValueResult, environment.EvalToExpression(assignValue.Value, update), assignValue.Name, VariableLabelText, NewFieldLabelText, "="), debugItem);
}
}
}
}
IEnumerable<string> BuildQueryFromTo(SharepointSearchTo sharepointSearchTo, IExecutionEnvironment env, ISharepointFieldTo sharepointFieldTo,int update)
{
WarewolfIterator iterator = new WarewolfIterator(env.Eval(sharepointSearchTo.ValueToMatch,update));
while (iterator.HasMoreData())
{
var fieldType = sharepointFieldTo.GetFieldType();
yield return string.Format("{0}<FieldRef Name=\"{1}\"></FieldRef><Value Type=\"{2}\">{3}</Value>{4}", SharepointSearchOptions.GetStartTagForSearchOption(sharepointSearchTo.SearchType), sharepointSearchTo.InternalName, fieldType, CastWarewolfValueToCorrectType(iterator.GetNextValue(), sharepointFieldTo.Type), SharepointSearchOptions.GetEndTagForSearchOption(sharepointSearchTo.SearchType));
}
}
protected IWarewolfIterator CreateDataListEvaluateIterator(string expression, IExecutionEnvironment executionEnvironment, int update)
{
var evalled = executionEnvironment.Eval(expression, update);
// if(ExecutionEnvironment.IsNothing(evalled))
// throw new Exception("Invalid variable: "+expression);
var expressionIterator = new WarewolfIterator(evalled);
return(expressionIterator);
}
protected override void AddItemsToIterator(IExecutionEnvironment environment)
{
_compresItr = new WarewolfIterator(environment.Eval(CompressionRatio));
ColItr.AddVariableToIterateOn(_compresItr);
_archNameItr = new WarewolfIterator(environment.Eval(ArchiveName));
ColItr.AddVariableToIterateOn(_archNameItr);
_archPassItr = new WarewolfIterator(environment.Eval(ArchivePassword));
ColItr.AddVariableToIterateOn(_archPassItr);
}
static WarewolfDataEvaluationCommon.WarewolfEvalResult GetWarewolfEvalResult(IExecutionEnvironment env, string col)
{
var warewolfEvalResult = WarewolfDataEvaluationCommon.WarewolfEvalResult.NewWarewolfAtomResult(DataASTMutable.WarewolfAtom.Nothing);
try
{
warewolfEvalResult = env.Eval(col);
}
catch(NullValueInVariableException)
{
//This is allow for decisions.
}
return warewolfEvalResult;
}
public DebugEvalResult(string inputVariable, string label, IExecutionEnvironment environment, bool isDataMerge = false)
{
_inputVariable = inputVariable.Trim();
_label = label;
try
{
if (ExecutionEnvironment.IsRecordsetIdentifier(_inputVariable) && DataListUtil.IsEvaluated(_inputVariable))
{
if (DataListUtil.GetRecordsetIndexType(_inputVariable) == enRecordsetIndexType.Blank)
{
var length = environment.GetLength(DataListUtil.ExtractRecordsetNameFromValue(_inputVariable));
_inputVariable = DataListUtil.ReplaceRecordsetBlankWithIndex(_inputVariable, length);
}
}
if (isDataMerge)
{
var evalForDataMerge = environment.EvalForDataMerge(_inputVariable);
var innerIterator = new WarewolfListIterator();
var innerListOfIters = new List<WarewolfIterator>();
foreach (var listOfIterator in evalForDataMerge)
{
var inIterator = new WarewolfIterator(listOfIterator);
innerIterator.AddVariableToIterateOn(inIterator);
innerListOfIters.Add(inIterator);
}
var atomList = new List<DataASTMutable.WarewolfAtom>();
while (innerIterator.HasMoreData())
{
var stringToUse = "";
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (var warewolfIterator in innerListOfIters)
{
stringToUse += warewolfIterator.GetNextValue();
}
atomList.Add(DataASTMutable.WarewolfAtom.NewDataString(stringToUse));
}
var finalString = string.Join("", atomList);
_evalResult = WarewolfDataEvaluationCommon.WarewolfEvalResult.NewWarewolfAtomListresult(new WarewolfAtomList<DataASTMutable.WarewolfAtom>(DataASTMutable.WarewolfAtom.Nothing, atomList));
if (DataListUtil.IsFullyEvaluated(finalString))
{
_inputVariable = finalString;
_evalResult = environment.Eval(finalString);
}
}
else
{
var evalToExpression = environment.EvalToExpression(_inputVariable);
if (DataListUtil.IsEvaluated(evalToExpression))
{
_inputVariable = evalToExpression;
}
_evalResult = environment.Eval(_inputVariable);
}
}
catch(Exception e)
{
Dev2Logger.Log.Error(e.Message,e);
_evalResult = WarewolfDataEvaluationCommon.WarewolfEvalResult.NewWarewolfAtomResult(DataASTMutable.WarewolfAtom.Nothing);
}
}
protected override void AddItemsToIterator(IExecutionEnvironment environment,int update)
{
_archPassItr = new WarewolfIterator(environment.Eval(DecryptedArchivePassword,update));
ColItr.AddVariableToIterateOn(_archPassItr);
}
IEnumerable<string> BuildQueryFromTo(SharepointSearchTo sharepointSearchTo, IExecutionEnvironment env, ISharepointFieldTo sharepointFieldTo,int update)
{
var warewolfEvalResult = env.Eval(sharepointSearchTo.ValueToMatch, update);
var fieldType = sharepointFieldTo.GetFieldType();
if (sharepointSearchTo.SearchType == "In")
{
var startSearchTerm = string.Format("{0}<FieldRef Name=\"{1}\"></FieldRef>", SharepointSearchOptions.GetStartTagForSearchOption(sharepointSearchTo.SearchType), sharepointSearchTo.InternalName);
startSearchTerm+="<Values>";
if(warewolfEvalResult.IsWarewolfAtomListresult)
{
var listResult = warewolfEvalResult as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomListresult;
if (listResult != null)
{
foreach(var warewolfAtom in listResult.Item)
{
var valueString = warewolfAtom.ToString();
if (valueString.Contains(","))
{
var listOfValues = valueString.Split(',');
startSearchTerm = listOfValues.Select(listOfValue => CastWarewolfValueToCorrectType(listOfValue, sharepointFieldTo.Type)).Aggregate(startSearchTerm, (current, value) => current + string.Format("<Value Type=\"{0}\">{1}</Value>", fieldType, value));
}
else
{
var value = CastWarewolfValueToCorrectType(valueString, sharepointFieldTo.Type);
startSearchTerm += string.Format("<Value Type=\"{0}\">{1}</Value>", fieldType, value);
}
}
}
}else
{
var scalarResult = warewolfEvalResult as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
if(scalarResult!=null)
{
var valueString = scalarResult.Item.ToString();
if (valueString.Contains(","))
{
var listOfValues = valueString.Split(',');
startSearchTerm = listOfValues.Select(listOfValue => CastWarewolfValueToCorrectType(listOfValue, sharepointFieldTo.Type)).Aggregate(startSearchTerm, (current, value) => current + string.Format("<Value Type=\"{0}\">{1}</Value>", fieldType, value));
}
else
{
var value = CastWarewolfValueToCorrectType(valueString, sharepointFieldTo.Type);
startSearchTerm += string.Format("<Value Type=\"{0}\">{1}</Value>", fieldType, value);
}
}
}
startSearchTerm += "</Values>";
startSearchTerm += SharepointSearchOptions.GetEndTagForSearchOption(sharepointSearchTo.SearchType);
yield return startSearchTerm;
}
else
{
WarewolfIterator iterator = new WarewolfIterator(warewolfEvalResult);
while (iterator.HasMoreData())
{
yield return string.Format("{0}<FieldRef Name=\"{1}\"></FieldRef><Value Type=\"{2}\">{3}</Value>{4}", SharepointSearchOptions.GetStartTagForSearchOption(sharepointSearchTo.SearchType), sharepointSearchTo.InternalName, fieldType, CastWarewolfValueToCorrectType(iterator.GetNextValue(), sharepointFieldTo.Type), SharepointSearchOptions.GetEndTagForSearchOption(sharepointSearchTo.SearchType));
}
}
}
//MO - Changed : new ctor that accepts the new arguments
public ForEachBootstrapTO(enForEachType forEachType, string from, string to, string csvNumbers, string numberOfExecutes, string recordsetName, IExecutionEnvironment compiler, out ErrorResultTO errors, int update)
{
errors = new ErrorResultTO();
ForEachType = forEachType;
IIndexIterator localIndexIterator;
switch(forEachType)
{
case enForEachType.InRecordset:
var records = compiler.EvalRecordSetIndexes(recordsetName, update);
if (!compiler.HasRecordSet(recordsetName) )
{
errors.AddError("When selecting a recordset only valid recordsets can be used");
break;
}
localIndexIterator = new IndexListIndexIterator(records);
IndexIterator = localIndexIterator;
break;
case enForEachType.InRange:
if(string.IsNullOrWhiteSpace(@from))
{
errors.AddError("The from field can not be left empty.");
break;
}
if(string.IsNullOrWhiteSpace(to))
{
errors.AddError("The to field can not be left empty.");
break;
}
if(@from.Contains("(*)"))
{
errors.AddError("The Star notation is not accepted in the From field.");
break;
}
var evalledFrom = ExecutionEnvironment.WarewolfEvalResultToString( compiler.Eval(@from, update));
int intFrom;
if (!int.TryParse(evalledFrom, out intFrom) || intFrom < 1)
{
errors.AddError("From range must be a whole number from 1 onwards.");
break;
}
if(to.Contains("(*)"))
{
errors.AddError("The Star notation is not accepted in the To field.");
break;
}
var evalledTo= ExecutionEnvironment.WarewolfEvalResultToString( compiler.Eval(@to, update));
int intTo;
if (!int.TryParse(evalledTo, out intTo) || intTo < 1)
{
errors.AddError("To range must be a whole number from 1 onwards.");
break;
}
IndexList indexList;
if(intFrom > intTo)
{
indexList = new IndexList(new HashSet<int>(), 0) { MinValue = intFrom, MaxValue = intTo };
ReverseIndexIterator revIdxItr = new ReverseIndexIterator(new HashSet<int>(), 0) { IndexList = indexList };
IndexIterator = revIdxItr;
}
else
{
indexList = new IndexList(new HashSet<int>(), 0) { MinValue = intFrom, MaxValue = intTo };
localIndexIterator = new IndexIterator(new HashSet<int>(), 0) { IndexList = indexList };
IndexIterator = localIndexIterator;
}
break;
case enForEachType.InCSV:
var csvIndexedsItr = ExecutionEnvironment.WarewolfEvalResultToString( compiler.Eval(csvNumbers, update));
ErrorResultTO allErrors;
List<int> listOfIndexes = SplitOutCsvIndexes(csvIndexedsItr, out allErrors);
if(allErrors.HasErrors())
{
errors.MergeErrors(allErrors);
break;
}
ListIndexIterator listLocalIndexIterator = new ListIndexIterator(listOfIndexes);
ListOfIndex listOfIndex = new ListOfIndex(listOfIndexes);
listLocalIndexIterator.IndexList = listOfIndex;
IndexIterator = listLocalIndexIterator;
break;
default:
if(numberOfExecutes != null && numberOfExecutes.Contains("(*)"))
{
errors.AddError("The Star notation is not accepted in the Numbers field.");
break;
}
int intExNum;
var numOfExItr = ExecutionEnvironment.WarewolfEvalResultToString( compiler.Eval(numberOfExecutes, update));
if (!int.TryParse(numOfExItr, out intExNum))
{
errors.AddError("Number of executes must be a whole number from 1 onwards.");
}
IndexIterator = new IndexIterator(new HashSet<int>(), intExNum);
break;
}
}
