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