public void DataListTO_IgnoreColumnDirection_False_MapForInputOutput_ColumnIODirection_HasElements_True_HasGrandChild_ExpectSuccess()
{
//--------------------------Arrange-------------------------------
var dataList = new StringBuilder(
"<DataList>" +
"<Child0 ColumnIODirection='" + enDev2ColumnArgumentDirection.Input + "' IsJson='False'>content</Child0>" +
"<Child01 ColumnIODirection='" + enDev2ColumnArgumentDirection.Both + "' IsJson='False'>content</Child01>" +
"<Child011>child attribute content</Child011>" +
"<Child02 ColumnIODirection='" + enDev2ColumnArgumentDirection.Output + "' IsJson='False'>content</Child02>" +
"<Child03 ColumnIODirection='" + enDev2ColumnArgumentDirection.None + "' IsJson='False'>content</Child03>" +
"<Child1>content</Child1>" +
"<Child2>" +
"<Child3 ColumnIODirection='" + enDev2ColumnArgumentDirection.Both + "'>content</Child3>" +
"<Child4 ColumnIODirection='" + enDev2ColumnArgumentDirection.Input + "'>content</Child4>" +
"<Child5 ColumnIODirection='" + enDev2ColumnArgumentDirection.Output + "'>content</Child5>" +
"</Child2>" +
"</DataList>");
//--------------------------Act-----------------------------------
var dataListTo = new DataListTO(dataList.ToString(), false);
//--------------------------Assert--------------------------------
Assert.AreEqual(4, dataListTo.Inputs.Count);
Assert.AreEqual(4, dataListTo.Outputs.Count);
Assert.AreEqual("Child0", dataListTo.Inputs[0]);
Assert.AreEqual("Child01", dataListTo.Inputs[1]);
Assert.AreEqual("[[Child2(*).Child3]]", dataListTo.Inputs[2]);
Assert.AreEqual("[[Child2(*).Child4]]", dataListTo.Inputs[3]);
Assert.AreEqual("Child01", dataListTo.Outputs[0]);
Assert.AreEqual("Child02", dataListTo.Outputs[1]);
Assert.AreEqual("[[Child2(*).Child3]]", dataListTo.Outputs[2]);
Assert.AreEqual("[[Child2(*).Child5]]", dataListTo.Outputs[3]);
}
public void DataListTO_IgnoreColumnDirection_True_ExpectSuccess()
{
//--------------------------Arrange-------------------------------
var dataList = new StringBuilder(
"<DataList>" +
"<Child1>content</Child1>" +
"<Child2>" +
"<Child3>content</Child3>" +
"<Child4>content</Child4>" +
"<Child5>content</Child5>" +
"</Child2>" +
"</DataList>");
//--------------------------Act-----------------------------------
var dataListTo = new DataListTO(dataList.ToString(), true);
//--------------------------Assert--------------------------------
Assert.AreEqual(4, dataListTo.Inputs.Count);
Assert.AreEqual(0, dataListTo.Outputs.Count);
Assert.AreEqual("Child1", dataListTo.Inputs[0]);
Assert.AreEqual("[[Child2(*).Child3]]", dataListTo.Inputs[1]);
Assert.AreEqual("[[Child2(*).Child4]]", dataListTo.Inputs[2]);
Assert.AreEqual("[[Child2(*).Child5]]", dataListTo.Inputs[3]);
}
public static void UpdateEnvironmentFromInputPayload(IDSFDataObject dataObject, StringBuilder rawPayload, string dataList, int update)
{
string toLoad = DataListUtil.StripCrap(rawPayload.ToString()); // clean up the rubish ;)
if (toLoad.IsJSON())
{
XNode node = JsonConvert.DeserializeXNode(toLoad, "Root");
if (node == null)
{
return;
}
toLoad = node.ToString();
}
XmlDocument xDoc = new XmlDocument();
toLoad = string.Format("<Tmp{0}>{1}</Tmp{0}>", Guid.NewGuid().ToString("N"), toLoad);
xDoc.LoadXml(toLoad);
dataList = dataList.Replace("ADL>", "DataList>").Replace("root>", "DataList>");
if (xDoc.DocumentElement != null)
{
XmlNodeList children = xDoc.DocumentElement.ChildNodes;
var dataListTO = new DataListTO(dataList);
TryConvert(dataObject, children, dataListTO.Inputs, update);
}
}
public void DataListTO_IgnoreColumnDirection_False_MapForInputOutput_AllColumnIODirectionSet_IsJson_True_ExpectSuccess()
{
//--------------------------Arrange-------------------------------
var dataList = new StringBuilder(
"<DataList>" +
"<Child0 ColumnIODirection='" + enDev2ColumnArgumentDirection.Input + "' IsJson='True'>content</Child0>" +
"<Child01 ColumnIODirection='" + enDev2ColumnArgumentDirection.Both + "' IsJson='True'>content</Child01>" +
"<Child02 ColumnIODirection='" + enDev2ColumnArgumentDirection.Output + "' IsJson='True'>content</Child02>" +
"<Child03 ColumnIODirection='" + enDev2ColumnArgumentDirection.None + "' IsJson='True'>content</Child03>" +
"<Child1>content</Child1>" +
"<Child2>" +
"<Child3>content</Child3>" +
"<Child4>content</Child4>" +
"<Child5>content</Child5>" +
"</Child2>" +
"</DataList>");
//--------------------------Act-----------------------------------
var dataListTo = new DataListTO(dataList.ToString(), false);
//--------------------------Assert--------------------------------
Assert.AreEqual(2, dataListTo.Inputs.Count);
Assert.AreEqual(2, dataListTo.Outputs.Count);
Assert.AreEqual("Child0", dataListTo.Inputs[0]);
Assert.AreEqual("Child01", dataListTo.Inputs[1]);
Assert.AreEqual("Child01", dataListTo.Outputs[0]);
Assert.AreEqual("Child02", dataListTo.Outputs[1]);
}
public InternalServiceContainer(ServiceAction sa, IDSFDataObject dataObj, IWorkspace theWorkspace, IEsbChannel esbChannel, EsbExecuteRequest request, IEsbManagementServiceLocator managementServiceLocator = null)
: base(sa, dataObj, theWorkspace, esbChannel, request)
{
if (request.Args == null)
{
if (sa.DataListSpecification == null)
{
sa.DataListSpecification = new StringBuilder("<DataList></DataList>");
}
var dataListTo = new DataListTO(sa.DataListSpecification.ToString());
request.Args = new Dictionary <string, StringBuilder>();
foreach (var input in dataListTo.Inputs)
{
var warewolfEvalResult = dataObj.Environment.Eval(DataListUtil.AddBracketsToValueIfNotExist(input), 0);
if (warewolfEvalResult.IsWarewolfAtomResult)
{
var scalarResult = warewolfEvalResult as CommonFunctions.WarewolfEvalResult.WarewolfAtomResult;
if (scalarResult != null && !scalarResult.Item.IsNothing)
{
request.Args.Add(input, new StringBuilder(scalarResult.Item.ToString()));
}
}
}
}
_managementServiceLocator = managementServiceLocator ?? new EsbManagementServiceLocator();
}
public static void UpdateEnvironmentFromOutputPayload(IDSFDataObject dataObject, StringBuilder rawPayload, string dataList)
{
dataList = dataList.Replace("ADL>", "DataList>").Replace("root>", "DataList>");
var dataListTO = new DataListTO(dataList);
var outputs = dataListTO.Outputs;
TryUpdateEnviromentWithMappings(dataObject, rawPayload, outputs);
}
static JToken BuildParametersObject(string dataList)
{
JArray arrayObj = new JArray();
var dataListTo = new DataListTO(dataList);
var scalarInputs = dataListTo.Inputs.Where(s => !DataListUtil.IsValueRecordset(s));
foreach (var input in scalarInputs)
{
var inputObject = new JObject
{
{ "name", input },
{ "in", "query" },
{ "required", true },
{
"schema", new JObject
{
{ "type", "string" }
}
}
};
arrayObj.Add(inputObject);
}
var recSetInputs = dataListTo.Inputs.Where(DataListUtil.IsValueRecordset).ToList();
var groupedRecSets = recSetInputs.GroupBy(DataListUtil.ExtractRecordsetNameFromValue);
foreach (var groupedRecSet in groupedRecSets)
{
var recSetName = groupedRecSet.Key;
var propObject = BuildPropertyDefinition(groupedRecSet);
var recSchemaObject = new Schema
{
Type = "object",
Properties = propObject
};
var serializedSchema = JsonConvert.SerializeObject(recSchemaObject);
var deserializedSchema = JsonConvert.DeserializeObject(serializedSchema) as JToken;
var recObject = new JObject
{
{ "name", recSetName },
{ "in", "query" },
{ "required", true },
{ "schema", deserializedSchema }
};
arrayObj.Add(recObject);
}
var serialized = JsonConvert.SerializeObject(arrayObj);
var des = JsonConvert.DeserializeObject(serialized) as JToken;
var definitionObject = des;
return(definitionObject);
}
public void DataListTO_IgnoreColumnDirection_False_ExpectFail()
{
//--------------------------Arrange-------------------------------
var dataList = new StringBuilder(
"<DataList></DataList>");
//--------------------------Act-----------------------------------
var dataListTo = new DataListTO(dataList.ToString(), false);
//--------------------------Assert--------------------------------
Assert.AreEqual(0, dataListTo.Inputs.Count);
Assert.AreEqual(0, dataListTo.Outputs.Count);
}
public void DataListTO_Load()
{
const string expectedResult = @"<DataList><Car Description=""A recordset of information about a car"" IsEditable=""True"" ColumnIODirection=""Both"" ><Make Description=""Make of vehicle"" IsEditable=""True"" ColumnIODirection=""None"" /><Model Description=""Model of vehicle"" IsEditable=""True"" ColumnIODirection=""None"" /></Car><Country Description=""name of Country"" IsEditable=""True"" ColumnIODirection=""Both"" /><Person Description="""" IsEditable=""True"" IsJson=""True"" IsArray=""False"" ColumnIODirection=""None"" ><Age Description="""" IsEditable=""True"" IsJson=""True"" IsArray=""False"" ColumnIODirection=""None"" ></Age><Name Description="""" IsEditable=""True"" IsJson=""True"" IsArray=""False"" ColumnIODirection=""None"" ></Name><School Description="""" IsEditable=""True"" IsJson=""True"" IsArray=""False"" ColumnIODirection=""None"" ><Name Description="""" IsEditable=""True"" IsJson=""True"" IsArray=""False"" ColumnIODirection=""None"" ></Name><Location Description="""" IsEditable=""True"" IsJson=""True"" IsArray=""False"" ColumnIODirection=""None"" ></Location></School></Person></DataList>";
var dataList = new DataListTO(expectedResult, true);
Assert.AreEqual("Country", dataList.Inputs[0]);
Assert.AreEqual("[[Car(*).Make]]", dataList.Inputs[1]);
Assert.AreEqual("[[Car(*).Model]]", dataList.Inputs[2]);
Assert.AreEqual("[[Person(*).Age]]", dataList.Inputs[3]);
Assert.AreEqual("[[Person(*).Name]]", dataList.Inputs[4]);
Assert.AreEqual("[[Person(*).School]]", dataList.Inputs[5]);
Assert.AreEqual(6, dataList.Inputs.Count);
}
public static void UpdateEnvironmentFromOutputPayload(IDSFDataObject dataObject, StringBuilder rawPayload, string dataList)
{
string toLoad = DataListUtil.StripCrap(rawPayload.ToString()); // clean up the rubish ;)
XmlDocument xDoc = new XmlDocument();
toLoad = string.Format("<Tmp{0}>{1}</Tmp{0}>", Guid.NewGuid().ToString("N"), toLoad);
xDoc.LoadXml(toLoad);
dataList = dataList.Replace("ADL>", "DataList>").Replace("root>", "DataList>");
if (xDoc.DocumentElement != null)
{
XmlNodeList children = xDoc.DocumentElement.ChildNodes;
var dataListTO = new DataListTO(dataList);
TryConvert(dataObject, children, dataListTO.Outputs);
}
}
public static void UpdateEnvironmentFromXmlPayload(IDSFDataObject dataObject, StringBuilder rawPayload, string dataList, int update)
{
var toLoad = rawPayload.ToString().ToCleanXml(); // clean up the rubish ;)
var xDoc = new XmlDocument();
toLoad = string.Format("<Tmp{0:N}>{1}</Tmp{0:N}>", Guid.NewGuid(), toLoad);
xDoc.LoadXml(toLoad);
if (dataList != null)
{
dataList = dataList.Replace("ADL>", "DataList>").Replace("root>", "DataList>");
if (xDoc.DocumentElement != null)
{
var children = xDoc.DocumentElement.ChildNodes;
var dataListTO = new DataListTO(dataList, true);
TryConvert(dataObject, children, dataListTO.Inputs, update);
}
}
}
static JToken GetParametersDefinition(out List <JObject> parameters, string dataList, out bool isScalarInputOnly)
{
var dataListTO = new DataListTO(dataList);
var scalarInputs = dataListTO.Inputs.Where(s => !DataListUtil.IsValueRecordset(s));
var recSetInputs = dataListTO.Inputs.Where(DataListUtil.IsValueRecordset).ToList();
var scalarOutputs = dataListTO.Outputs.Where(s => !DataListUtil.IsValueRecordset(s));
var recSetOutputs = dataListTO.Outputs.Where(DataListUtil.IsValueRecordset);
parameters = null;
isScalarInputOnly = true;
var dataListSchema = new Dictionary <string, Schema>
{
{
"Output", new Schema
{
Type = "object",
Properties = BuildDefinition(scalarOutputs, recSetOutputs)
}
}
};
if (recSetInputs.Any())
{
dataListSchema.Add("DataList", new Schema
{
Type = "object",
Properties = BuildDefinition(scalarInputs, recSetInputs)
});
isScalarInputOnly = false;
}
else
{
parameters = scalarInputs.Select(scalarInput => new JObject
{
{ "name", scalarInput }, { "in", "query" }, { "required", true }, { "type", "string" }
}).ToList();
}
var serialized = JsonConvert.SerializeObject(dataListSchema);
var des = JsonConvert.DeserializeObject(serialized) as JToken;
var definitionObject = des;
return(definitionObject);
}
private static JToken BuildResponseSchema(string dataList)
{
var dataListTo = new DataListTO(dataList);
var scalarOutputs = dataListTo.Outputs.Where(s => !DataListUtil.IsValueRecordset(s));
var recSetOutputs = dataListTo.Outputs.Where(DataListUtil.IsValueRecordset);
var propertiesObject = scalarOutputs.ToDictionary(scalarInput => scalarInput, scalarInput => new Schema {
Type = "string"
});
var groupedRecSets = recSetOutputs.GroupBy(DataListUtil.ExtractRecordsetNameFromValue);
foreach (var groupedRecSet in groupedRecSets)
{
var recSetName = groupedRecSet.Key;
var propObject = BuildPropertyDefinition(groupedRecSet);
var recObject = new Schema
{
Type = "object",
Properties = propObject
};
propertiesObject.Add(recSetName, recObject);
}
var responseSchema = new Dictionary <string, Schema>
{
{
"schema", new Schema
{
Type = "object",
Properties = propertiesObject,
}
}
};
var serialized = JsonConvert.SerializeObject(responseSchema);
var definitionObject = JsonConvert.DeserializeObject(serialized) as JToken;
var res = definitionObject;
return(res);
}
public InternalServiceContainer(ServiceAction sa, IDSFDataObject dataObj, IWorkspace theWorkspace, IEsbChannel esbChannel, EsbExecuteRequest request)
: base(sa, dataObj, theWorkspace, esbChannel, request)
{
var dataListTO = new DataListTO(sa.DataListSpecification.ToString());
if (request.Args == null)
{
request.Args = new Dictionary <string, StringBuilder>();
foreach (var input in dataListTO.Inputs)
{
var warewolfEvalResult = dataObj.Environment.Eval(DataListUtil.AddBracketsToValueIfNotExist(input), 0, false);
if (warewolfEvalResult.IsWarewolfAtomResult)
{
var scalarResult = warewolfEvalResult as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
if (scalarResult != null && !scalarResult.Item.IsNothing)
{
request.Args.Add(input, new StringBuilder(scalarResult.Item.ToString()));
}
}
}
}
}
public static string GetXmlInputFromEnvironment(IDSFDataObject dataObject, Guid workspaceGuid, string dataList)
{
var environment = dataObject.Environment;
var dataListTO = new DataListTO(dataList);
StringBuilder result = new StringBuilder("<" + "DataList" + ">");
var scalarOutputs = dataListTO.Inputs.Where(s => !DataListUtil.IsValueRecordset(s));
var recSetOutputs = dataListTO.Inputs.Where(DataListUtil.IsValueRecordset);
var groupedRecSets = recSetOutputs.GroupBy(DataListUtil.ExtractRecordsetNameFromValue);
foreach (var groupedRecSet in groupedRecSets)
{
var i = 1;
var warewolfListIterators = new WarewolfListIterator();
Dictionary <string, IWarewolfIterator> iterators = new Dictionary <string, IWarewolfIterator>();
foreach (var name in groupedRecSet)
{
var warewolfIterator = new WarewolfIterator(environment.Eval(name));
iterators.Add(DataListUtil.ExtractFieldNameFromValue(name), warewolfIterator);
warewolfListIterators.AddVariableToIterateOn(warewolfIterator);
}
while (warewolfListIterators.HasMoreData())
{
result.Append("<");
result.Append(groupedRecSet.Key);
result.Append(string.Format(" Index=\"{0}\">", i));
foreach (var namedIterator in iterators)
{
var value = warewolfListIterators.FetchNextValue(namedIterator.Value);
result.Append("<");
result.Append(namedIterator.Key);
result.Append(">");
result.Append(value);
result.Append("</");
result.Append(namedIterator.Key);
result.Append(">");
}
result.Append("</");
result.Append(groupedRecSet.Key);
result.Append(">");
i++;
}
}
foreach (var output in scalarOutputs)
{
var evalResult = environment.Eval(DataListUtil.AddBracketsToValueIfNotExist(output));
if (evalResult.IsWarewolfAtomResult)
{
var scalarResult = evalResult as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
if (scalarResult != null && !scalarResult.Item.IsNothing)
{
result.Append("<");
result.Append(output);
result.Append(">");
result.Append(scalarResult.Item);
result.Append("</");
result.Append(output);
result.Append(">");
}
}
}
result.Append("</" + "DataList" + ">");
return(result.ToString());
}
public static string GetXmlOutputFromEnvironment(IDSFDataObject dataObject, string dataList, int update)
{
var environment = dataObject.Environment;
var dataListTO = new DataListTO(dataList);
StringBuilder result = new StringBuilder("<DataList>");
var scalarOutputs = dataListTO.Outputs.Where(s => !DataListUtil.IsValueRecordset(s));
var recSetOutputs = dataListTO.Outputs.Where(DataListUtil.IsValueRecordset);
var groupedRecSets = recSetOutputs.GroupBy(DataListUtil.ExtractRecordsetNameFromValue);
foreach (var groupedRecSet in groupedRecSets)
{
var i = 1;
var warewolfListIterators = new WarewolfListIterator();
Dictionary <string, IWarewolfIterator> iterators = new Dictionary <string, IWarewolfIterator>();
foreach (var name in groupedRecSet)
{
var warewolfEvalResult = WarewolfDataEvaluationCommon.WarewolfEvalResult.NewWarewolfAtomResult(DataASTMutable.WarewolfAtom.Nothing);
try
{
warewolfEvalResult = environment.Eval(name, update, false);
}
// ReSharper disable once RESP510236
// ReSharper disable once RESP510241
catch (Exception e)
{
Dev2Logger.Log.Debug("Null Variable", e);
}
var warewolfIterator = new WarewolfIterator(warewolfEvalResult);
iterators.Add(DataListUtil.ExtractFieldNameFromValue(name), warewolfIterator);
warewolfListIterators.AddVariableToIterateOn(warewolfIterator);
}
while (warewolfListIterators.HasMoreData())
{
result.Append("<");
result.Append(groupedRecSet.Key);
result.Append(string.Format(" Index=\"{0}\">", i));
foreach (var namedIterator in iterators)
{
try
{
var value = warewolfListIterators.FetchNextValue(namedIterator.Value);
result.Append("<");
result.Append(namedIterator.Key);
result.Append(">");
result.Append(value);
result.Append("</");
result.Append(namedIterator.Key);
result.Append(">");
}
catch (Exception e)
{
Dev2Logger.Log.Debug(e.Message, e);
}
}
result.Append("</");
result.Append(groupedRecSet.Key);
result.Append(">");
i++;
}
}
foreach (var output in scalarOutputs)
{
var evalResult = environment.Eval(DataListUtil.AddBracketsToValueIfNotExist(output), update, false);
if (evalResult.IsWarewolfAtomResult)
{
var scalarResult = evalResult as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
if (scalarResult != null && !scalarResult.Item.IsNothing)
{
result.Append("<");
result.Append(output);
result.Append(">");
result.Append(scalarResult.Item);
result.Append("</");
result.Append(output);
result.Append(">");
}
}
}
result.Append("</DataList>");
return(result.ToString());
}
public static string GetJsonOutputFromEnvironment(IDSFDataObject dataObject, Guid workspaceGuid, string dataList)
{
var environment = dataObject.Environment;
var dataListTO = new DataListTO(dataList);
StringBuilder result = new StringBuilder("{");
var keyCnt = 0;
var scalarOutputs = dataListTO.Outputs.Where(s => !DataListUtil.IsValueRecordset(s));
var recSetOutputs = dataListTO.Outputs.Where(DataListUtil.IsValueRecordset);
var groupedRecSets = recSetOutputs.GroupBy(DataListUtil.ExtractRecordsetNameFromValue);
var recSets = groupedRecSets as IGrouping <string, string>[] ?? groupedRecSets.ToArray();
foreach (var groupedRecSet in recSets)
{
var i = 0;
var warewolfListIterators = new WarewolfListIterator();
Dictionary <string, IWarewolfIterator> iterators = new Dictionary <string, IWarewolfIterator>();
foreach (var name in groupedRecSet)
{
var warewolfIterator = new WarewolfIterator(environment.Eval(name));
iterators.Add(DataListUtil.ExtractFieldNameFromValue(name), warewolfIterator);
warewolfListIterators.AddVariableToIterateOn(warewolfIterator);
}
result.Append("\"");
result.Append(groupedRecSet.Key);
result.Append("\" : [");
while (warewolfListIterators.HasMoreData())
{
int colIdx = 0;
result.Append("{");
foreach (var namedIterator in iterators)
{
var value = warewolfListIterators.FetchNextValue(namedIterator.Value);
result.Append("\"");
result.Append(namedIterator.Key);
result.Append("\":\"");
result.Append(value);
result.Append("\"");
colIdx++;
if (colIdx < iterators.Count)
{
result.Append(",");
}
}
if (warewolfListIterators.HasMoreData())
{
result.Append("}");
result.Append(",");
}
}
result.Append("}");
result.Append("]");
i++;
if (i < recSets.Count())
{
result.Append(",");
}
}
var scalars = scalarOutputs as string[] ?? scalarOutputs.ToArray();
foreach (var output in scalars)
{
var evalResult = environment.Eval(DataListUtil.AddBracketsToValueIfNotExist(output));
if (evalResult.IsWarewolfAtomResult)
{
var scalarResult = evalResult as WarewolfDataEvaluationCommon.WarewolfEvalResult.WarewolfAtomResult;
if (scalarResult != null && !scalarResult.Item.IsNothing)
{
result.Append("\"");
result.Append(output);
result.Append("\":\"");
result.Append(scalarResult.Item);
result.Append("\"");
}
}
keyCnt++;
if (keyCnt < scalars.Count())
{
result.Append(",");
}
}
var jsonOutputFromEnvironment = result.ToString();
jsonOutputFromEnvironment += "}";
return(jsonOutputFromEnvironment);
}
