/// <summary>
/// Executes a query against a database - returns the result for pretty displaying of the data in xslt
/// </summary>
/// <param name="args">
/// Accepts a piece of xml that can be mapped to the Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteDataset method.
///
/// Read about it here: http://projekt.chainbox.dk/default.asp?W258
/// </param>
/// <returns>
/// The first datatable returned by the query
///
/// <root>
/// <item>
/// <fieldname>fieldvalue</fieldname>
/// <fieldname>fieldvalue</fieldname>
/// <fieldname>fieldvalue</fieldname>
/// </item>
/// <item>
/// <fieldname>fieldvalue</fieldname>
/// <fieldname>fieldvalue</fieldname>
/// <fieldname>fieldvalue</fieldname>
/// </item>
/// </root>
///
/// </returns>
public static XPathNodeIterator ExecuteDataset(XPathNodeIterator args)
{
try
{
XPathNodeIterator retval;
SqlHelperArgs sqlargs = ParseArgs(args);
DataSet ds = Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteDataset(sqlargs.ConnectionString, sqlargs.CommandType, sqlargs.CommandText, sqlargs.Params.ToArray());
XmlDocument xd = new XmlDocument();
ds.DataSetName = "root";
// this is bad - the query might not return anything - but hey this is webdevelopment.
ds.Tables[0].TableName = "item";
using (StringWriter sw = new StringWriter())
{
ds.WriteXml(sw);
xd.LoadXml(sw.ToString());
}
retval = xd.CreateNavigator().Select(".");
WriteToTrace("ExecuteDataset: Returning data from:" + sqlargs.CommandText + " without using cache");
return retval;
}
catch (Exception ex)
{
WriteToTrace(ex.ToString());
return EmptyXpathNodeIterator(ex, "Xslt.ApplicationBlocks.Data.ExecuteDataset", true);
}
}
private static IEnumerable<object> GetUnderlyingXObjects(XPathNodeIterator nodeIterator)
{
foreach (XPathNavigator nav in nodeIterator)
{
yield return nav.UnderlyingObject;
}
}
/// <summary>
/// Implements the following function
/// number min(node-set)
/// </summary>
/// <param name="iterator"></param>
/// <returns></returns>
public double min(XPathNodeIterator iterator)
{
double min, t;
if (iterator.Count == 0)
{
return Double.NaN;
}
try
{
iterator.MoveNext();
min = XmlConvert.ToDouble(iterator.Current.Value);
while (iterator.MoveNext())
{
t = XmlConvert.ToDouble(iterator.Current.Value);
min = (t < min) ? t : min;
}
}
catch
{
return Double.NaN;
}
return min;
}
/// <summary>
/// Implements the following function
/// number max(node-set)
/// </summary>
/// <param name="iterator"></param>
/// <returns></returns>
public double max(XPathNodeIterator iterator)
{
double max, t;
if (iterator.Count == 0)
{
return Double.NaN;
}
try
{
iterator.MoveNext();
max = XmlConvert.ToDouble(iterator.Current.Value);
while (iterator.MoveNext())
{
t = XmlConvert.ToDouble(iterator.Current.Value);
max = (t > max) ? t : max;
}
}
catch
{
return Double.NaN;
}
return max;
}
public static XPathNodeIterator FilterNodes(XPathNodeIterator nodeset, string xpath)
{
try
{
while (nodeset.MoveNext())
{
var nav = nodeset.Current;
var manager = new XmlNamespaceManager(nav.NameTable);
nav.MoveToFollowing(XPathNodeType.Element);
foreach (var ns in nav.GetNamespacesInScope(XmlNamespaceScope.All))
{
manager.AddNamespace(ns.Key, ns.Value);
}
var result = nav.Evaluate(xpath, manager);
if (result is XPathNodeIterator) {
return (XPathNodeIterator)result;
} else {
XmlDocument doc = new XmlDocument();
doc.LoadXml("<result expression=\"" + xpath + "\">" + result.ToString() + "</result>");
return (XPathNodeIterator)doc.DocumentElement.CreateNavigator().Evaluate("/result");
}
}
}
catch (Exception ex)
{
return ex.ToXPathNodeIterator();
}
return nodeset;
}
internal XPathResult(XPathNodeIterator nodeSetResult)
: this()
{
this.nodeSetResult = nodeSetResult;
this.internalIterator = nodeSetResult as SafeNodeSequenceIterator;
this.resultType = XPathResultType.NodeSet;
}
public override object Evaluate(XPathNodeIterator context)
{
base.Evaluate(context);
List<XPathNavigator> parentStk = new List<XPathNavigator>();
Stack<XPathNavigator> stack = new Stack<XPathNavigator>();
while ((base.currentNode = base.qyInput.Advance()) != null)
{
stack.Push(base.currentNode.Clone());
}
while (stack.Count != 0)
{
XPathNavigator nav = stack.Pop();
if (((nav.NodeType != XPathNodeType.Attribute) && (nav.NodeType != XPathNodeType.Namespace)) && this.NotVisited(nav, parentStk))
{
XPathNavigator e = nav.Clone();
if (e.MoveToParent())
{
e.MoveToFirstChild();
while (!e.IsSamePosition(nav))
{
if (this.matches(e))
{
base.Insert(base.outputBuffer, e);
}
if (e.MoveToNext())
{
}
}
}
}
}
return this;
}
public override object Evaluate(XPathNodeIterator nodeIterator)
{
if (xsltContext == null)
{
throw XPathException.Create(SR.Xp_NoContext);
}
// calculate arguments:
object[] argVals = new object[_args.Count];
for (int i = 0; i < _args.Count; i++)
{
argVals[i] = _args[i].Evaluate(nodeIterator);
if (argVals[i] is XPathNodeIterator)
{// ForBack Compat. To protect our queries from users.
argVals[i] = new XPathSelectionIterator(nodeIterator.Current, _args[i]);
}
}
try
{
return ProcessResult(_function.Invoke(xsltContext, argVals, nodeIterator.Current));
}
catch (Exception ex)
{
throw XPathException.Create(SR.Xp_FunctionFailed, QName, ex);
}
}
/// <summary>
/// Implements the following function
/// number avg(node-set)
/// </summary>
/// <param name="iterator"></param>
/// <returns>The average of all the value of all the nodes in the
/// node set</returns>
/// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>
public double avg(XPathNodeIterator iterator)
{
double sum = 0;
int count = iterator.Count;
if (count == 0)
{
return Double.NaN;
}
try
{
while (iterator.MoveNext())
{
sum += XmlConvert.ToDouble(iterator.Current.Value);
}
}
catch (FormatException)
{
return Double.NaN;
}
return sum / count;
}
public override object Evaluate(XPathNodeIterator nodeIterator)
{
return GetValue(_op,
XmlConvertEx.ToXPathDouble(_opnd1.Evaluate(nodeIterator)),
XmlConvertEx.ToXPathDouble(_opnd2.Evaluate(nodeIterator))
);
}
/// <summary>
/// Implements the following function
/// node-set highest(node-set)
/// </summary>
/// <param name="iterator">The input nodeset</param>
/// <returns>All the nodes that contain the max value in the nodeset</returns>
public static XPathNodeIterator highest(XPathNodeIterator iterator){
ExsltNodeList newList = new ExsltNodeList();
double max, t;
if(iterator.Count == 0){
return ExsltCommon.ExsltNodeListToXPathNodeIterator(newList);
}
try{
iterator.MoveNext();
max = XmlConvert.ToDouble(iterator.Current.Value);
newList.Add(iterator.Current.Clone());
while (iterator.MoveNext()){
t = XmlConvert.ToDouble(iterator.Current.Value);
if(t > max){
max = t;
newList.Clear();
newList.Add(iterator.Current.Clone());
}else if( t == max){
newList.Add(iterator.Current.Clone());
}
}
}catch(Exception){ //return empty node set
newList.Clear();
return ExsltCommon.ExsltNodeListToXPathNodeIterator(newList);
}
return ExsltCommon.ExsltNodeListToXPathNodeIterator(newList);
}
public List<TSK> Read(XPathNodeIterator iterator)
{
var tsks = new List<TSK>();
if (iterator.Count == 0)
return tsks;
foreach (XPathNavigator node in iterator)
{
if (node.SelectChildren("TLG", node.NamespaceURI).Count == 0)
continue;
var tsk = new TSK
{
A = GetStringValue(node, "A"),
B = GetStringValue(node, "B"),
C = GetStringValue(node, "C"),
D = GetStringValue(node, "D"),
E = GetStringValue(node, "E"),
F = GetStringValue(node, "F"),
G = GetEnumValue(node, "G"),
H = GetByteValue(node, "H"),
I = GetByteValue(node, "I"),
J = GetByteValue(node, "J"),
Items = GetItems(node),
};
tsks.Add(tsk);
}
return tsks;
}
internal DebuggerOptions(XPathNodeIterator iter)
{
while (iter.MoveNext ()) {
switch (iter.Current.Name) {
case "File":
file = iter.Current.Value;
break;
case "InferiorArgs":
append_array (ref inferior_args, iter.Current.Value);
break;
case "JitArguments":
append_array (ref jit_arguments, iter.Current.Value);
break;
case "WorkingDirectory":
WorkingDirectory = iter.Current.Value;
break;
case "MonoPrefix":
MonoPrefix = iter.Current.Value;
break;
case "MonoPath":
MonoPath = iter.Current.Value;
break;
default:
throw new InternalError ();
}
}
if (inferior_args == null)
inferior_args = new string [0];
}
public override XPathNavigator Advance()
{
while (!this.iterator.MoveNext())
{
XPathNavigator navigator = base.qyInput.Advance();
if (navigator == null)
{
return null;
}
if (base.NameTest)
{
if (base.TypeTest == XPathNodeType.ProcessingInstruction)
{
this.iterator = new IteratorFilter(navigator.SelectChildren(base.TypeTest), base.Name);
}
else
{
this.iterator = navigator.SelectChildren(base.Name, base.Namespace);
}
}
else
{
this.iterator = navigator.SelectChildren(base.TypeTest);
}
base.position = 0;
}
base.position++;
base.currentNode = this.iterator.Current;
return base.currentNode;
}
public static string GetWsdlUrl(string referencePath)
{
string url = string.Empty;
if (!string.IsNullOrEmpty(referencePath))
{
XPathDocument xDoc = new XPathDocument(referencePath);
XPathNavigator xNav = xDoc.CreateNavigator();
string xpathExpression;
if (referencePath.Contains(Messages.MSG_D_SERV_REF))
{
xpathExpression = @"ReferenceGroup/Metadata/MetadataFile[MetadataType='Wsdl']/@SourceUrl";
}
else
{
xpathExpression = @"DiscoveryClientResultsFile/Results/DiscoveryClientResult[@referenceType='System.Web.Services.Discovery.ContractReference']/@url";
}
System.Xml.XPath.XPathNodeIterator xIter = xNav.Select(xpathExpression);
if (xIter.MoveNext())
{
url = xIter.Current.TypedValue.ToString();
}
}
return(url);
}
public override object Evaluate(XPathNodeIterator nodeIterator) {
object n1 = opnd1.Evaluate(nodeIterator);
if (((bool) n1) == isOr) {
return n1;
}
return opnd2.Evaluate(nodeIterator);
}
/// <summary>
/// Implements an optimized algorithm for the following function
/// node-set difference(node-set, node-set)
/// Uses document identification and binary search,
/// based on the fact that a node-set is always in document order.
/// </summary>
/// <param name="nodeset1">An input nodeset</param>
/// <param name="nodeset2">Another input nodeset</param>
/// <returns>The those nodes that are in the node set
/// passed as the first argument that are not in the node set
/// passed as the second argument.</returns>
/// <author>Dimitre Novatchev</author>
private XPathNodeIterator difference2(XPathNodeIterator nodeset1, XPathNodeIterator nodeset2)
{
ArrayList arDocs = new ArrayList();
ArrayList arNodes2 = new ArrayList(nodeset2.Count);
while(nodeset2.MoveNext())
{
arNodes2.Add(nodeset2.Current.Clone());
}
auxEXSLT.findDocs(arNodes2, arDocs);
ExsltNodeList enlResult = new ExsltNodeList();
while(nodeset1.MoveNext())
{
XPathNavigator currNode = nodeset1.Current;
if(!auxEXSLT.findNode(arNodes2, arDocs, currNode) )
enlResult.Add(currNode.Clone());
}
return ExsltCommon.ExsltNodeListToXPathNodeIterator(enlResult);
}
private List<TSK> GetExternalTasks(string path, XPathNodeIterator externalChildren)
{
var items = new List<TSK>();
foreach (XPathNavigator node in externalChildren)
{
var attribute = node.GetAttribute("A", node.NamespaceURI);
if (attribute.StartsWith("TSK"))
{
var filename = Path.Combine(path, attribute + ".xml");
if(!File.Exists(filename))
continue;
var externalTaskElements = new XPathDocument(filename).CreateNavigator()
.SelectSingleNode(XFC)
.SelectChildren(XPathNodeType.Element)
.Current.Select("./" + TSK);
var externalTsks = _tsksReader.Read(externalTaskElements);
items.AddRange(externalTsks);
}
}
return items;
}
public override object Evaluate(XPathNodeIterator nodeIterator) {
if (xsltContext == null) {
throw XPathException.Create(Res.Xp_NoContext);
}
return ProcessResult(variable.Evaluate(xsltContext));
}
public override object Evaluate(XPathNodeIterator context) {
object argVal = base.Evaluate(context);
XPathNavigator contextNode = context.Current.Clone();
switch (GetXPathType(argVal)) {
case XPathResultType.NodeSet:
XPathNavigator temp;
while ((temp = input.Advance()) != null) {
ProcessIds(contextNode, temp.Value);
}
break;
case XPathResultType.String:
ProcessIds(contextNode, (string)argVal);
break;
case XPathResultType.Number:
ProcessIds(contextNode, StringFunctions.toString((double)argVal));
break;
case XPathResultType.Boolean:
ProcessIds(contextNode, StringFunctions.toString((bool)argVal));
break;
case XPathResultType_Navigator:
ProcessIds(contextNode, ((XPathNavigator)argVal).Value);
break;
}
return this;
}
public override object Evaluate(XPathNodeIterator context)
{
outputBuffer.Clear();
count = 0;
return input.Evaluate(context);// This is trick. IDQuery needs this value. Otherwise we would return this.
// All subclasses should and would anyway override thismethod and return this.
}
internal override void reset()
{
_eLast = null;
_qy = null;
_first = true;
base.reset();
}
public override XPathNavigator Advance() {
while (true) {
if (nodeIterator == null) {
position = 0;
XPathNavigator nav = qyInput.Advance();
if (nav == null) {
return null;
}
if (NameTest) {
if (TypeTest == XPathNodeType.ProcessingInstruction) {
nodeIterator = new IteratorFilter(nav.SelectDescendants(TypeTest, matchSelf), Name);
} else {
nodeIterator = nav.SelectDescendants(Name, Namespace, matchSelf);
}
} else {
nodeIterator = nav.SelectDescendants(TypeTest, matchSelf);
}
}
if (nodeIterator.MoveNext()) {
position++;
currentNode = nodeIterator.Current;
return currentNode;
} else {
nodeIterator = null;
}
}
}
public override object Evaluate(XPathNodeIterator context) {
base.Evaluate(context);
// Fill up base.outputBuffer
List<XPathNavigator> parentStk = new List<XPathNavigator>();
Stack<XPathNavigator> inputStk = new Stack<XPathNavigator>();
while ((currentNode = qyInput.Advance()) != null) {
inputStk.Push(currentNode.Clone());
}
while (inputStk.Count != 0) {
XPathNavigator input = inputStk.Pop();
if (input.NodeType == XPathNodeType.Attribute || input.NodeType == XPathNodeType.Namespace) {
continue;
}
if (NotVisited(input, parentStk)) {
XPathNavigator prev = input.Clone();
if (prev.MoveToParent()) {
bool test = prev.MoveToFirstChild();
Debug.Assert(test, "We just moved to parent, how we can not have first child?");
while (!prev.IsSamePosition(input)) {
if (matches(prev)) {
Insert(outputBuffer, prev);
}
if (!prev.MoveToNext()) {
Debug.Fail("We managed to miss sentinel node (input)");
break;
}
}
}
}
}
return this;
}
internal override XPathNavigator advance() {
while (true) {
if (_count == 0) {
m_eNext = m_qyInput.advance();
if (m_eNext == null ){
return null;
}
if( _fMatchName ) {
if( m_Type == XPathNodeType.ProcessingInstruction ) {
_iterator = new IteratorFilter( m_eNext.SelectChildren( m_Type ), m_Name );
}
else {
_iterator = m_eNext.SelectChildren( m_Name, m_URN );
}
}
else {
_iterator = m_eNext.SelectChildren( m_Type );
}
_count = 1;
_position = 0;
}
if( _iterator.MoveNext() ) {
_position++;
m_eNext = _iterator.Current;
return m_eNext;
}
else {
_count = 0;
}
}
} // Advance
/// <summary>
/// Implements the following function
/// string date2:min(node-set)
/// See http://www.xmland.net/exslt/doc/GDNDatesAndTimes-min.xml
/// </summary>
/// <remarks>THIS FUNCTION IS NOT PART OF EXSLT!!!</remarks>
public string min(XPathNodeIterator iterator)
{
TimeSpan min, t;
if (iterator.Count == 0)
{
return "";
}
try
{
iterator.MoveNext();
min = XmlConvert.ToTimeSpan(iterator.Current.Value);
while (iterator.MoveNext())
{
t = XmlConvert.ToTimeSpan(iterator.Current.Value);
min = (t < min) ? t : min;
}
}
catch (FormatException)
{
return "";
}
return XmlConvert.ToString(min);
}
public override object Evaluate(XPathNodeIterator context)
{
base.contextNode = context.Current.Clone();
base.contextNode.MoveToRoot();
base.count = 0;
return this;
}
public override object Evaluate(XPathNodeIterator context)
{
object obj2 = base.Evaluate(context);
XPathNavigator contextNode = context.Current.Clone();
switch (base.GetXPathType(obj2))
{
case XPathResultType.Number:
this.ProcessIds(contextNode, StringFunctions.toString((double) obj2));
break;
case XPathResultType.String:
this.ProcessIds(contextNode, (string) obj2);
break;
case XPathResultType.Boolean:
this.ProcessIds(contextNode, StringFunctions.toString((bool) obj2));
break;
case XPathResultType.NodeSet:
XPathNavigator navigator2;
while ((navigator2 = base.input.Advance()) != null)
{
this.ProcessIds(contextNode, navigator2.Value);
}
break;
case ((XPathResultType) 4):
this.ProcessIds(contextNode, ((XPathNavigator) obj2).Value);
break;
}
return this;
}
private double Number(XPathNodeIterator nodeIterator)
{
if (_arg == null)
{
return XmlConvertEx.ToXPathDouble(nodeIterator.Current.Value);
}
object argVal = _arg.Evaluate(nodeIterator);
switch (GetXPathType(argVal))
{
case XPathResultType.NodeSet:
XPathNavigator value = _arg.Advance();
if (value != null)
{
return Number(value.Value);
}
break;
case XPathResultType.String:
return Number((string)argVal);
case XPathResultType.Boolean:
return Number((bool)argVal);
case XPathResultType.Number:
return (double)argVal;
case XPathResultType_Navigator:
return Number(((XPathNavigator)argVal).Value);
}
return double.NaN;
}
private XPathNavigator EvaluateArg(XPathNodeIterator context) {
if (arg == null) {
return context.Current;
}
arg.Evaluate(context);
return arg.Advance();
}
/// <summary>
/// Override method that performs the actual property setting from a Navigator result.
/// </summary>
/// <param name="component"></param>
/// <param name="data"></param>
/// <param name="context"></param>
protected override void DoBindComponent(object component, object data, PDFDataContext context)
{
System.Xml.XPath.XPathExpression expr = this.GetExpression(data, context);
if (data is System.Xml.XPath.XPathNodeIterator)
{
data = ((System.Xml.XPath.XPathNodeIterator)data).Current;
}
System.Xml.XPath.XPathNavigator nav = (System.Xml.XPath.XPathNavigator)data;
if (null == this.Converter)
{
var iterator = nav.Select(expr);
if (this.Property.PropertyType == typeof(XPathNavigator))
{
this.Property.SetValue(component, iterator.Current);
}
else
{
this.Property.SetValue(component, iterator);
}
}
else
{
System.Xml.XPath.XPathNodeIterator itter = nav.Select(expr);
if (itter.CurrentPosition < 0)
{
itter.MoveNext();
}
string value = itter.Current.Value;
object converted = this.Converter(value, this.Property.PropertyType, System.Globalization.CultureInfo.CurrentCulture);
if (context.ShouldLogVerbose)
{
context.TraceLog.Add(TraceLevel.Verbose, "Item Binding", "Setting property '" + this.Property.Name + "' with the XPath binding expression '" + expr.Expression + "' to value '" + ((null == value) ? "NULL" : value) + "'");
}
this.Property.SetValue(component, converted, null);
}
}
protected override bool DoEvaluateTestExpression(string expr, object withData, PDFDataContext context)
{
System.Xml.XPath.XPathNavigator nav;
if (withData is System.Xml.XPath.XPathNavigator)
{
nav = withData as System.Xml.XPath.XPathNavigator;
}
else
{
throw new NotSupportedException("The XmlDataSource can only perfrom select operations on XPathNavigator data.");
}
object result;
if (string.IsNullOrEmpty(expr))
{
result = nav.Evaluate("*", context.NamespaceResolver);
}
else
{
result = nav.Evaluate(expr, context.NamespaceResolver);
}
if (result is bool)
{
return((bool)result);
}
else if (result is System.Xml.XPath.XPathNodeIterator)
{
System.Xml.XPath.XPathNodeIterator itter = (System.Xml.XPath.XPathNodeIterator)result;
return(itter.Count > 0);
}
else
{
return(null != result);
}
}
override internal object getValue(XPathNavigator qyContext, XPathNodeIterator iterator)
{
return(m_qyInput.getValue(qyContext, iterator));
}
public Enumerator(XPathNodeIterator original)
{
_original = original.Clone();
}
internal override object getValue(XPathNavigator qy, XPathNodeIterator iterator)
{
return(_Var);
}
private void EditCand_Load(object sender, EventArgs e)
{
doc = new XPathDocument(FILE_NAME);
nav = doc.CreateNavigator();
// Compile a standard XPath expression
expr = nav.Compile("/config/voto/@puesto");
iterator = nav.Select(expr);
// Iterate on the node set
comboBox1.Items.Clear();
try
{
while (iterator.MoveNext())
{
XPathNavigator nav2 = iterator.Current.Clone();
comboBox1.Items.Add(nav2.Value);
comboBox1.SelectedIndex = 0;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
//save old title
oldTitle = comboBox1.Text;
}
