public void Load(Compiler compiler, object stylesheet, XmlResolver xmlResolver) { Debug.Assert(compiler != null); _compiler = compiler; _xmlResolver = xmlResolver ?? XmlNullResolver.Singleton; XmlReader reader = stylesheet as XmlReader; if (reader != null) { _readerSettings = new QueryReaderSettings(reader); Load(reader); } else { // We should take DefaultReaderSettings from Compiler.Settings.DefaultReaderSettings. string uri = stylesheet as string; if (uri != null) { // If xmlResolver == null, then the original uri will be resolved using XmlUrlResolver XmlResolver origResolver = xmlResolver; if (xmlResolver == null || xmlResolver == XmlNullResolver.Singleton) origResolver = new XmlUrlResolver(); Uri resolvedUri = origResolver.ResolveUri(null, uri); if (resolvedUri == null) { throw new XslLoadException(SR.Xslt_CantResolve, uri); } _readerSettings = new QueryReaderSettings(new NameTable()); using (reader = CreateReader(resolvedUri, origResolver)) { Load(reader); } } else { IXPathNavigable navigable = stylesheet as IXPathNavigable; if (navigable != null) { reader = XPathNavigatorReader.Create(navigable.CreateNavigator()); _readerSettings = new QueryReaderSettings(reader.NameTable); Load(reader); } else { Debug.Fail("Should never get here"); } } } Debug.Assert(compiler.Root != null); compiler.StartApplyTemplates = f.ApplyTemplates(nullMode); ProcessOutputSettings(); foreach (AttributeSet attSet in compiler.AttributeSets.Values) { CheckAttributeSetsDfs(attSet); // Check attribute sets for circular references using dfs marking method } }
//============================== // static void XSLT_Old() { string filename = "books.xml"; //<snippet7> // Create the XslTransform. XslTransform xslt = new XslTransform(); // Create a resolver and set the credentials to use. XmlUrlResolver resolver = new XmlUrlResolver(); resolver.Credentials = CredentialCache.DefaultCredentials; // Load the style sheet. xslt.Load("http://serverName/data/xsl/sort.xsl", resolver); // Transform the file. XPathDocument doc = new XPathDocument(filename); XmlTextWriter writer = new XmlTextWriter("output.xml", null); xslt.Transform(doc, null, writer, null); //</snippet7> }
static void Main(string[] args) { //This example gets all the Tables in the specified spreadsheet and lists them //Note: Check that the Excel Services service application is running before you run this example //Get a reference to the atom namespace XNamespace atomNS = atomNameSpace; //build the relative Url to the excel workbook model string relativeUrl = "/_vti_bin/ExcelRest.aspx/" + docLibrary + "/" + spreadsheetFileName + "/model/Tables"; //Use an XMLUrlResolver object to pass credentials to the REST service XmlUrlResolver resolver = new XmlUrlResolver(); resolver.Credentials = CredentialCache.DefaultCredentials; //Build the URI to pass the the resolver Uri baseUri = new Uri(sharepointSite); Uri fullUri = resolver.ResolveUri(baseUri, relativeUrl); //Tell the user what the stream address is Console.WriteLine("Opening this stream: " + fullUri.ToString()); //Call the resolver and receive the ATOM feed as a result Stream atomStream = (Stream)resolver.GetEntity(fullUri, null, typeof(Stream)); //Load the stream into an XDocument XDocument atomResults = XDocument.Load(atomStream); //Query the XDocument for all title elements that are children of an entry element IEnumerable <XElement> tables = from t in atomResults.Descendants(atomNS + "title") where t.Parent.Name == atomNS + "entry" select t; Console.WriteLine("Tables in the spreadsheet " + spreadsheetFileName + ":"); //Display each of the table foreach (XElement table in tables) { Console.WriteLine((string)table); } //This line prevents the console disappearing before you can read the result //Alternatively, remove this line a run the project without debugging (CTRL-F5) Console.ReadKey(); }
public string GetOriginalChain(string stringXML) { StringWriter sw = new StringWriter(); try { XslCompiledTransform xslt = new System.Xml.Xsl.XslCompiledTransform(); XsltSettings sets = new XsltSettings(true, true); var resolver = new XmlUrlResolver(); xslt.Load(xsltPath, sets, resolver); XmlDocument FromXmlFile = new System.Xml.XmlDocument(); FromXmlFile.LoadXml(stringXML); xslt.Transform(FromXmlFile, null, sw); } catch (Exception ex) { throw new Exception("No se pudo generar la cadena", ex.InnerException); } return(sw.ToString()); }
private XmlReaderSettings BuildXmlReaderSettings(bool isDtdProcessing, XsdInfo xsdInfo) { // Set the validation settings. XmlReaderSettings settings = new XmlReaderSettings(); settings.ValidationType = ValidationType.Schema; //Removed for Issue#2 on Codeplex //settings.ValidationFlags |= XmlSchemaValidationFlags.ProcessSchemaLocation; settings.ValidationEventHandler += new ValidationEventHandler(ValidationCallBack); //Allow DTD processing if (isDtdProcessing) { settings.DtdProcessing = DtdProcessing.Parse; } else { settings.DtdProcessing = DtdProcessing.Prohibit; } // Supply the credentials necessary to access the DTD file stored on the network. XmlUrlResolver resolver = new XmlUrlResolver(); resolver.Credentials = System.Net.CredentialCache.DefaultCredentials; settings.XmlResolver = resolver; //Get the Schema // A Stream is needed to read the XSD document contained in the assembly. if (xsdInfo != null) { settings.ValidationFlags |= XmlSchemaValidationFlags.ReportValidationWarnings; using (Stream stream = Assembly.GetExecutingAssembly() .GetManifestResourceStream(xsdInfo.ResourceName)) { settings.Schemas.Add(xsdInfo.TargetNamespace, XmlReader.Create(stream)); settings.Schemas.Compile(); } } return(settings); }
public net.sf.saxon.om.SequenceIterator resolve(string href, string baseStr, net.sf.saxon.expr.XPathContext context) { try { List <Uri> docs; if (href == null) { docs = (List <Uri>)collections[new Uri("http://www.saxonica.com/defaultCollection")]; } else { XmlUrlResolver res = new XmlUrlResolver(); Uri abs = res.ResolveUri(new Uri(baseStr), href); try { docs = (List <Uri>)collections[abs]; } catch (Exception) { docs = null; } } if (docs == null) { return(net.sf.saxon.tree.iter.EmptyIterator.getInstance()); } else { java.util.List list = new java.util.ArrayList(); foreach (Uri uri in docs) { list.add(new net.sf.saxon.value.AnyURIValue(uri.ToString())); } return(new net.sf.saxon.tree.iter.ListIterator(list)); } } catch (java.net.URISyntaxException e) { System.Console.WriteLine("** Invalid Uri: " + e.Message); return(net.sf.saxon.tree.iter.EmptyIterator.getInstance()); } }
/// <include file='doc\xml.uex' path='docs/doc[@for="Xml.Render"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> protected override void Render(HtmlTextWriter output) { // If we don't already have an XmlDocument, load am XPathDocument (which is faster) if (_document == null) { LoadXPathDocument(); } LoadTransformFromSource(); if (_document == null && _xpathDocument == null) { return; } // If we don't have a transform, use the identity transform, which // simply renders the XML. if (_transform == null) { _transform = _identityTransform; } // Pass a resolver in full trust, to support certain XSL scenarios (ASURT 141427) XmlUrlResolver xr = null; if (HttpRuntime.HasUnmanagedPermission()) { xr = new XmlUrlResolver(); } if (_document != null) { Transform.Transform(_document, _transformArgumentList, output, xr); } else { Transform.Transform(_xpathDocument, _transformArgumentList, output, xr); } }
private void buttonsubmit_Click(object sender, EventArgs e) { string path = textBoxPath.Text; textBoxPath.Text = ""; XmlUrlResolver resolver = new XmlUrlResolver(); resolver.Credentials = System.Net.CredentialCache.DefaultCredentials; xmlDoc.XmlResolver = resolver; try { xmlDoc.Load(path); //Durch die Load Methode wird eine XML-Datei geladen. Die XML-Datei liegt im Verzeichnis"Debug". kontextNode = xmlDoc; //kontextNode wird auf das Dokument initialisiert. tbAusgabetextBox.Text = AusgabeString(kontextNode); } catch (Exception ex) { Console.WriteLine("{0}:{1}", ex.GetType(), ex.Message); StatusLabel.Text = ex.GetType().ToString(); } }
/// <summary> /// Initializes a new instance of the <see cref="XmlValidatingLoader" /> class. /// </summary> /// <param name="innerReader">The inner reader.</param> /// <remarks></remarks> public XmlValidatingLoader(XmlReader innerReader) { this.innerReader = innerReader; var resolver = new XmlUrlResolver(); // This is a bit of a hack - Turn on DTD entity resolution if it is not already on. // Also set a resolver, this is required under Mono var dummy = innerReader as XmlTextReader; if (dummy != null) { dummy.EntityHandling = EntityHandling.ExpandEntities; dummy.XmlResolver = resolver; } xmlReaderSettings = new XmlReaderSettings(); xmlReaderSettings.ValidationType = ValidationType.None; xmlReaderSettings.ProhibitDtd = false; xmlReaderSettings.XmlResolver = resolver; xmlReaderSettings.ConformanceLevel = ConformanceLevel.Auto; xmlReaderSettings.ValidationEventHandler += ValidationHandler; }
public void WithInitializeInsideIf(XmlUrlResolver xmlUrlResolver) { XmlDocument doc; if ((doc = new XmlDocument()) != null) { doc.XmlResolver = null; // no DTD resolving doc.Load(""); } if ((doc = new XmlDocument()) != null) // Noncompliant { doc.XmlResolver = xmlUrlResolver; // Noncompliant doc.Load(""); } if ((doc = new XmlDocument()) != null) { doc.XmlResolver = null; // no DTD resolving doc.Load(""); } }
public static string CadenaOriginalCFDIv33(string strXml) { try { var xslt_cadenaoriginal_3_3 = new XslCompiledTransform(); XsltSettings settings = new XsltSettings(true, true); XmlUrlResolver resolver = new XmlUrlResolver(); xslt_cadenaoriginal_3_3.Load("Resources/XSLT/cadenaoriginal_3_3.xslt", settings, resolver); string resultado = null; StringWriter writer = new StringWriter(); XmlReader xml = XmlReader.Create(new StringReader(strXml)); xslt_cadenaoriginal_3_3.Transform(xml, null, writer); resultado = writer.ToString().Trim(); writer.Close(); return(resultado); } catch (Exception ex) { throw new Exception("El XML proporcionado no es válido.", ex); } }
static void Main(string[] args) { // Create and load the transform with script execution enabled. XslCompiledTransform transform = new XslCompiledTransform(); XsltSettings settings = new XsltSettings(); settings.EnableScript = true; XmlUrlResolver resolver = new XmlUrlResolver(); // transform the Schematron to a XSL transform.Load(@"D:\VisualStudio Projects\HL7\SchematronTry.ConsoleApplication\iso-schematron-xslt1\iso_svrl_for_xslt1.xsl", settings, resolver); transform.Transform(@"D:\VisualStudio Projects\HL7\SchematronTry.ConsoleApplication\Test.sch", @"D:\VisualStudio Projects\HL7\SchematronTry.ConsoleApplication\Test.sch.xsl"); // now execute the Schematron XSL const string fm_max_file = @"D:\My Documents\__R4C\__WIP\HL7 EHR-S FM Tooling (2012-aug)\EHRS_FM_R2 (import v2.2) generated-ehrs-fm-20121115-full2.max.xml"; //const string fm_max_file = @"D:\VisualStudio Projects\HL7\SchematronTry.ConsoleApplication\fm-max.xml"; transform.Load(@"D:\VisualStudio Projects\HL7\SchematronTry.ConsoleApplication\Test.sch.xsl", settings, resolver); transform.Transform(fm_max_file, @"D:\VisualStudio Projects\HL7\SchematronTry.ConsoleApplication\fm-max.xml-output"); }
public XmlSchema Add(string targetNamespace, string schemaUri) { if ((schemaUri == null) || (schemaUri.Length == 0)) { throw new ArgumentNullException("schemaUri"); } if (targetNamespace != null) { targetNamespace = XmlComplianceUtil.CDataNormalize(targetNamespace); } XmlSchema schema = null; lock (this.InternalSyncObject) { System.Xml.XmlResolver xmlResolver = this.readerSettings.GetXmlResolver(); if (xmlResolver == null) { xmlResolver = new XmlUrlResolver(); } Uri uri = xmlResolver.ResolveUri(null, schemaUri); if (this.IsSchemaLoaded(uri, targetNamespace, out schema)) { return(schema); } XmlReader reader = XmlReader.Create(schemaUri, this.readerSettings); try { schema = this.Add(targetNamespace, this.ParseSchema(targetNamespace, reader)); while (reader.Read()) { } } finally { reader.Close(); } } return(schema); }
// Load URI with XmlResolver static void Settings_Resolver() { string UserName = "******"; string SecurelyStoredPassword = "******"; string Domain = "domain"; //<snippet2> // Create an XmlUrlResolver with the credentials necessary to access the Web server. XmlUrlResolver resolver = new XmlUrlResolver(); System.Net.NetworkCredential myCred; myCred = new System.Net.NetworkCredential(UserName, SecurelyStoredPassword, Domain); resolver.Credentials = myCred; XmlReaderSettings settings = new XmlReaderSettings(); settings.XmlResolver = resolver; // Create the reader. XmlReader reader = XmlReader.Create("http://serverName/data/books.xml", settings); //</snippet2> }
protected override ActivityExecutionStatus Execute(ActivityExecutionContext context) { string sFullURL = this.SourceSiteURL + @"/" + this.DocumentLibrary + @"/" + this.RuleSetName + ".ruleset"; WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer(); XmlUrlResolver resolver = new XmlUrlResolver(); System.Net.NetworkCredential myCredentials = new System.Net.NetworkCredential("Administrator", "password", "Mossb2tr"); resolver.Credentials = myCredentials; XmlReaderSettings settings = new XmlReaderSettings(); settings.XmlResolver = resolver; XmlReader reader = XmlReader.Create(sFullURL, settings); RuleSet ruleSet = (RuleSet)serializer.Deserialize(reader); reader.Close(); Activity targetActivity = Utility.GetRootWorkflow(this.Parent); RuleValidation validation = new RuleValidation(targetActivity.GetType(), null); RuleExecution execution = new RuleExecution(validation, targetActivity, context); ruleSet.Execute(execution); return(ActivityExecutionStatus.Closed); }
static void SaveAsXml(string url, string fileToSave) { if (File.Exists(fileToSave)) { return; } var stream = new XmlUrlResolver().GetEntity(new Uri(url), null, typeof(Stream)) as Stream; var xr = new SgmlReader() { InputStream = new StreamReader(stream) }; var xw = XmlWriter.Create(fileToSave); xr.MoveToContent(); do { xw.WriteNode(xr, false); xw.Flush(); } while (xr.Read()); xw.Close(); }
private string DoTransform(string XML, string XSL, XsltArgumentList Params) { try { XslTransform oXsl = new XslTransform(); oXsl.Load(XSL); XmlTextReader oXR = new XmlTextReader(XML, XmlNodeType.Document, null); XPathDocument oXml = new XPathDocument(oXR); XmlUrlResolver oResolver = new XmlUrlResolver(); StringBuilder oSB = new StringBuilder(); StringWriter oWriter = new StringWriter(oSB, null); oXsl.Transform(oXml, Params, oWriter, oResolver); oWriter.Close(); return(oSB.ToString()); } catch (Exception ex) { throw (ex); } }
public string Validate(string filename, Stream sourceDoc) { var xsltArguments = CreateXsltArguments(filename); XPathDocument myXPathDocument = new XPathDocument(sourceDoc); XslTransform myXslTransform = new XslTransform(); var resolver = new XmlUrlResolver(); myXslTransform.Load(_xslPath, resolver); try { using (var output = new MemoryStream()) myXslTransform.Transform(myXPathDocument, xsltArguments, output); } catch (XsltException ex) { return(ex.Message); } return(null); }
public void WriteToExcel(string Dir, string Filename, string Xslname, string Query, Int16 Limit) { DataSet ds = new DataSet(); // Dim fn, str As String string str = null; long i = 0; long j = 0; //Dim d As Directory j = 0; SqlDataAdapter da = new SqlDataAdapter(Query, con); da.Fill(ds); da.Dispose(); if (!Directory.Exists(Dir)) { Directory.CreateDirectory(Dir); } for (i = 1; i <= ds.Tables[0].Rows.Count; i += Limit) { str = Query + " and num between " + i + " and " + (i + Limit - 1); SqlDataAdapter da1 = new SqlDataAdapter(str, con); DataSet DS2 = new DataSet(); da1.Fill(DS2); XmlDataDocument xdd = new XmlDataDocument(DS2); //Dim xt As New Xsl.XslTransform System.Xml.Xsl.XslTransform xt = new System.Xml.Xsl.XslTransform(); xt.Load(Xslname); FileStream fs = new FileStream(Dir + "\\" + Filename + j + ".xls", System.IO.FileMode.CreateNew, System.IO.FileAccess.Write); XmlUrlResolver rs = new XmlUrlResolver(); rs.Credentials = System.Net.CredentialCache.DefaultCredentials; xt.Transform(xdd, null, fs, rs); fs.Close(); j = j + 1; DS2.Dispose(); } }
/// <summary> /// Pres the process. /// </summary> /// <param name="input">The input.</param> /// <param name="output">The output.</param> /// <param name="resolver">The resolver.</param> /// <param name="inputUri">The input_uri.</param> /// <returns></returns> /// <remarks></remarks> public PreprocessorEnvironment PreProcess(XmlReader input, XmlWriter output, XmlUrlResolver resolver, Uri inputUri) { // The base URI is needed to resolve includes of relative paths, as well as to generate // error messages. // If none is given explicitly, try to use the XmlReader's BaseUri. // If that doesn't exist either, use the current working directory and a fake filename. Uri base_uri = inputUri ?? (String.IsNullOrEmpty(input.BaseURI) ? new Uri( Path.Combine( Environment.CurrentDirectory, "nofile.xml")) : new Uri(input.BaseURI)); // Create the environment _env = new PreprocessorEnvironment(_settings, base_uri, resolver); // Load the input document XDocument doc = XDocument.Load(input, LoadOptions.PreserveWhitespace | LoadOptions.SetBaseUri | LoadOptions.SetLineInfo); // Process the input document's nodes and write the results to the output stream foreach (XNode out_node in doc.Nodes().SelectMany( node => _env._DefaultNodeProcessor.Process(node)).Where(node => !(node is XText))) { out_node.WriteTo(output); } // Notify listeners of all files encountered. if (SubfileLoaded != null) { foreach (Uri path in _env.Fileset) { SubfileLoaded(path); } } return(_env); }
public static void Main() { //Create the XslTransform. XslTransform xslt = new XslTransform(); //Create a resolver and set the credentials to use. XmlUrlResolver resolver = new XmlUrlResolver(); resolver.Credentials = CredentialCache.DefaultCredentials; //Load the stylesheet. xslt.Load(stylesheet, resolver); //Load the XML data file. XPathDocument doc = new XPathDocument(filename); //Create the XmlTextWriter to output to the console. XmlTextWriter writer = new XmlTextWriter(Console.Out); //Transform the file. xslt.Transform(doc, null, writer, null); writer.Close(); }
public void Load(string url, XmlResolver resolver) { XmlResolver res = resolver; if (res == null) { res = new XmlUrlResolver(); } Uri uri = res.ResolveUri(null, url); using (Stream s = res.GetEntity(uri, null, typeof(Stream)) as Stream) { XmlTextReader xtr = new XmlTextReader(uri.ToString(), s); xtr.XmlResolver = res; XmlValidatingReader xvr = new XmlValidatingReader(xtr); xvr.XmlResolver = res; xvr.ValidationType = ValidationType.None; Load(new XPathDocument(xvr, XmlSpace.Preserve).CreateNavigator(), resolver #if NOT_PFX , null #endif ); } }
public static void Main() { // Create the reader. XmlTextReader reader = new XmlTextReader("http://myServer/data/books.xml"); // Create a secure resolver with default credentials. XmlUrlResolver resolver = new XmlUrlResolver(); XmlSecureResolver sResolver = new XmlSecureResolver(resolver, "http://myServer/data/"); sResolver.Credentials = CredentialCache.DefaultCredentials; // Use the secure resolver to resolve resources. reader.XmlResolver = sResolver; // Parse the file. while (reader.Read()) { // Do any additional processing here. } // Close the reader. reader.Close(); }
static void xsltFormatTransform(string inputPath, string outputPath, string xsltPath) { XmlUrlResolver resolver = new XmlUrlResolver(); XsltSettings xsltSettings = new XsltSettings(true, true); MxmlTextWriter mxmlWriter = mxmlWriter = new MxmlTextWriter(outputPath, null, true); XmlInput input = new XmlInput(inputPath); MvpXslTransform mxmlTransform = new MvpXslTransform(); mxmlWriter.Formatting = Formatting.Indented; mxmlWriter.IndentChar = '\t'; mxmlWriter.Indentation = 1; mxmlWriter.WriteRaw("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"); mxmlWriter.WriteRaw("<?xml-stylesheet type=\"text/xsl\" href=\"../../../material/css/" + BookName + "/" + BookName + ".css\"?>\n"); mxmlWriter.WriteRaw("<!DOCTYPE book SYSTEM \"" + commonSrc + "mxml/dtd/mxml.dtd\">\n"); mxmlTransform.Load(xsltPath, xsltSettings, resolver); mxmlTransform.Transform(input, null, new XmlOutput(mxmlWriter)); mxmlWriter.Flush(); mxmlWriter.Close(); mxmlWriter = null; }
public void MatchRootMvpXml() { XmlDocument xsltDoc = new XmlDocument(); xsltDoc.LoadXml(@" <xsl:stylesheet version='1.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'> <xsl:output method='xml' omit-xml-declaration='no' encoding='UTF-8'/> <xsl:template match='/'><root>Matched</root></xsl:template> </xsl:stylesheet> " ); MvpXslTransform transform = new MvpXslTransform(); var resolver = new XmlUrlResolver(); transform.Load(xsltDoc, XsltSettings.TrustedXslt, resolver); StringBuilder builder = new StringBuilder(); XmlWriter writer = new XmlTextWriter(new StringWriter(builder)); CollectionOfSimple c = new CollectionOfSimple(true); ObjectXPathContext context = new ObjectXPathContext(); context.DetectLoops = true; XPathNavigator nav = context.CreateNavigator(c); transform.Transform( new XmlInput(nav, resolver), null, new XmlOutput(writer)); writer.Close(); Assert.AreEqual("<root>Matched</root>", builder.ToString()); }
public void BuildNavigator(string modelFilePath) { XmlResolver resolver = new XmlUrlResolver(); resolver.Credentials = CredentialCache.DefaultCredentials; XmlTextReader tr = new XmlTextReader(modelFilePath); XslCompiledTransform transform = new XslCompiledTransform(); transform.Load(this.stylesheetFilesPath + Path.DirectorySeparatorChar + "ModelTree.xsl", null, resolver); XmlTextWriter tw = new XmlTextWriter(this.htmlFilesPath + Path.DirectorySeparatorChar + "ModelTree.htm", Encoding.UTF8); XsltArgumentList al = new XsltArgumentList(); al.AddParam("modelBrowser", "", this.localizer.GetValue("Globals", "ModelBrowser")); al.AddParam("glossary", "", this.localizer.GetValue("Globals", "Glossary")); al.AddParam("stakeholders", "", this.localizer.GetValue("Globals", "Stakeholders")); transform.Transform(tr, al, tw, null); tw.Close(); tr.Close(); tr = new XmlTextReader(modelFilePath); transform.Load(this.stylesheetFilesPath + Path.DirectorySeparatorChar + "HomePage.xsl", null, resolver); tw = new XmlTextWriter(this.htmlFilesPath + Path.DirectorySeparatorChar + "main.htm", Encoding.UTF8); al = new XsltArgumentList(); AssemblyName an = this.GetType().Assembly.GetName(); al.AddParam("version", "", an.Version.ToString(3)); al.AddParam("model", "", this.localizer.GetValue("Globals", "Model")); al.AddParam("author", "", this.localizer.GetValue("Globals", "Author")); al.AddParam("company", "", this.localizer.GetValue("Globals", "Company")); al.AddParam("creationDate", "", this.localizer.GetValue("Globals", "CreationDate")); al.AddParam("exportPrintDate", "", this.localizer.GetValue("Globals", "ExportPrintDate")); al.AddParam("now", "", Convert.ToString(DateTime.Now, DateTimeFormatInfo.InvariantInfo)); al.AddParam("release", "", this.localizer.GetValue("Globals", "Release")); transform.Transform(tr, al, tw, null); tw.Close(); tr.Close(); }
protected void Page_Load(object sender, EventArgs e) { string xml = Request.QueryString["xml"]; XmlUrlResolver resolver = new XmlUrlResolver(); resolver.Credentials = CredentialCache.DefaultCredentials; Console.WriteLine(xml); XmlDocument xmlDoc = new XmlDocument(); xmlDoc.XmlResolver = resolver; xmlDoc.LoadXml(xml); XXEResults.Text = string.Empty; foreach (XmlNode xn in xmlDoc) { switch (xn.Name) { case "user": XXEResults.Text = xn.InnerText; break; } } }
public IActionResult XXE() { string xml = RequestUtils.GetIfDefined(Request, "xml"); if (xml.Length <= 0) { @ViewData["result"] = "upload your request"; } else { var resolver = new XmlUrlResolver(); resolver.Credentials = CredentialCache.DefaultCredentials; var xmlDoc = new XmlDocument(); xmlDoc.XmlResolver = resolver; try { xmlDoc.LoadXml(xml); } catch (Exception) { } Show("Results of your request: " + string.Empty); foreach (XmlNode xn in xmlDoc) { if (xn.Name == "user") { Show("Results of your request: " + _javaScriptEncoder.Encode(xn.InnerText)); } } } return(View()); }
public XsltViewer() { this.SetStyle(ControlStyles.ResizeRedraw, true); this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true); this.SetStyle(ControlStyles.AllPaintingInWmPaint, true); InitializeComponent(); stripHeight = this.WebBrowser1.Top; xslt = new XslCompiledTransform(); settings = new XsltSettings(true, true); resolver = new XmlUrlResolver(); toolTip1.SetToolTip(this.BrowseButton, SR.BrowseButtonTooltip); toolTip1.SetToolTip(this.SourceFileName, SR.XslFileNameTooltip); toolTip1.SetToolTip(this.TransformButton, SR.TransformButtonTooltip); BrowseButton.Click += new EventHandler(BrowseButton_Click); this.SourceFileName.KeyDown += new KeyEventHandler(OnSourceFileNameKeyDown); this.WebBrowser1.ScriptErrorsSuppressed = true; this.WebBrowser1.WebBrowserShortcutsEnabled = true; }
/// <summary> /// Returns a string of the transformed XML /// </summary> /// <param name="doc">The document to transform</param> /// <param name="xslt">The XSLT to use</param> /// <param name="args">Arguments to pass into the transform</param> /// <returns>String of transformed XML</returns> public static string GetTransformedData(IXPathNavigable doc, string xslt, XsltArgumentList args) { if (doc == null) { return(null); } string content = string.Empty; using (MemoryStream stream = new MemoryStream()) { XslCompiledTransform transform = new XslCompiledTransform(); XmlUrlResolver resolver = new XmlUrlResolver(); resolver.Credentials = CredentialCache.DefaultCredentials; XsltSettings settings = new XsltSettings(true, true); transform.Load(xslt, settings, resolver); transform.Transform(doc.CreateNavigator(), args, stream); stream.Position = 0; StreamReader reader = new StreamReader(stream); content = reader.ReadToEnd(); } return(content); }
public override XmlReaderSettings GetXmlReaderSettings() { if (_xmlReaderSettings == null) { _xmlReaderSettings = new XmlReaderSettings(); _xmlReaderSettings.ValidationFlags = System.Xml.Schema.XmlSchemaValidationFlags.ProcessIdentityConstraints | System.Xml.Schema.XmlSchemaValidationFlags.ReportValidationWarnings; MemoryStream xpsSchemaStream = new MemoryStream(XpsS0Schema.S0SchemaBytes); MemoryStream dictionarySchemaStream = new MemoryStream(XpsS0Schema.DictionarySchemaBytes); XmlResolver resolver = new XmlUrlResolver(); _xmlReaderSettings.ValidationType = ValidationType.Schema; _xmlReaderSettings.Schemas.XmlResolver = resolver; _xmlReaderSettings.Schemas.Add(_xpsS0SchemaNamespace, new XmlTextReader(xpsSchemaStream)); _xmlReaderSettings.Schemas.Add(null, new XmlTextReader(dictionarySchemaStream)); } return(_xmlReaderSettings); }
/// <summary> /// Gets the XML document from the specified URL path. /// </summary> /// <param name="path">The path where the XML document can be found.</param> /// <param name="username">The username to use for authentication.</param> /// <param name="password">The password to use for authentication.</param> /// <param name="domain">The domain to use for authentication.</param> /// <returns>Returns the XML document from the specified URL path.</returns> public static XmlDocument GetXmlDocumentFromUrl(string path, string username, string password, string domain) { XmlDocument doc = new XmlDocument(); XmlUrlResolver resolver = new XmlUrlResolver(); if (String.IsNullOrEmpty(username) == false || String.IsNullOrEmpty(password) == false) { NetworkCredential credential = new NetworkCredential(username, password, domain); resolver.Credentials = credential; } doc.XmlResolver = resolver; try { doc.Load(GetAbsoluteUrl(path)); } catch (Exception ex) { return null; } return doc; }
public void Load (string url, XmlResolver resolver) { XmlResolver res = resolver; if (res == null) res = new XmlUrlResolver (); Uri uri = res.ResolveUri (null, url); using (Stream s = res.GetEntity (uri, null, typeof (Stream)) as Stream) { XmlTextReader xtr = new XmlTextReader (uri.ToString (), s); xtr.XmlResolver = res; XmlValidatingReader xvr = new XmlValidatingReader (xtr); xvr.XmlResolver = res; xvr.ValidationType = ValidationType.None; Load (new XPathDocument (xvr, XmlSpace.Preserve).CreateNavigator (), resolver, null); } }
private static XdmNode getSourceRoot(String src) { Debug.WriteLine("getting source root node for " + src); Uri uri = null; try { XmlUrlResolver resolver = new XmlUrlResolver(); uri = resolver.ResolveUri(null, src); //null sets the current location as the resolution base } catch (UriFormatException e) { Console.WriteLine("error getting transformation source '" + uri + "': " + e.Message); } Debug.WriteLine("resolved uri=" + uri.AbsolutePath); XdmNode doc = null; try { doc = builder.Build(uri); } catch (FileNotFoundException e) { Console.WriteLine("error getting transformation source: " + e.Message); } catch (XPathException e) { Console.WriteLine("error getting transformation source: " + e.Message); } return doc; }
/** * Construct an Environment * * @param xpc the XPathCompiler used to process the catalog file * @param env the Environment element in the catalog file * @param environments the set of environments to which this one should be added (may be null) * @return the constructed Environment object * @throws SaxonApiException */ private TestEnvironment processEnvironment(XPathCompiler xpc, XdmItem env, Dictionary<string, TestEnvironment> environments) { TestEnvironment environment = new TestEnvironment(); string name = ((XdmNode)env).GetAttributeValue(new QName("name")); environment.processor = new Processor(true); XmlUrlResolver res = new XmlUrlResolver(); if (generateByteCode == 1) { environment.processor.SetProperty(JFeatureKeys.GENERATE_BYTE_CODE, "true"); environment.processor.SetProperty(JFeatureKeys.DEBUG_BYTE_CODE, "false"); } else if (generateByteCode == 2) { environment.processor.SetProperty(JFeatureKeys.GENERATE_BYTE_CODE, "true"); environment.processor.SetProperty(JFeatureKeys.DEBUG_BYTE_CODE, "true"); } else { environment.processor.SetProperty(JFeatureKeys.GENERATE_BYTE_CODE, "false"); environment.processor.SetProperty(JFeatureKeys.DEBUG_BYTE_CODE, "false"); } environment.xpathCompiler = environment.processor.NewXPathCompiler(); environment.xpathCompiler.BaseUri = (((XdmNode)env).BaseUri).ToString(); environment.xqueryCompiler = environment.processor.NewXQueryCompiler(); environment.xqueryCompiler.BaseUri = (((XdmNode)env).BaseUri).ToString(); if (unfolded) { //environment.xqueryCompiler.getUnderlyingStaticContext().setCodeInjector(new LazyLiteralInjector()); } DocumentBuilder builder = environment.processor.NewDocumentBuilder(); environment.sourceDocs = new Dictionary<string, XdmNode>(); if (environments != null && name != null) { try { environments.Add(name, environment); }catch(Exception e){} } System.Collections.IEnumerator dependency = xpc.Evaluate("dependency", env).GetEnumerator(); while (dependency.MoveNext()) { if (!DependencyIsSatisfied((XdmNode)dependency.Current, environment)) { environment.usable = false; } } // set the base Uri if specified IEnumerator base1 = xpc.Evaluate("static-base-uri", env).GetEnumerator(); while (base1.MoveNext()) { string Uri = ((XdmNode)base1.Current).GetAttributeValue(new QName("uri")); try { environment.xpathCompiler.BaseUri = Uri; environment.xqueryCompiler.BaseUri = Uri; } catch (Exception e) { Console.WriteLine("**** invalid base Uri " + Uri); } } // set any requested collations base1 = xpc.Evaluate("collation", env).GetEnumerator(); while (base1.MoveNext()) { string uriStr = ((XdmNode)base1.Current).GetAttributeValue(new QName("uri")); string defaultAtt = ((XdmNode)base1.Current).GetAttributeValue(new QName("default")); Boolean defaultCol = false; if (defaultAtt != null && (defaultAtt.Trim().Equals("true") || defaultAtt.Trim().Equals("1"))) { defaultCol = true; } if (uriStr.Equals("http://www.w3.org/2010/09/qt-fots-catalog/collation/caseblind")) { net.sf.saxon.Configuration config = xpc.Processor.Implementation; net.sf.saxon.lib.StringCollator collator = config.getCollationURIResolver().resolve("http://saxon.sf.net/collation?ignore-case=yes", "", config); CompareInfo compareInfo = CultureInfo.CurrentCulture.CompareInfo; CompareOptions options = CompareOptions.IgnoreCase; environment.xpathCompiler.DeclareCollation(new Uri(uriStr), compareInfo, options, defaultCol); environment.xqueryCompiler.DeclareCollation(new Uri(uriStr), compareInfo, options, defaultCol); } } // declare the requested namespaces IEnumerator nsElement = xpc.Evaluate("namespace", env).GetEnumerator(); while (nsElement.MoveNext()) { string prefix = ((XdmNode)nsElement.Current).GetAttributeValue(new QName("prefix")); string uri = ((XdmNode)nsElement.Current).GetAttributeValue(new QName("uri")); environment.xpathCompiler.DeclareNamespace(prefix, uri); environment.xqueryCompiler.DeclareNamespace(prefix, uri); } // load the requested schema documents SchemaManager manager = environment.processor.SchemaManager; System.Collections.IEnumerator schema = xpc.Evaluate("schema", env).GetEnumerator(); while (schema.MoveNext()) { string href = ((XdmNode)schema.Current).GetAttributeValue(new QName("file")); manager.Compile((new Uri(((XdmNode)env).BaseUri, href))); } // load the requested source documents //IEnumerator source = xpc.Evaluate("source", env).GetEnumerator(); foreach (XdmItem source in xpc.Evaluate("source", env)) { Uri href = res.ResolveUri(((XdmNode)env).BaseUri, ((XdmNode)source).GetAttributeValue(new QName("file"))); string Uri = ((XdmNode)source).GetAttributeValue(new QName("uri")); string validation = ((XdmNode)source).GetAttributeValue(new QName("", "validation")); XdmNode doc = null; if (validation == null || validation.Equals("skip")) { try { doc = builder.Build(href); } catch (Exception e) { feedback.Message("Error:" + e.Message+" *** failed to build source document " + href, false); } } else { try { SchemaValidator validator = manager.NewSchemaValidator(); XdmDestination xdmDest = new XdmDestination(); validator.IsLax = validation.Equals("lax"); validator.SetDestination(xdmDest); validator.SetSource(href); validator.Run(); doc = xdmDest.XdmNode; environment.xpathCompiler.SchemaAware = true; environment.xqueryCompiler.SchemaAware = true; } catch(Exception e) { feedback.Message("Error:" + e.Message+" *** failed to build source document " + href, false); } } if (Uri != null) { environment.sourceDocs.Add(Uri, doc); } string role = ((XdmNode)source).GetAttributeValue(new QName("role")); if (role != null) { if (".".Equals(role)) { environment.contextNode = doc; } else if (role.StartsWith("$")) { string varName = role.Substring(1); environment.params1.Add(new QName(varName), doc); environment.xpathCompiler.DeclareVariable(new QName(varName)); environment.paramDeclarations.Append("declare variable $" + varName + " external; "); } } } // create a collection Uri resolved to handle the requested collections Hashtable collections = new Hashtable(); foreach (XdmItem coll in xpc.Evaluate("collection", env)) { string collectionUri = ((XdmNode)coll).GetAttributeValue(new QName("uri")); if (collectionUri == null || collectionUri.Equals("")) { collectionUri = "http://www.saxonica.com/defaultCollection"; } IList<Uri> docs = new List<Uri>(); foreach (XdmItem source in xpc.Evaluate("source", coll)) { Uri href = res.ResolveUri(((XdmNode)env).BaseUri, ((XdmNode)source).GetAttributeValue(new QName("file"))); //File file = new File((((XdmNode) env).GetBaseUri().resolve(href))); string id = ((XdmNode)source).GetAttributeValue(new QName(JNamespaceConstant.XML, "id")); XdmNode doc = builder.Build(href); if (id != null) { environment.sourceDocs.Add(id, doc); } environment.processor.RegisterCollection(href, getCollection(doc, href.AbsoluteUri)); environment.sourceDocs.Add(href.ToString(), doc); docs.Add(doc.DocumentUri); } try { collections.Add(new Uri(collectionUri), docs); } catch (Exception e) { feedback.Message("**** Invalid collection Uri " + collectionUri, false); } } if (collections.Count != 0) { environment.processor.Implementation.setCollectionURIResolver(new CollectionResolver(collections)); /* new net.sf.saxon.lib.CollectionURIResolver() { public SequenceIterator resolve(string href, string base, XPathContext context) { try { List<AnyUriValue> docs; if (href == null) { docs = collections.get(new Uri("")); } else { Uri abs = new Uri(base).resolve(href); docs = collections.get(abs); } if (docs == null) { return EmptyIterator.getInstance(); } else { return new ListIterator(docs); } } catch (UriSyntaxException e) { Console.WriteLine("** Invalid Uri: " + e.Message); return EmptyIterator.getInstance(); } } } )*/ } // register any required decimal formats IEnumerator decimalFormat = xpc.Evaluate("decimal-format", env).GetEnumerator(); while (decimalFormat.MoveNext()) { XdmNode formatElement = (XdmNode) decimalFormat.Current; string formatName = formatElement.GetAttributeValue(new QName("name")); QName formatQName = null; if (formatName != null) { if (formatName.IndexOf(':') < 0) { formatQName = new QName("", "", formatName); } else { try { formatQName = new QName(environment.xpathCompiler.GetNamespaceURI(formatName, false), formatName.Substring(formatName.IndexOf(':')+1)); } catch (Exception) { feedback.Message("**** Invalid QName as decimal-format name", false); formatQName = new QName("", "", "error-name"); } } environment.paramDecimalDeclarations.Append("declare decimal-format " + formatName + " "); } else { environment.paramDecimalDeclarations.Append("declare default decimal-format "); } foreach (XdmItem decimalFormatAtt in xpc.Evaluate("@* except @name", formatElement)) { XdmNode formatAttribute = (XdmNode) decimalFormatAtt; string property = formatAttribute.NodeName.LocalName; string value = formatAttribute.StringValue; environment.paramDecimalDeclarations.Append(property + "=\"" + value + "\" "); environment.xpathCompiler.SetDecimalFormatProperty(formatQName, property, value); } environment.paramDecimalDeclarations.Append(";"); } // declare any variables IEnumerator param = xpc.Evaluate("param", env).GetEnumerator(); while (param.MoveNext()) { string varName = ((XdmNode)param.Current).GetAttributeValue(new QName("name")); XdmValue value = null; string sourceStr = ((XdmNode)param.Current).GetAttributeValue(new QName("source")); if (sourceStr != null) { XdmNode sourceDoc = (XdmNode)(environment.sourceDocs[sourceStr]); if (sourceDoc == null) { Console.WriteLine("**** Unknown source document " + sourceDoc.ToString()); } value = sourceDoc; } else { string select = ((XdmNode)param.Current).GetAttributeValue(new QName("select")); value = xpc.Evaluate(select, null); } environment.params1.Add(new QName(varName), value); environment.xpathCompiler.DeclareVariable(new QName(varName)); string declared = ((XdmNode)param.Current).GetAttributeValue(new QName("declared")); if (declared != null && "true".Equals(declared) || "1".Equals(declared)) { // no action } else { environment.paramDeclarations.Append("declare variable $" + varName + " external; "); } } return environment; }
static TextReader GetReader (string filename) { XmlResolver resolver = new XmlUrlResolver (); Stream stream = resolver.GetEntity (resolver.ResolveUri (null, filename), null, typeof (Stream)) as Stream; if (useDecentReader) return new XmlSignatureStreamReader ( new StreamReader (stream)); else return new StreamReader (stream); }
private XmlReader GetXmlReader (string url) { XmlResolver res = new XmlUrlResolver (); Uri uri = res.ResolveUri (null, url); Stream s = res.GetEntity (uri, null, typeof (Stream)) as Stream; XmlTextReader xtr = new XmlTextReader (uri.ToString (), s); xtr.XmlResolver = res; XmlValidatingReader xvr = new XmlValidatingReader (xtr); xvr.XmlResolver = res; xvr.ValidationType = ValidationType.None; return xvr; }
private bool LoadSchema(string uri) { uri = _NameTable.Add(uri); if (_SchemaInfo.HasSchema(uri)) { return false; } SchemaInfo schemaInfo = null; XmlResolver resolver = new XmlUrlResolver(); Uri _baseUri = resolver.ResolveUri(null,_reader.BaseURI); XmlReader reader = null; try { Uri ruri = resolver.ResolveUri(_baseUri, uri.Substring(x_schema.Length)); Stream stm = (Stream)resolver.GetEntity(ruri,null,null); reader = new XmlTextReader(ruri.ToString(), stm, _NameTable); schemaInfo = new SchemaInfo(_SchemaNames); new Parser(null, _NameTable, _SchemaNames, validationEventHandler).Parse(reader, uri, schemaInfo); } catch(XmlException e) { SendValidationEvent(Res.Sch_CannotLoadSchema, new string[] {uri, e.Message}, XmlSeverityType.Warning); schemaInfo = null; } finally { if (reader != null) { reader.Close(); } } if (schemaInfo != null && schemaInfo.ErrorCount == 0) { _SchemaInfo.Add(uri, schemaInfo, validationEventHandler); return true; } return false; }
public void TransformXml(string[] parts) { XsltSettings XSLSettings = new XsltSettings(); XSLSettings.EnableDocumentFunction = true; XmlUrlResolver resolver = new XmlUrlResolver(); XslCompiledTransform xsl = new XslCompiledTransform(); xsl.Load(root + "/templates/global.xsl", XSLSettings, resolver); timmie.timmie timmie = new timmie.timmie(); XsltArgumentList args = new XsltArgumentList(); args.AddExtensionObject(timmie.nameSpaceURI, timmie); xsl.Transform(CreateContext(parts), args, HttpContext.Current.Response.Output); }
public ModuleResolver(XPathCompiler xpc) { this.catXPC = xpc; resolver = new XmlUrlResolver(); }
private XmlReader validateRequest(Stream inputStream) { //load instance into memory XmlReaderSettings settings = new XmlReaderSettings(); settings.Schemas.Add(null, Server.MapPath(".") + "\\wsrequest.xsd"); //add resolver to pass security if accessing web site to recieve schemaXmlUrlResolver XmlUrlResolver resolver = new XmlUrlResolver(); resolver.Credentials = System.Net.CredentialCache.DefaultCredentials; settings.XmlResolver = resolver; settings.ValidationType = ValidationType.Schema; //this line is neccessary for validation to settings.ValidationEventHandler += new ValidationEventHandler(xvr_ValidationEventHandler); return XmlReader.Create(inputStream, settings); }
public net.sf.saxon.om.SequenceIterator resolve(string href, string baseStr, net.sf.saxon.expr.XPathContext context) { try { List<Uri> docs; if (href == null) { docs = (List<Uri>)collections[new Uri("http://www.saxonica.com/defaultCollection")]; } else { XmlUrlResolver res = new XmlUrlResolver(); Uri abs= res.ResolveUri(new Uri(baseStr), href); docs = (List<Uri>)collections[abs]; } if (docs == null) { return net.sf.saxon.tree.iter.EmptyIterator.getInstance(); } else { java.util.List list = new java.util.ArrayList(); foreach(Uri uri in docs){ list.add(new net.sf.saxon.value.AnyURIValue(uri.ToString())); } return new net.sf.saxon.tree.iter.ListIterator(list); } } catch (java.net.URISyntaxException e) { Console.WriteLine("** Invalid Uri: " + e.Message); return net.sf.saxon.tree.iter.EmptyIterator.getInstance(); } }
//Public Methods /// <include file='doc\XmlSchemaSet.uex' path='docs/doc[@for="XmlSchemaSet.Add1"]/*' /> /// <devdoc> /// <para>Add the schema located by the given URL into the schema schemas. /// If the given schema references other namespaces, the schemas for those other /// namespaces are NOT automatically loaded.</para> /// </devdoc> public XmlSchema Add(String targetNamespace, String schemaUri) { if (schemaUri == null || schemaUri.Length == 0) { throw new ArgumentNullException("schemaUri"); } if (targetNamespace != null) { targetNamespace = XmlComplianceUtil.CDataNormalize(targetNamespace); } XmlSchema schema = null; lock (InternalSyncObject) { //Check if schema from url has already been added XmlResolver tempResolver = readerSettings.GetXmlResolver(); if ( tempResolver == null ) { tempResolver = new XmlUrlResolver(); } Uri tempSchemaUri = tempResolver.ResolveUri(null, schemaUri); if (IsSchemaLoaded(tempSchemaUri, targetNamespace, out schema)) { return schema; } else { //Url already not processed; Load SOM from url XmlReader reader = XmlReader.Create(schemaUri, readerSettings); try { schema = Add(targetNamespace, ParseSchema(targetNamespace, reader)); //TODO can move parsing outside lock boundary while(reader.Read());// wellformness check; } finally { reader.Close(); } } } return schema; }