void SetupScalarResult(WarewolfDataEvaluationCommon.WarewolfEvalResult warewolfEvalResult)
{
if(warewolfEvalResult.IsWarewolfAtomResult)
{
_scalarResult = warewolfEvalResult as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
}
}
void SetupForWarewolfRecordSetResult(WarewolfDataEvaluationCommon.WarewolfEvalResult warewolfEvalResult)
{
if(warewolfEvalResult.IsWarewolfRecordSetResult)
{
var listResult = warewolfEvalResult as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfRecordSetResult;
if(listResult != null)
{
var stringValue = "";
foreach(var item in listResult.Item.Data)
{
if(item.Key != WarewolfDataEvaluationCommon.PositionColumn)
{
var data = WarewolfDataEvaluationCommon.WarewolfEvalResult.NewWarewolfAtomListresult(item.Value) as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomListresult;
var warewolfEvalResultToString = ExecutionEnvironment.WarewolfEvalResultToString(data);
if(string.IsNullOrEmpty(stringValue))
{
stringValue = warewolfEvalResultToString;
}
else
{
stringValue += "," + warewolfEvalResultToString;
}
}
}
_scalarResult = WarewolfDataEvaluationCommon.WarewolfEvalResult.NewWarewolfAtomResult(DataASTMutable.WarewolfAtom.NewDataString(stringValue)) as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public WarewolfIterator(WarewolfDataEvaluationCommon.WarewolfEvalResult warewolfEvalResult)
{
SetupListResult(warewolfEvalResult);
SetupScalarResult(warewolfEvalResult);
SetupForWarewolfRecordSetResult(warewolfEvalResult);
_maxValue = _listResult != null ? _listResult.Item.Count(atom => atom!=null) : 1;
_currentValue = 0;
}
void SetupListResult(WarewolfDataEvaluationCommon.WarewolfEvalResult warewolfEvalResult)
{
if(warewolfEvalResult.IsWarewolfAtomListresult)
{
var warewolfAtomListresult = warewolfEvalResult as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomListresult;
if(warewolfAtomListresult != null)
{
warewolfAtomListresult.Item.ResetCurrentEnumerator();
_listResult = warewolfAtomListresult;
}
}
}
public DebugItemWarewolfAtomListResult(WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomListresult warewolfAtomListresult, WarewolfDataEvaluationCommon.WarewolfEvalResult oldResult, string assignedToVariableName, string variable, string leftLabelText, string rightLabelText, string operand)
{
_labelText = "";
_operand = operand;
_variable = variable;
_type = DebugItemResultType.Variable;
_rightLabel = rightLabelText;
_leftLabel = leftLabelText;
_warewolfAtomListresult = warewolfAtomListresult;
_oldValue = oldResult;
_assignedToVariableName = assignedToVariableName;
}
public void AssignEvaluation_AddProperty_AddNothing_ExpectSuccess()
{
//------------Setup for test--------------------------
JObject j = new JObject();
//------------Execute Test---------------------------
// ReSharper disable once RedundantAssignment
var obj = WarewolfDataEvaluationCommon.addAtomicPropertyToJson(j, "Name", DataStorage.WarewolfAtom.Nothing);
var result = obj.ToString();
//------------Assert Results-------------------------
Assert.AreEqual(@"{
""Name"": null
}", result);
}
object GetEvalResult(WarewolfDataEvaluationCommon.WarewolfEvalResult evalResult, int i)
{
if (evalResult.IsWarewolfAtomListresult)
{
WarewolfAtomList <DataASTMutable.WarewolfAtom> lst = ((WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomListresult)evalResult).Item;
if (i > lst.Count)
{
return(null);
}
return(WarewolfDataEvaluationCommon.AtomToJsonCompatibleObject(lst[i]));
}
if (evalResult.IsWarewolfAtomResult)
{
if (i == 0)
{
return(WarewolfDataEvaluationCommon.EvalResultToJsonCompatibleObject(evalResult));
}
return(null);
}
if (evalResult.IsWarewolfRecordSetResult)
{
DataASTMutable.WarewolfRecordset recset = ((WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfRecordSetResult)EvalResult).Item;
KeyValuePair <string, WarewolfAtomList <DataASTMutable.WarewolfAtom> >[] data = recset.Data.ToArray();
var jObjects = new List <JObject>();
for (int j = 0; j < recset.Count; j++)
{
var a = new JObject();
foreach (KeyValuePair <string, WarewolfAtomList <DataASTMutable.WarewolfAtom> > pair in data)
{
if (pair.Key != WarewolfDataEvaluationCommon.PositionColumn)
{
try
{
a.Add(new JProperty(pair.Key, WarewolfDataEvaluationCommon.AtomToJsonCompatibleObject(pair.Value[j])));
}
catch (Exception)
{
a.Add(new JProperty(pair.Key, null));
}
}
}
jObjects.Add(a);
}
return(jObjects);
}
throw new Exception("Invalid result type was encountered from warewolfstorage");
}
public static string GetPositionColumnExpression(string recordset)
{
var rec = WarewolfDataEvaluationCommon.ParseLanguageExpression(recordset, 0);
if (rec.IsRecordSetExpression)
{
var index = (rec as LanguageAST.LanguageExpression.RecordSetExpression).Item;
return("[[" + index.Name + "(" + "*" + ")." + WarewolfDataEvaluationCommon.PositionColumn + "]]");
}
if (rec.IsRecordSetNameExpression)
{
var index = (rec as LanguageAST.LanguageExpression.RecordSetNameExpression).Item;
return("[[" + index.Name + "(" + "*" + ")." + WarewolfDataEvaluationCommon.PositionColumn + "]]");
}
return(recordset);
}
public void AssignEvaluation_AddProperty_AddAtom_AlreadyExist_ExpectSuccess()
{
//------------Setup for test--------------------------
var j = new JObject();
//------------Execute Test---------------------------
var obj = WarewolfDataEvaluationCommon.addAtomicPropertyToJson(j, "Name", DataStorage.WarewolfAtom.NewDataString("a"));
obj = WarewolfDataEvaluationCommon.addAtomicPropertyToJson(j, "Name", DataStorage.WarewolfAtom.NewDataString("x"));
var result = obj.ToString();
//------------Assert Results-------------------------
Assert.AreEqual(@"{
""Name"": ""x""
}", result);
}
public static bool IsValidVariableExpression(string expression, out string errorMessage, int update)
{
errorMessage = "";
try
{
var x = WarewolfDataEvaluationCommon.ParseLanguageExpression(expression, update);
if (x.IsRecordSetExpression || x.IsScalarExpression)
{
return(true);
}
}
catch (Exception e)
{
errorMessage = e.Message;
return(false);
}
return(false);
}
public static string ValidateInput(string sourceName)
{
try
{
var parsed = WarewolfDataEvaluationCommon.ParseLanguageExpression(sourceName, 0);
if (parsed.IsComplexExpression)
{
var complex = (LanguageAST.LanguageExpression.ComplexExpression)parsed;
if (complex.Item
.Any(x => x.IsRecordSetNameExpression))
{
return("Cannot specify a Recordset as part of a comma seperated list of expressions");
}
if (complex.Item.Count() < 3 ||
complex.Item.Count() % 2 != 1 ||
// ReSharper disable MaximumChainedReferences
!Enumerable.Range(1, complex.Item.Count() - 1)
.Where(i => i % 2 == 1)
.Select(i =>
WarewolfDataEvaluationCommon.LanguageExpressionToString(
complex.Item.ElementAt(i)
) == ",")
.Aggregate((a, b) => a && b))
// ReSharper restore MaximumChainedReferences
{
return("Problem with input: expressions must be comma seperated");
}
}
else if (!parsed.IsRecordSetNameExpression &&
!parsed.IsRecordSetExpression &&
!parsed.IsScalarExpression &&
!parsed.IsWarewolfAtomAtomExpression)
{
return("Can only have a scalar, a RecordSet or a RecordSet with column qualification as input");
}
}
catch (Exception)
{
return("Unable to parse the Source Name");
}
return(null);
}
public void AssignEvaluation_AddProperty_AddArray_Exists_ExpectSuccess()
{
//------------Setup for test--------------------------
JObject j = new JObject();
//------------Execute Test---------------------------
// ReSharper disable once RedundantAssignment
var obj = WarewolfDataEvaluationCommon.addArrayPropertyToJson(j, "Name", new List <DataStorage.WarewolfAtom> {
DataStorage.WarewolfAtom.NewDataString("a"), DataStorage.WarewolfAtom.NewDataString("b")
});
obj = WarewolfDataEvaluationCommon.addArrayPropertyToJson(j, "Name", new List <DataStorage.WarewolfAtom> {
DataStorage.WarewolfAtom.NewDataString("x"), DataStorage.WarewolfAtom.NewDataString("y")
});
var result = obj.ToString();
//------------Assert Results-------------------------
Assert.AreEqual("{\r\n \"Name\": [\r\n \"x\",\r\n \"y\"\r\n ]\r\n}", result);
}
public void CreateJSONAndEvalPartialObject()
{
//------------Setup for test--------------------------
var createDataSet = WarewolfTestData.CreateTestEnvWithData;
var j = JObject.FromObject(new Person()
{
Name = "n", Children = new List <Person>()
});
var added = WarewolfDataEvaluationCommon.addToJsonObjects(createDataSet, "bob", j);
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.IsTrue(added.JsonObjects.ContainsKey("bob"));
Assert.AreEqual((added.JsonObjects["bob"] as JObject).GetValue("Name").ToString(), "n");
var evalled = CommonFunctions.evalResultToString(EvaluationFunctions.eval(added, 0, false, "[[@bob.Name]]"));
Assert.AreEqual(evalled, "n");
}
public string ToLast(string rawValue)
{
var output = WarewolfDataEvaluationCommon.ParseLanguageExpression(rawValue);
if (output.IsRecordSetExpression)
{
var outputidentifier = (output as LanguageAST.LanguageExpression.RecordSetExpression).Item;
var i = GetLength(outputidentifier.Name);
return("[[" + outputidentifier.Name + "(" + i + ")." + outputidentifier.Column + "]]");
}
if (output.IsRecordSetExpression)
{
var outputidentifier = (output as LanguageAST.LanguageExpression.RecordSetNameExpression).Item;
var i = GetLength(outputidentifier.Name);
if (Equals(outputidentifier.Index, LanguageAST.Index.Star))
{
return("[[" + outputidentifier.Name + "(" + i + ") " + "]]");
}
}
return(rawValue);
}
public string ToStar(string expression)
{
var exp = WarewolfDataEvaluationCommon.ParseLanguageExpression(expression, 0);
if (exp.IsRecordSetExpression)
{
var rec = exp as LanguageAST.LanguageExpression.RecordSetExpression;
if (rec != null)
{
return("[[" + rec.Item.Name + "(*)." + rec.Item.Column + "]]");
}
}
if (exp.IsRecordSetNameExpression)
{
var rec = exp as LanguageAST.LanguageExpression.RecordSetNameExpression;
if (rec != null)
{
return("[[" + rec.Item.Name + "(*)" + "]]");
}
}
return(expression);
}
public void CreateJSONAndEvalEntireObject()
{
//------------Setup for test--------------------------
var createDataSet = WarewolfTestData.CreateTestEnvWithData;
var j = JObject.FromObject(new Person()
{
Name = "n", Children = new List <Person>()
});
var added = WarewolfDataEvaluationCommon.addToJsonObjects(createDataSet, "bob", j);
//------------Execute Test---------------------------
//------------Assert Results-------------------------
Assert.IsTrue(added.JsonObjects.ContainsKey("bob"));
Assert.AreEqual((added.JsonObjects["bob"] as JObject).GetValue("Name").ToString(), "n");
var evalled = EvaluationFunctions.eval(added, 0, false, "[[@bob]]");
Assert.IsTrue(evalled.IsWarewolfAtomResult);
var res = (evalled as CommonFunctions.WarewolfEvalResult.WarewolfAtomResult).Item;
var str = (res as DataStorage.WarewolfAtom.DataString).ToString();
Assert.AreEqual(str, j.ToString());
}
public JsonMappingCompoundTo(
IExecutionEnvironment env,
JsonMappingTo compound)
{
_env = env;
Compound = compound;
Evaluations = new List <JsonMappingEvaluated>();
if (!IsCompound)
{
Evaluations.Add(new JsonMappingEvaluated(_env, compound.SourceName));
}
else
{
if (WarewolfDataEvaluationCommon.ParseLanguageExpression(Compound.SourceName, 0).IsRecordSetNameExpression)
{
Evaluations = new List <JsonMappingEvaluated> {
new JsonMappingEvaluated(_env, Compound.SourceName)
};
}
else
{
// we know this is a comma seperated list of expressions
Evaluations =
// ReSharper disable MaximumChainedReferences
((LanguageAST.LanguageExpression.ComplexExpression)WarewolfDataEvaluationCommon.ParseLanguageExpression(Compound.SourceName, 0))
.Item
.Where(x => !x.IsWarewolfAtomAtomExpression)
.Select(WarewolfDataEvaluationCommon.LanguageExpressionToString)
.Select(x =>
new JsonMappingEvaluated(_env, x))
.ToList();
} // ReSharper restore MaximumChainedReferences
}
}
object GetEvalResult(WarewolfDataEvaluationCommon.WarewolfEvalResult evalResult, int i)
{
if (evalResult.IsWarewolfAtomListresult)
{
WarewolfAtomList<DataASTMutable.WarewolfAtom> lst = ((WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomListresult)evalResult).Item;
if (i > lst.Count)
{
return null;
}
return WarewolfDataEvaluationCommon.AtomToJsonCompatibleObject(lst[i]);
}
if (evalResult.IsWarewolfAtomResult)
{
if (i == 0)
{
return WarewolfDataEvaluationCommon.EvalResultToJsonCompatibleObject(evalResult);
}
return null;
}
if (evalResult.IsWarewolfRecordSetResult)
{
DataASTMutable.WarewolfRecordset recset = ((WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfRecordSetResult)EvalResult).Item;
KeyValuePair<string, WarewolfAtomList<DataASTMutable.WarewolfAtom>>[] data = recset.Data.ToArray();
var jObjects = new List<JObject>();
for (int j = 0; j < recset.Count; j++)
{
var a = new JObject();
foreach (KeyValuePair<string, WarewolfAtomList<DataASTMutable.WarewolfAtom>> pair in data)
{
if (pair.Key != WarewolfDataEvaluationCommon.PositionColumn)
{
try
{
a.Add(new JProperty(pair.Key, WarewolfDataEvaluationCommon.AtomToJsonCompatibleObject(pair.Value[j])));
}
catch (Exception)
{
a.Add(new JProperty(pair.Key, null));
}
}
}
jObjects.Add(a);
}
return jObjects;
}
throw new Exception("Invalid result type was encountered from warewolfstorage");
}
public static bool IsNothing(WarewolfDataEvaluationCommon.WarewolfEvalResult evalInp1)
{
return WarewolfDataEvaluationCommon.IsNothing(evalInp1);
}
public void EvalAssignFromNestedNumeric(string exp, WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomListresult recsetResult)
{
if( recsetResult.Item.Any())
AssignWithFrame(new AssignValue(exp, WarewolfAtomToString(recsetResult.Item.Last())));
}
public void EvalAssignFromNestedLast(string exp, WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomListresult recsetResult,int startIndex)
{
bool exists = PublicFunctions.RecordsetExpressionExists(exp, _env);
if (!exists)
exp = ToStar(exp);
AssignWithFrameAndList(exp, recsetResult.Item, exists);
}
public void EvalAssignFromNestedStar(string exp, WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomListresult recsetResult)
{
AssignWithFrameAndList(exp, recsetResult.Item, false);
}
public static string WarewolfEvalResultToString(WarewolfDataEvaluationCommon.WarewolfEvalResult result)
{
if (result.IsWarewolfAtomResult)
{
// ReSharper disable PossibleNullReferenceException
var warewolfAtomResult = result as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
if(warewolfAtomResult != null)
{
var x = warewolfAtomResult.Item;
if (x.IsNothing) return null;
// ReSharper restore PossibleNullReferenceException
return WarewolfAtomToString(x);
}
throw new Exception("null when f# said it should not be");
}
// ReSharper disable RedundantIfElseBlock
else
// ReSharper restore RedundantIfElseBlock
{
// ReSharper disable PossibleNullReferenceException
var warewolfAtomListresult = result as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomListresult;
if(warewolfAtomListresult != null)
{
var x = warewolfAtomListresult.Item;
StringBuilder res = new StringBuilder();
for(int index = 0; index < x.Count; index++)
{
var warewolfAtom = x[index];
if(index==x.Count-1)
{
res.Append(warewolfAtom);
}
else
{
res.Append(warewolfAtom).Append(",");
}
}
return res.ToString();
}
throw new Exception("null when f# said it should not be");
}
}
public void AddToJsonObjects(string exp, JContainer jContainer)
{
_env = WarewolfDataEvaluationCommon.addToJsonObjects(_env, exp, jContainer);
}
public static bool IsNothing(WarewolfDataEvaluationCommon.WarewolfEvalResult evalInp1)
{
return(WarewolfDataEvaluationCommon.IsNothing(evalInp1));
}
public string EvalToExpression(string exp, int update)
{
return(string.IsNullOrEmpty(exp) ? "" : WarewolfDataEvaluationCommon.EvalToExpression(_env, update, exp));
}
protected override void ExecuteTool(IDSFDataObject dataObject, int update)
{
_debugOutputs.Clear();
_debugInputs.Clear();
if (WebRequestInvoker == null)
{
return;
}
var allErrors = new ErrorResultTO();
InitializeDebug(dataObject);
try
{
allErrors.MergeErrors(errorsTo);
if (dataObject.IsDebugMode())
{
DebugItem debugItem = new DebugItem();
AddDebugItem(new DebugEvalResult(Url, "URL", dataObject.Environment, update), debugItem);
_debugInputs.Add(debugItem);
}
var colItr = new WarewolfListIterator();
var urlitr = new WarewolfIterator(dataObject.Environment.Eval(Url, update));
var headerItr = new WarewolfIterator(dataObject.Environment.Eval(Headers, update));
colItr.AddVariableToIterateOn(urlitr);
colItr.AddVariableToIterateOn(headerItr);
while (colItr.HasMoreData())
{
var c = colItr.FetchNextValue(urlitr);
var headerValue = colItr.FetchNextValue(headerItr);
var headers = string.IsNullOrEmpty(headerValue)
? new string[0]
: headerValue.Split(new[] { '\n', '\r', ';' }, StringSplitOptions.RemoveEmptyEntries);
var headersEntries = new List <Tuple <string, string> >();
foreach (var header in headers)
{
var headerSegments = header.Split(':');
headersEntries.Add(new Tuple <string, string>(headerSegments[0], headerSegments[1]));
if (dataObject.IsDebugMode())
{
DebugItem debugItem = new DebugItem();
AddDebugItem(new DebugEvalResult(Headers, "Header", dataObject.Environment, update), debugItem);
_debugInputs.Add(debugItem);
}
}
bool timeoutSecondsError = false;
if (!string.IsNullOrEmpty(TimeOutText))
{
int timeoutval;
if (int.TryParse(WarewolfDataEvaluationCommon.EvalResultToString(dataObject.Environment.Eval(TimeOutText, update)), out timeoutval))
{
if (timeoutval < 0)
{
allErrors.AddError(string.Format("Value of TimeoutSecondsText out of range: please specify a value between 0 and {0}.", int.MaxValue));
timeoutSecondsError = true;
}
else
{
TimeoutSeconds = timeoutval;
}
}
else
{
allErrors.AddError(string.Format("Value {0} for TimeoutSecondsText could not be interpreted as a numeric value.", TimeOutText));
timeoutSecondsError = true;
}
if (dataObject.IsDebugMode())
{
DebugItem debugItem = new DebugItem();
AddDebugItem(new DebugEvalResult(String.IsNullOrEmpty(TimeOutText) ? "100" : TimeOutText, "Time Out Seconds", dataObject.Environment, update), debugItem);
_debugInputs.Add(debugItem);
}
}
if (!timeoutSecondsError)
{
var result = WebRequestInvoker.ExecuteRequest(Method,
c,
headersEntries, (TimeoutSeconds == 0 ? Timeout.Infinite : TimeoutSeconds * 1000) // important to list the parameter name here to see the conversion from seconds to milliseconds
);
allErrors.MergeErrors(errorsTo);
PushResultsToDataList(Result, result, dataObject, update);
}
else
{
throw new ApplicationException("Execution aborted - see error messages.");
}
}
}
catch (Exception e)
{
Dev2Logger.Log.Error("DSFWebGetRequest", e);
allErrors.AddError(e.Message);
}
finally
{
if (allErrors.HasErrors())
{
DisplayAndWriteError("DsfWebGetRequestActivity", allErrors);
var errorString = allErrors.MakeDisplayReady();
dataObject.Environment.AddError(errorString);
var expression = GetExpression(1);
PushResultsToDataList(expression, null, dataObject, update);
}
if (dataObject.IsDebugMode())
{
DispatchDebugState(dataObject, StateType.Before, update);
DispatchDebugState(dataObject, StateType.After, update);
}
}
}
public IEnumerable <WarewolfDataEvaluationCommon.WarewolfEvalResult> EvalForDataMerge(string exp, int update)
{
return(WarewolfDataEvaluationCommon.EvalForDataMerge(_env, update, exp));
}
