public bool Invoke(string[] cols)
{
var data = DataListUtil.AdjustForEncodingIssues(cols[0]);
bool isFragment;
var isXml = DataListUtil.IsXml(data, out isFragment);
return isXml || isFragment;
}
public void DataListUtil_AdjustForEncodingIssues_WithStringLengthOf3_SameDataAsPassedIn()
{
//------------Setup for test--------------------------
const string startingData = "A A";
//------------Execute Test---------------------------
string result = DataListUtil.AdjustForEncodingIssues(startingData);
//------------Assert Results-------------------------
Assert.AreEqual(startingData, result, "The data has changed when there was no encoding issues.");
}
public void DataListUtil_AdjustForEncodingIssues_BOMRemoved()
{
//------------Setup for test--------------------------
const char c = ((char)65279);
string startingData = c + "<A></A>";
Assert.IsFalse(startingData.StartsWith("<", StringComparison.OrdinalIgnoreCase));
//------------Execute Test---------------------------
string result = DataListUtil.AdjustForEncodingIssues(startingData);
//------------Assert Results-------------------------
Assert.IsTrue(result.StartsWith("<"));
}
/// <summary>
/// Executes the X path.
/// </summary>
/// <param name="xmlData">The XML data.</param>
/// <param name="xPath">The x path.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">
/// xmlData
/// or
/// xPath
/// </exception>
/// <exception cref="System.Exception">
/// Input XML is not valid.
/// or
/// The XPath expression provided is not valid.
/// </exception>
public IEnumerable <string> ExecuteXPath(string xmlData, string xPath)
{
if (String.IsNullOrEmpty(xmlData))
{
throw new ArgumentNullException("xmlData");
}
if (String.IsNullOrEmpty(xPath))
{
throw new ArgumentNullException("xPath");
}
try
{
bool isFragment;
var useXmlData = DataListUtil.AdjustForEncodingIssues(xmlData);
var isXml = DataListUtil.IsXml(useXmlData, out isFragment);
if (!isXml && !isFragment)
{
throw new Exception("Input XML is not valid.");
}
using (TextReader stringReader = new StringReader(useXmlData))
{
XmlReaderSettings settings = new XmlReaderSettings
{
IgnoreWhitespace = true,
DtdProcessing = DtdProcessing.Ignore,
ConformanceLevel = ConformanceLevel.Auto
};
using (XmlTextReader xtr = new XmlTextReader(stringReader))
{
xtr.Namespaces = false;
using (XmlReader reader = XmlReader.Create(xtr, settings))
{
reader.Read();
if (reader.NodeType == XmlNodeType.XmlDeclaration || reader.NodeType == XmlNodeType.Whitespace)
{
reader.Skip();
// handle DocumentType nodes
if (reader.NodeType == XmlNodeType.DocumentType)
{
reader.Skip();
}
// skip white space ;)
while (reader.Value.IndexOf("\n", StringComparison.Ordinal) >= 0 || reader.NodeType == XmlNodeType.Comment)
{
reader.Skip();
}
}
if (xPath.StartsWith("/" + reader.Name) || xPath.StartsWith("//" + reader.Name))
{
xPath = xPath.Replace("/" + reader.Name, "");
}
else if (xPath.StartsWith(reader.Name))
{
xPath = xPath.Replace(reader.Name, "/");
}
XNode xNode = XNode.ReadFrom(reader);
IEnumerable <object> xdmValue = xNode.XPath2Select(xPath);
var list = xdmValue.Select(element =>
{
var realElm = element as XObject;
if (realElm != null && realElm.NodeType == XmlNodeType.Attribute)
{
var xAttribute = realElm as XAttribute;
if (xAttribute != null)
{
return(xAttribute.Value);
}
}
return(element.ToString());
}).ToList();
return(list);
}
}
}
}
catch (Exception exception)
{
if (exception.GetType() == typeof(XPath2Exception))
{
throw new Exception("The XPath expression provided is not valid.");
}
Dev2Logger.Log.Error(exception);
throw;
}
}
public IEnumerable <string> ExecuteXPath(string xmlData, string xPath)
{
if (string.IsNullOrEmpty(xmlData))
{
throw new ArgumentNullException(nameof(xmlData));
}
if (string.IsNullOrEmpty(xPath))
{
throw new ArgumentNullException(nameof(xPath));
}
try
{
var useXmlData = DataListUtil.AdjustForEncodingIssues(xmlData);
var isXml = DataListUtil.IsXml(useXmlData, out bool isFragment);
if (!isXml && !isFragment)
{
throw new Exception("Input XML is not valid.");
}
List <string> stringList;
var document = new XmlDocument();
document.LoadXml(useXmlData);
var namespaces = new List <KeyValuePair <string, string> >();
if (document.DocumentElement != null)
{
namespaces = AddAttributesAsNamespaces(document, namespaces);
}
using (TextReader stringReader = new StringReader(useXmlData))
{
var processor = new Processor(false);
var compiler = processor.NewXPathCompiler();
compiler.XPathLanguageVersion = "3.0";
foreach (var keyValuePair in namespaces)
{
compiler.DeclareNamespace(keyValuePair.Key, keyValuePair.Value);
}
var xPathExecutable = compiler.Compile(xPath);
var xPathSelector = xPathExecutable.Load();
var newDocumentBuilder = processor.NewDocumentBuilder();
newDocumentBuilder.BaseUri = new Uri("http://warewolf.io");
newDocumentBuilder.WhitespacePolicy = WhitespacePolicy.StripAll;
var xdmNode = newDocumentBuilder.Build(stringReader);
xPathSelector.ContextItem = xdmNode;
var xdmValue = xPathSelector.Evaluate();
var list = xdmValue.GetEnumerator();
stringList = BuildListFromXPathResult(list);
}
return(stringList);
}
catch (Exception exception)
{
if (exception.GetType() == typeof(SAXException))
{
throw new Exception(ErrorResource.XPathProvidedNotValid);
}
Dev2Logger.Error(exception, GlobalConstants.WarewolfError);
throw;
}
}
static void WriteDebugItems(string workflowName, string taskName, string result)
{
var user = Thread.CurrentPrincipal.Identity.Name.Replace("\\", "-");
var state = new DebugState
{
HasError = result.Contains("Exception"),
ID = Guid.NewGuid(),
StartTime = StartTime,
EndTime = DateTime.Now,
ActivityType = ActivityType.Workflow,
ExecutingUser = user,
Server = "localhost",
ServerID = Guid.Empty,
DisplayName = workflowName
};
if (!string.IsNullOrEmpty(result))
{
var data = DataListUtil.AdjustForEncodingIssues(result);
var isXml = DataListUtil.IsXml(data, out bool isFragment);
if (isXml)
{
var xmlData = XElement.Parse(data);
var allChildren = xmlData.Elements();
var groupedData = allChildren.GroupBy(element => element.Name);
var recSets = groupedData as IGrouping <XName, XElement>[] ?? groupedData.ToArray();
foreach (var grouping in recSets)
{
var debugItem = new DebugItem();
foreach (var name in grouping)
{
if (name.HasElements)
{
var debugItemResult = ProcessRecordSet(name, name.Elements());
debugItem.ResultsList.AddRange(debugItemResult);
}
else
{
var debugItemResult = new DebugItemResult
{
Variable = DataListUtil.AddBracketsToValueIfNotExist(name.Name.LocalName),
Value = name.Value,
Operator = "=",
Type = DebugItemResultType.Variable
};
debugItem.ResultsList.Add(debugItemResult);
}
}
state.Outputs.Add(debugItem);
}
}
}
var js = new Dev2JsonSerializer();
Thread.Sleep(5000);
var correlation = GetCorrelationId(WarewolfTaskSchedulerPath + taskName);
if (!Directory.Exists(OutputPath))
{
Directory.CreateDirectory(OutputPath);
}
File.WriteAllText(
$"{OutputPath}DebugItems_{workflowName.Replace("\\", "_")}_{DateTime.Now.ToString("yyyy-MM-dd")}_{correlation}_{user}.txt",
js.SerializeToBuilder(new List <DebugState> {
state
}).ToString());
}
