public static void CopyAdditionalParams(Dictionary<string, string> additionalParams, XsltArgumentList arguments) { foreach (KeyValuePair<string, string> pair in additionalParams) { arguments.AddParam(pair.Key, "", pair.Value); } }
public static void XTransformToWriter(this Linq.XElement xmlDoc, TextWriter writer, Linq.XElement xmlXslt = null, // Action<XslCompiledTransform> onXsltLoad = null, object xsltExtension = null, string urn = "urn:request-info") { XslCompiledTransform trans = new XslCompiledTransform(); //if (onXsltLoad != null) // onXsltLoad(trans); //else trans.Load(xmlXslt.CreateReader()); if (xsltExtension != null) { XsltArgumentList xslArg = new XsltArgumentList(); xslArg.AddExtensionObject(urn, xsltExtension); // XTransformTo(trans, xmlDoc.CreateReader(), xslArg, writer); // var results = writer; XmlReader input = xmlDoc.CreateReader(); XmlWriterSettings outputSettings = trans.OutputSettings; using (XmlWriter writerXml = XmlWriter.Create(writer, outputSettings)) { trans.Transform(input, arguments: xslArg, results: writerXml, documentResolver: XmlNullResolver.Singleton); // XsltConfigSection.CreateDefaultResolver()); writerXml.Close(); } } else { // trans.Transform(xmlDoc.CreateNavigator() as IXPathNavigable, arguments: null, results: writer); XTransformTo(trans, xmlDoc.CreateReader(), null, writer); } }
private void RenderRelatedNews() { if (Request.QueryString[ConstantsManager.NewsGUID] == null) return; //int _newsID = 0; Int32.TryParse(Request.QueryString[ConstantsManager.NewsID], out _newsID); //if (_newsID == 0) // return; string guid = Request.QueryString[ConstantsManager.NewsGUID].ToString(); NewsItem _news = NewsItemManager.GetByGUID(guid); if (null == _news) return; XmlDocument xDoc = NewsItemManager.GetNewsByKeywordAsXML(_news.Keywords, _news.ID); if (null == xDoc) return; XslTemplate xslTemplate = XslTemplateManager.GetByID(XSLID); if (null == xslTemplate) return; XsltArgumentList arguments = new XsltArgumentList(); arguments.AddExtensionObject("obj:CategoryViewer", this); _news.Keywords = ""; _news.ViewCount++; NewsItemManager.Update(_news); string _html = UtilitiesManager.TransformXMLWithXSLText(xDoc.OuterXml, xslTemplate.Details, arguments); dvData.InnerHtml = _html; }
void LoadMenuItem() { int menuID = 0; int.TryParse(Request.QueryString[CMSConfig.QueryString.MenuID], out menuID); if (base.XSLTemplateID > 0 && menuID > 0) { string xslPath = CMSWebHelper.GetXSLTemplateFilePath(base.XSLTemplateID); xslPath = XSLTemplateManager.GetXSLTemplatePath(xslPath, base.XSLTemplateID); XsltArgumentList arguments = new XsltArgumentList(); arguments.AddExtensionObject("CMS:UserControl", this); Menu menu = new Menu(); xmlMenu.DocumentContent = MenuManager.GetMenuItemTemplateXml(menuID, CMSContext.LanguageID, out menu); xmlMenu.TransformSource = xslPath; xmlMenu.TransformArgumentList = arguments; xmlMenu.DataBind(); bool SetPageTitle = false; bool.TryParse(this.Attributes["SetPageTitle"], out SetPageTitle); if (SetPageTitle && menu != null) { this.Page.Title = menu.Name; } } }
public new void Init(object objParam) { // Get parameter info _strPath = Path.Combine(@"TestFiles\", FilePathUtil.GetTestDataPath(), @"XsltApi\"); xsltArg1 = new XsltArgumentList(); MyObject obj1 = new MyObject(1, _output); MyObject obj2 = new MyObject(2, _output); MyObject obj3 = new MyObject(3, _output); MyObject obj4 = new MyObject(4, _output); MyObject obj5 = new MyObject(5, _output); xsltArg1.AddExtensionObject("urn:my-obj1", obj1); xsltArg1.AddExtensionObject("urn:my-obj2", obj2); xsltArg1.AddExtensionObject("urn:my-obj3", obj3); xsltArg1.AddExtensionObject("urn:my-obj4", obj4); xsltArg1.AddExtensionObject("urn:my-obj5", obj5); xsltArg1.AddParam("myArg1", szEmpty, "Test1"); xsltArg1.AddParam("myArg2", szEmpty, "Test2"); xsltArg1.AddParam("myArg3", szEmpty, "Test3"); xsltArg1.AddParam("myArg4", szEmpty, "Test4"); xsltArg1.AddParam("myArg5", szEmpty, "Test5"); return; }
public void AddExtensionObject_LinkDemand () { // requires FullTrust, so denying anything break the requirements Assert.IsNotNull (addExtensionObject, "AddExtensionObject"); XsltArgumentList xal = new XsltArgumentList (); addExtensionObject.Invoke (xal, new object[2] { "http://www.go-mono.com", new object () }); }
public Program() { //Set the UI to the specified culture. Thread.CurrentThread.CurrentUICulture = new CultureInfo(_culturename); //Create the XslTransform and load the stylesheet. //XslTransform xslt = new XslTransform(); XslCompiledTransform xslt = new XslCompiledTransform(); xslt.Load(_stylesheet); //Load the XML data file. XPathDocument doc = new XPathDocument(_filename); //Create an XsltArgumentList. XsltArgumentList xslArg = new XsltArgumentList(); //Add an object to get the resources for the specified language. ResourceTranslator resTran = new ResourceTranslator("Resources.Resource"); xslArg.AddExtensionObject("urn:myResTran", resTran); //Add an object to calculate the circumference of the circle. Calculate obj = new Calculate(); xslArg.AddExtensionObject("urn:myObj", obj); //Create an XmlTextWriter to output to the console. XmlTextWriter writer = new XmlTextWriter(Console.Out); //Transform the file. xslt.Transform(doc, xslArg, writer, null); writer.Close(); }
public static string Transform(string xml,string xslFile) { XslTransform transform = new XslTransform(); XsltArgumentList args = new XsltArgumentList(); //define the xslt rendering file //get the iterators for the root and context item XPathDocument xmlDoc = new XPathDocument(new StringReader(xml)); XPathNavigator iter = xmlDoc.CreateNavigator(); //define and add the xslt extension classes //Sitecore.Xml.Xsl.XslHelper sc = new Sitecore.Xml.Xsl.XslHelper(); XsltHelper xslt = new XsltHelper(); args.AddExtensionObject("http://www.rlmcore.vn/helper", xslt); //add parameters args.AddParam("item", "", iter); args.AddParam("currentitem", "", iter.Select(".")); //define the stream which will contain the result of xslt transformation //StringBuilder sb = new StringBuilder(); //TextWriter stream = new FileStream(new MemoryStream(Encoding.ASCII.GetBytes(sb.ToString()))); System.IO.StringWriter stream = new System.IO.StringWriter(); //load xslt rendering to XslTransform class transform.Load(xslFile); //perform a transformation with the rendering transform.Transform(iter, args, stream); return stream.ToString(); }
public string RenderComponentFieldAsBBCode(string fieldExpression, int fieldIndex, bool outputImages) { BuiltInFunctions functions = new BuiltInFunctions(_engine, _package); string output = functions.RenderComponentField(fieldExpression, fieldIndex); StringReader sr = new StringReader(output); NameTable nt = new NameTable(); XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt); nsmgr.AddNamespace("tcdl", Tridion.ContentManager.Templating.TcdlTags.TcdlNamespace); XmlParserContext parserContext = new XmlParserContext(null, nsmgr, null, XmlSpace.None); XmlReader xmlReader = XmlReader.Create(sr, new XmlReaderSettings(), parserContext); XslCompiledTransform transform = new XslCompiledTransform(true); using (Stream xsltStream = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("Tridion.ContentManager.Templating.Expression.NetbiscuitsFunctions.XhtmlToBBCode.xslt")) { using (XmlReader xsltReader = XmlReader.Create(xsltStream)) { transform.Load(xsltReader); } } StringWriter resultWriter = new StringWriter(); XsltArgumentList argumentList = new XsltArgumentList(); argumentList.AddParam("IncludeImages", String.Empty, outputImages); transform.Transform(xmlReader, argumentList, resultWriter); return resultWriter.ToString(); }
/// <summary> /// Performs a XSL Transformation /// </summary> /// <param name="styleSheet">Style Sheet path relative to Application Base directory</param> /// <param name="xslArguments">XSL Arguments</param> /// <param name="inputStream">Input Stream</param> /// <param name="outputStream">Out put Stream as Ref (output Stream is initialized if it is null</param> public void Transform(String styleSheet, Dictionary<String, String> xslArguments, Stream inputStream, ref Stream outputStream) { try { XsltSettings xsltSettings = new XsltSettings(); xsltSettings.EnableScript = true; xsltSettings.EnableDocumentFunction = true; XsltArgumentList xslArgumentList = new XsltArgumentList(); foreach (String key in xslArguments.Keys) { xslArgumentList.AddParam(key, "", xslArguments[key]); } XslCompiledTransform transformer = new XslCompiledTransform(); String stylesheetpath = AppDomain.CurrentDomain.BaseDirectory + styleSheet; transformer.Load(stylesheetpath, xsltSettings, new XmlUrlResolver()); if (null == outputStream) { outputStream = new MemoryStream(); } StreamWriter streamWriter = new StreamWriter(outputStream); XmlReaderSettings xmlReaderSettings = new XmlReaderSettings(); xmlReaderSettings.DtdProcessing = DtdProcessing.Ignore; XmlReader xmlReader = XmlReader.Create(inputStream, xmlReaderSettings); XmlTextWriter writer = new XmlTextWriter(outputStream,System.Text.Encoding.UTF8); writer.Formatting = Formatting.None; transformer.Transform(xmlReader, xslArgumentList, writer); } catch (Exception exception) { throw exception; } }
public static IGraph CreateNuspecGraph(XDocument nuspec, string baseAddress) { nuspec = NormalizeNuspecNamespace(nuspec); XslCompiledTransform transform = CreateTransform("xslt.nuspec.xslt"); XsltArgumentList arguments = new XsltArgumentList(); arguments.AddParam("base", "", baseAddress + "packages/"); arguments.AddParam("extension", "", ".json"); arguments.AddExtensionObject("urn:helper", new XsltHelper()); XDocument rdfxml = new XDocument(); using (XmlWriter writer = rdfxml.CreateWriter()) { transform.Transform(nuspec.CreateReader(), arguments, writer); } RdfXmlParser rdfXmlParser = new RdfXmlParser(); XmlDocument doc = new XmlDocument(); doc.Load(rdfxml.CreateReader()); IGraph graph = new Graph(); rdfXmlParser.Load(graph, doc); return graph; }
/// <summary> /// This function retuns list of states for a given country as XML Document in a string /// and this value is used in client side java script to populate state combo box. /// Functionality: Transform the CountriesAndStates xml string into another XML string having the single country /// and states under that country. /// </summary> public string GetStatesXMLString(string countryName) { //Creates a XslTransform object and load the CountriesAndStates.xsl file XslTransform transformToCountryNode = new XslTransform(); transformToCountryNode.Load(new XPathDocument(HttpContext.Current.Server.MapPath("~/xmlxsl/CountriesAndStates.xsl")).CreateNavigator(), new XmlUrlResolver()); //TransformToCountryNode.Load(new XPathDocument(HttpContext.Current.Server.MapPath("~/xmlxsl/CountriesAndStates.xsl")).CreateNavigator(), new XmlUrlResolver(), this.GetType().Assembly.Evidence); //Creating the XSLT parameter country-name and setting the value XsltArgumentList xslArgs = new XsltArgumentList(); xslArgs.AddParam("country-name", "", countryName); // Memory stream to store the result of XSL transform MemoryStream countryNodeMemoryStream = new MemoryStream(); XmlTextWriter countryNodeXmlTextWriter = new XmlTextWriter(countryNodeMemoryStream, Encoding.UTF8); countryNodeXmlTextWriter.WriteProcessingInstruction("xml", "version='1.0' encoding='UTF-8'"); //transforming the current XML string to get the state XML string transformToCountryNode.Transform(xPathDoc, xslArgs, countryNodeXmlTextWriter); //TransformToCountryNode.Transform(XPathDoc, XslArgs, CountryNodeXmlTextWriter, null); //reading the XML string using StreamReader and return the same countryNodeXmlTextWriter.Flush(); countryNodeMemoryStream.Position = 0; StreamReader countryNodeStreamReader = new StreamReader(countryNodeMemoryStream); return countryNodeStreamReader.ReadToEnd(); }
protected void Button1_Click(object sender, EventArgs e) { XsltArgumentList argsList = new XsltArgumentList(); argsList.AddParam("calories", "", TextBox1.Text); Xml1.TransformArgumentList = argsList; Xml1.Visible = true; }
/// <summary> /// Writes the results of XSLT transformation into the specified TextWriter. /// </summary> public static void WriteProcessed(string templateName, XsltArgumentList argumentList, XDocument data, TextWriter outStream) { using (XmlReader reader = data.CreateReader()) { GetCompiledTransform(templateName).Transform(reader, argumentList, outStream); } }
private string ToHtml() { if (Services.StrandsCache.Contains(this)) { return Services.StrandsCache.Read(this); } else { var transform = new XslCompiledTransform(true); var arguments = new XsltArgumentList(); var settings = new XsltSettings(); var readersettings = new XmlReaderSettings(); //string xslsrc = (!string.IsNullOrEmpty(this.DisplayType)) ? "/XMLList.xsl" : "/Strands.xsl"; //var xslfile = (this.Name == "themes") ? HttpContext.Current.Server.MapPath(this._xslAppUrl + "/StrandList.xsl") : HttpContext.Current.Server.MapPath(this._xslAppUrl + xslsrc); var xslfile = HttpContext.Current.Server.MapPath(this._xslAppUrl + ((!string.IsNullOrEmpty(this.DisplayType)) ? "XMLList.xsl" : this.XslName)); settings.EnableDocumentFunction = true; settings.EnableScript = true; readersettings.DtdProcessing = DtdProcessing.Parse; readersettings.ValidationType = ValidationType.None; transform.Load(xslfile, settings, new XmlUrlResolver()); arguments = TransformArguments(this); using (XmlReader reader = XmlReader.Create(this.GetDirectoryPath(), readersettings)) { System.IO.StringWriter writer = new System.IO.StringWriter(); transform.Transform(reader, arguments, writer); return Services.StrandsCache.Write(this, writer.ToString()); } } }
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, System.Net.Http.HttpContent content, System.Net.TransportContext transportContext) { var taskSource = new TaskCompletionSource<object>(); try { var xml = (XmlNode) value; var documentElement = ((XmlDocument)value).DocumentElement; if (documentElement != null && documentElement.LocalName == "RDF") { ((XmlDocument)xml).Save(writeStream); } else { var parameters = new XsltArgumentList(); var transform = XsltRepository.Get("RdfToHtml.xslt"); transform.Transform(xml, parameters, writeStream); } taskSource.SetResult(null); } catch (Exception e) { taskSource.SetException(e); } return taskSource.Task; }
/////////////////////////////////////////////////////////////////////////////// // // Transform the input xml into the output file. // /////////////////////////////////////////////////////////////////////////////// private void _transform(XmlDocument xml, String xlstfile, String outfile) { XslTransform xlst = new XslTransform(); String xlstDir = _resourceFileDirectory(); xlst.Load(xlstDir + xlstfile); System.Xml.Xsl.XsltArgumentList args = new System.Xml.Xsl.XsltArgumentList(); System.IO.FileInfo info = new System.IO.FileInfo(outfile); System.IO.FileStream output; if (info.Exists) { output = new System.IO.FileStream(outfile, System.IO.FileMode.Truncate); } else { output = new System.IO.FileStream(outfile, System.IO.FileMode.Create); } xlst.Transform(xml.CreateNavigator(), args, output); output.Close(); }
private void DrawProfilesModule() { XsltArgumentList args = new XsltArgumentList(); XslCompiledTransform xslt = new XslCompiledTransform(); SessionManagement sm = new SessionManagement(); Utilities.DataIO data = new Profiles.Profile.Utilities.DataIO(); string email = string.Empty; string imageemailurl = string.Empty; if (this.BaseData.SelectSingleNode("rdf:RDF[1]/rdf:Description[1]/prns:emailEncrypted", this.Namespaces) != null && this.BaseData.SelectSingleNode("rdf:RDF[1]/rdf:Description[1]/vivo:email", this.Namespaces) == null) { email = this.BaseData.SelectSingleNode("rdf:RDF[1]/rdf:Description[1]/prns:emailEncrypted", this.Namespaces).InnerText; imageemailurl = string.Format(Root.Domain + "/profile/modules/CustomViewPersonGeneralInfo/" + "EmailHandler.ashx?msg={0}", HttpUtility.UrlEncode(email)); } args.AddParam("root", "", Root.Domain); if (email != string.Empty) { args.AddParam("email", "", imageemailurl); } args.AddParam("imgguid", "", Guid.NewGuid().ToString()); litPersonalInfo.Text = XslHelper.TransformInMemory(Server.MapPath("~/Profile/Modules/CustomViewPersonGeneralInfo/CustomViewPersonGeneralInfo.xslt"), args, base.BaseData.OuterXml); if (base.BaseData.SelectSingleNode("rdf:RDF/rdf:Description[1]/prns:mainImage/@rdf:resource", base.Namespaces) != null) { string imageurl = base.BaseData.SelectSingleNode("//rdf:RDF/rdf:Description[1]/prns:mainImage/@rdf:resource", base.Namespaces).Value; imgPhoto.ImageUrl = imageurl + "&cachekey=" + Guid.NewGuid().ToString(); } else { imgPhoto.Visible = false; } }
public void Transform(string inputFilePath, string outputFilePath, KeyValueConfigurationCollection settings) { var xsltTemplateReader = new XmlTextReader(inputFilePath); var emptyDocumentReader = XmlReader.Create(new System.IO.StringReader("<empty />")); var writerSettings = new XmlWriterSettings(); //settings.ConformanceLevel = ConformanceLevel.Fragment; writerSettings.Indent = true; using (var outputWriter = XmlWriter.Create(outputFilePath, writerSettings)) { var xsltSettings = new XsltSettings(); XsltArgumentList argumentList = new XsltArgumentList(); var extensions = new XsltExtensionMethods(settings); argumentList.AddExtensionObject("http://core.com/config", extensions); argumentList.AddExtensionObject("http://setty.net/config", extensions); var transformer = new XslCompiledTransform(true); transformer.Load(xsltTemplateReader, xsltSettings, null); transformer.Transform(emptyDocumentReader, argumentList, outputWriter); } }
public void Transform() { var xsltTemplateReader = new XmlTextReader(_xsltPath); var emptyDocumentReader = XmlReader.Create(new System.IO.StringReader("<empty />")); var settings = new XmlWriterSettings(); //settings.ConformanceLevel = ConformanceLevel.Fragment; settings.Indent = true; using (var outputWriter = XmlWriter.Create(_outputPath, settings)) { var xsltSettings = new XsltSettings(); XsltArgumentList argumentList = new XsltArgumentList(); var extensions = new XsltExtensionMethods(_settings); argumentList.AddExtensionObject("http://core.com/config", extensions); argumentList.AddExtensionObject("http://paralect.com/config", extensions); var transformer = new XslCompiledTransform(true); transformer.Load(xsltTemplateReader, xsltSettings, null); transformer.Transform(emptyDocumentReader,argumentList, outputWriter); } }
public static string Transform (string xml, XslCompiledTransform xslTrans, IDictionary<string, string> xslParams) { if (xml.Trim ().Length == 0) return String.Empty; XmlDocument xmlDoc = new XmlDocument (); xmlDoc.LoadXml (xml); XsltArgumentList xslArgs = null; if (xslParams != null) { xslArgs = new XsltArgumentList (); foreach (string paramName in xslParams.Keys) { xslArgs.AddParam (paramName, "", xslParams [paramName]); } } using (StringWriter sw = new StringWriter()) { xslTrans.Transform(xmlDoc, xslArgs, sw); return sw.ToString(); } }
/// <exclude /> public static void Register(XsltArgumentList argumentList) { foreach(string providerName in XslExtensionsProviderRegistry.XslExtensionsProviderNames) { List<Pair<string, object>> extensions; try { extensions = XslExtensionsProviderPluginFacade.CreateExtensions(providerName); } catch(Exception ex) { string message = "Failed to get xsl extensions from provider '{0}'".FormatWith(providerName); LoggingService.LogError("XslExtensionsManager", new InvalidOperationException(message, ex)); continue; } if(extensions != null) { foreach (Pair<string, object> pair in extensions) { argumentList.AddExtensionObject(pair.First, pair.Second); } } } }
private void GenerateSinglePage(string kind, string kindName, string name, string slug, string title) { string filename = Path.Combine(this.OutputDirectory, slug + "." + this.FileSuffix); Dictionary<string, XElement> inputXml = new Dictionary<string, XElement>(); var type = inputDocument.Elements("type").Where(c => c.Attribute("kind").Value == kind && c.Attribute("name").Value == name).Single(); InsertExamples(type); using (var reader = inputDocument.CreateReader()) { using (XmlWriter writer = XmlWriter.Create(filename + ".tmp", new XmlWriterSettings { OmitXmlDeclaration = true })) { XsltArgumentList arguments = new XsltArgumentList(); arguments.AddParam("kind", "", kind); arguments.AddParam("kindName", "", kindName); arguments.AddParam("name", "", name); arguments.AddParam("slug", "", slug); arguments.AddParam("mode", "", this.Mode); transform.Transform(reader, arguments, writer); } } PostProcessFile(filename + ".tmp"); RewriteIfChanged(filename); }
public void Render(object source, HtmlTextWriter htmlWriter, TemplateDefinition liveDefinition) { var resolver = new PathResolver(liveDefinition.Folder); var hostPage = DNNContext.Current.Page; var args = new XsltArgumentList(); args.AddExtensionObject("urn:ddrmenu", new XsltFunctions()); args.AddExtensionObject("urn:dnngarden", new XsltFunctions()); args.AddParam("ControlID", "", DNNContext.Current.HostControl.ClientID); args.AddParam("Options", "", ConvertToJson(liveDefinition.ClientOptions)); args.AddParam("DNNPath", "", hostPage.ResolveUrl(resolver.Resolve("/", PathResolver.RelativeTo.Dnn))); args.AddParam("ManifestPath", "", hostPage.ResolveUrl(resolver.Resolve("/", PathResolver.RelativeTo.Manifest))); args.AddParam("PortalPath", "", hostPage.ResolveUrl(resolver.Resolve("/", PathResolver.RelativeTo.Portal))); args.AddParam("SkinPath", "", hostPage.ResolveUrl(resolver.Resolve("/", PathResolver.RelativeTo.Skin))); liveDefinition.TemplateArguments.ForEach(a => args.AddParam(a.Name, "", a.Value)); HttpContext.Current.Items["Resolver"] = resolver; using (var xmlStream = new MemoryStream()) { Utilities.SerialiserFor(source.GetType()).Serialize(xmlStream, source); xmlStream.Seek(0, SeekOrigin.Begin); xsl.Transform(XmlReader.Create(xmlStream), args, htmlWriter); } }
public XPathContext(XPathContext parent) : base((NameTable)parent.NameTable) { this.parent = parent; Arguments = new XsltArgumentList(); functions = new Dictionary<string, Func<IXsltContextFunction>>(); }
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(); }
public static void TransformHtml(XmlSerializer serializer, object report, Type reportType, string outputFilePath, GeneratorConfiguration generatorConfiguration, string xsltFile) { var xmlOutputWriter = new StringWriter(); serializer.Serialize(xmlOutputWriter, report); XslCompiledTransform xslt = new XslCompiledTransform(); var xsltSettings = new XsltSettings(true, false); XmlResolver resourceResolver; var reportName = reportType.Name.Replace("Generator", ""); using (var xsltReader = GetTemplateReader(reportType, reportName, xsltFile)) { resourceResolver = new XmlResourceResolver(); xslt.Load(xsltReader, xsltSettings, resourceResolver); } var xmlOutputReader = new XmlTextReader(new StringReader(xmlOutputWriter.ToString())); XsltArgumentList argumentList = new XsltArgumentList(); argumentList.AddParam("feature-language", "", generatorConfiguration.FeatureLanguage.Name); argumentList.AddParam("tool-language", "", generatorConfiguration.ToolLanguage.Name); using (var xmlTextWriter = new XmlTextWriter(outputFilePath, Encoding.UTF8)) { xslt.Transform(xmlOutputReader, argumentList, xmlTextWriter, resourceResolver); } }
void LoadCategory() { if (base.XSLTemplateID > 0) { int ParentCategoryID = 0; if (base.ContainerValue > 0) { ParentCategoryID = base.ContainerValue; } else { int.TryParse(Request.QueryString[CMSConfig.QueryString.CategoryID], out ParentCategoryID); } string categoryXML = CategoryManager.GetCategoryPublishXML(base.ModuleID, ParentCategoryID); string xslPath = CMSWebHelper.GetXSLTemplateFilePath(base.XSLTemplateID); xslPath = XSLTemplateManager.GetXSLTemplatePath(xslPath, base.XSLTemplateID); XsltArgumentList arguments = new XsltArgumentList(); arguments.AddExtensionObject("CMS:UserControl", this); xmlCategory.DocumentContent = categoryXML; xmlCategory.TransformSource = xslPath; xmlCategory.TransformArgumentList = arguments; xmlCategory.DataBind(); } }
/// <summary> /// Creates an instance of the given type from the specified Internet resource. /// </summary> /// <param name="htmlUrl">The requested URL, such as "http://Myserver/Mypath/Myfile.asp".</param> /// <param name="xsltUrl">The URL that specifies the XSLT stylesheet to load.</param> /// <param name="xsltArgs">An <see cref="XsltArgumentList"/> containing the namespace-qualified arguments used as input to the transform.</param> /// <param name="type">The requested type.</param> /// <param name="xmlPath">A file path where the temporary XML before transformation will be saved. Mostly used for debugging purposes.</param> /// <returns>An newly created instance.</returns> public object CreateInstance(string htmlUrl, string xsltUrl, XsltArgumentList xsltArgs, Type type, string xmlPath) { StringWriter sw = new StringWriter(); XmlTextWriter writer = new XmlTextWriter(sw); if (xsltUrl == null) { LoadHtmlAsXml(htmlUrl, writer); } else { if (xmlPath == null) { LoadHtmlAsXml(htmlUrl, xsltUrl, xsltArgs, writer); } else { LoadHtmlAsXml(htmlUrl, xsltUrl, xsltArgs, writer, xmlPath); } } writer.Flush(); StringReader sr = new StringReader(sw.ToString()); XmlTextReader reader = new XmlTextReader(sr); XmlSerializer serializer = new XmlSerializer(type); object o; try { o = serializer.Deserialize(reader); } catch (InvalidOperationException ex) { throw new Exception(ex + ", --- xml:" + sw); } return o; }
/// <summary> /// Return new instance of <see cref="XsltArgumentList"/> object with added <see cref="XsltScriptHelpers"/> as extension object. /// </summary> /// <returns>New instance of <see cref="XsltArgumentList"/>.</returns> public static XsltArgumentList GetDefaultArguments() { XsltArgumentList xslt_args = new XsltArgumentList (); xslt_args.AddExtensionObject ("urn:script", new XsltScriptHelpers ()); return xslt_args; }
// // .ctor // public System.Xml.XPath.XPathNavigator TransformData(System.Xml.XPath.XPathNavigator nav, int cacheduration, IPDFDataSource source, PDFDataContext context) { //Check we have something to use for a transformation. if (string.IsNullOrEmpty(this.XSLTPath) && null == this.Transformer) { return(nav); } System.Xml.XmlWriter xmlWriter = null; System.IO.MemoryStream memoryStream = null; System.IO.StreamWriter streamWriter = null; System.Xml.XmlDocument result = null; System.Xml.XmlDocument output = new System.Xml.XmlDocument(); try { System.Xml.Xsl.XslCompiledTransform trans = this.DoGetTransformer(cacheduration, source, context); System.Xml.Xsl.XsltArgumentList args = this.DoGetArguments(context); memoryStream = new System.IO.MemoryStream(); streamWriter = new System.IO.StreamWriter(memoryStream, Encoding.UTF8); System.Xml.XmlWriterSettings writerSettings = CreateWriterSettings(); xmlWriter = System.Xml.XmlWriter.Create(streamWriter, writerSettings); trans.Transform(nav, args, xmlWriter); xmlWriter.Flush(); streamWriter.Flush(); result = new System.Xml.XmlDocument(); memoryStream.Position = 0; result.Load(memoryStream); } catch (Exception ex) { throw new PDFDataException(Errors.CouldNotTransformInputData, ex); } finally { if (null != xmlWriter) { xmlWriter.Close(); } if (null != streamWriter) { streamWriter.Dispose(); } if (null != memoryStream) { memoryStream.Dispose(); } } return(result.CreateNavigator()); }
protected virtual System.Xml.Xsl.XsltArgumentList DoGetArguments(PDFDataContext context) { System.Xml.Xsl.XsltArgumentList args = new System.Xml.Xsl.XsltArgumentList(); if (this.HasArguments) { foreach (XsltArgumentBase arg in this.Arguments) { string name = arg.Name; string ns = null == arg.Namespace ? string.Empty : arg.Namespace; object value = arg.GetValue(context); args.AddParam(name, ns, value); } } return(args); }
private static void GenerateViaXSLT(string xsltFileName, System.Xml.XmlDocument xmlMetaData, string outputFile, params XSLTParam[] @params) { System.Xml.Xsl.XslTransform xslt = new System.Xml.Xsl.XslTransform(); System.Xml.XPath.XPathNavigator xNav; System.IO.StreamWriter streamWriter = null; System.Xml.Xsl.XsltArgumentList args = new System.Xml.Xsl.XsltArgumentList(); try { if (xmlMetaData == null) { xmlMetaData = new System.Xml.XmlDocument(); } foreach (XSLTParam param in @params) { args.AddParam(param.Name, "", param.Value); } xNav = xmlMetaData.CreateNavigator(); streamWriter = new System.IO.StreamWriter(outputFile); xslt.Load(xsltFileName); xslt.Transform(xNav, args, streamWriter, null); } finally { if (streamWriter != null) { streamWriter.Flush(); streamWriter.Close(); } } }
public XmlReader Transform(XPathNavigator input, XsltArgumentList args) { return(Transform(input, args, _DocumentResolver)); }
public void Transform(XPathNavigator input, XsltArgumentList args, Stream output) { Transform(input, args, output, _DocumentResolver); }
public void Transform(IXPathNavigable input, XsltArgumentList arguments, XmlWriter results) { CheckArguments(input, results); Transform(input, arguments, results, CreateDefaultResolver()); }
public void Transform(string inputUri, XsltArgumentList arguments, XmlWriter results) { Transform(new XPathDocument(inputUri, XmlSpace.Preserve), arguments, results); }
void Transform(XPathNavigator input, XsltArgumentList args, TextWriter output) { impl.Transform(input, args, output); }
void Transform(XPathNavigator input, XsltArgumentList args, XmlWriter output, XmlResolver resolver) { impl.Transform(input, args, output, resolver); }
public void Transform(XmlReader input, XsltArgumentList arguments, XmlWriter results, XmlResolver documentResolver) { Transform(new XPathDocument(input, XmlSpace.Preserve).CreateNavigator(), arguments, results, documentResolver); }
/// <summary>Transforms the XML data in the <see cref="T:System.Xml.XPath.IXPathNavigable" /> using the specified <paramref name="args" /> and outputs the result to an <see cref="T:System.Xml.XmlReader" />.</summary> /// <returns>An <see cref="T:System.Xml.XmlReader" /> containing the results of the transformation.</returns> /// <param name="input">An object implementing the <see cref="T:System.Xml.XPath.IXPathNavigable" /> interface. In the .NET Framework, this can be either an <see cref="T:System.Xml.XmlNode" /> (typically an <see cref="T:System.Xml.XmlDocument" />), or an <see cref="T:System.Xml.XPath.XPathDocument" /> containing the data to be transformed. </param> /// <param name="args">An <see cref="T:System.Xml.Xsl.XsltArgumentList" /> containing the namespace-qualified arguments used as input to the transformation. </param> /// <param name="resolver">The <see cref="T:System.Xml.XmlResolver" /> used to resolve the XSLT document() function. If this is null, the document() function is not resolved.The <see cref="T:System.Xml.XmlResolver" /> is not cached after the <see cref="M:System.Xml.Xsl.XslTransform.Transform(System.Xml.XPath.IXPathNavigable,System.Xml.Xsl.XsltArgumentList,System.Xml.XmlResolver)" /> method completes. </param> public XmlReader Transform(IXPathNavigable input, XsltArgumentList args, XmlResolver resolver) { return(this.Transform(input.CreateNavigator(), args, resolver)); }
public void Transform(XmlReader input, XsltArgumentList arguments, XmlWriter results) { Transform(input, arguments, results, null); }
public void Transform(XmlReader input, XsltArgumentList arguments, XmlWriter results) { CheckArguments(input, results); Transform(input, arguments, results, CreateDefaultResolver()); }
/// <summary>Transforms the XML data in the <see cref="T:System.Xml.XPath.XPathNavigator" /> using the specified <paramref name="args" /> and outputs the result to a <see cref="T:System.IO.Stream" />.</summary> /// <param name="input">An <see cref="T:System.Xml.XPath.XPathNavigator" /> containing the data to be transformed. </param> /// <param name="args">An <see cref="T:System.Xml.Xsl.XsltArgumentList" /> containing the namespace-qualified arguments used as input to the transformation. </param> /// <param name="output">The stream to which you want to output. </param> /// <param name="resolver">The <see cref="T:System.Xml.XmlResolver" /> used to resolve the XSLT document() function. If this is null, the document() function is not resolved.The <see cref="T:System.Xml.XmlResolver" /> is not cached after the <see cref="M:System.Xml.Xsl.XslTransform.Transform(System.Xml.XPath.XPathNavigator,System.Xml.Xsl.XsltArgumentList,System.IO.Stream,System.Xml.XmlResolver)" /> method completes. </param> /// <exception cref="T:System.InvalidOperationException">There was an error processing the XSLT transformation. Note: This is a change in behavior from earlier versions. An <see cref="T:System.Xml.Xsl.XsltException" /> is thrown if you are using Microsoft .NET Framework version 1.1 or earlier.</exception> public void Transform(XPathNavigator input, XsltArgumentList args, Stream output, XmlResolver resolver) { XslOutput xslOutput = (XslOutput)this.s.Outputs[string.Empty]; this.Transform(input, args, new StreamWriter(output, xslOutput.Encoding), resolver); }
/// <summary>Transforms the XML data in the <see cref="T:System.Xml.XPath.XPathNavigator" /> using the specified <paramref name="args" /> and outputs the result to a <see cref="T:System.IO.TextWriter" />.</summary> /// <param name="input">An <see cref="T:System.Xml.XPath.XPathNavigator" /> containing the data to be transformed. </param> /// <param name="args">An <see cref="T:System.Xml.Xsl.XsltArgumentList" /> containing the namespace-qualified arguments used as input to the transformation. </param> /// <param name="output">The <see cref="T:System.IO.TextWriter" /> to which you want to output. </param> /// <exception cref="T:System.InvalidOperationException">There was an error processing the XSLT transformation. Note: This is a change in behavior from earlier versions. An <see cref="T:System.Xml.Xsl.XsltException" /> is thrown if you are using Microsoft .NET Framework version 1.1 or earlier.</exception> public void Transform(XPathNavigator input, XsltArgumentList args, TextWriter output) { this.Transform(input, args, output, this.xmlResolver); }
/// <summary>Transforms the XML data in the <see cref="T:System.Xml.XPath.IXPathNavigable" /> using the specified <paramref name="args" /> and outputs the result to a <see cref="T:System.IO.Stream" />.</summary> /// <param name="input">An object implementing the <see cref="T:System.Xml.XPath.IXPathNavigable" /> interface. In the .NET Framework, this can be either an <see cref="T:System.Xml.XmlNode" /> (typically an <see cref="T:System.Xml.XmlDocument" />), or an <see cref="T:System.Xml.XPath.XPathDocument" /> containing the data to be transformed. </param> /// <param name="args">An <see cref="T:System.Xml.Xsl.XsltArgumentList" /> containing the namespace-qualified arguments used as input to the transformation. </param> /// <param name="output">The stream to which you want to output. </param> /// <exception cref="T:System.InvalidOperationException">There was an error processing the XSLT transformation.Note: This is a change in behavior from earlier versions. An <see cref="T:System.Xml.Xsl.XsltException" /> is thrown if you are using Microsoft .NET Framework version 1.1 or earlier.</exception> public void Transform(IXPathNavigable input, XsltArgumentList args, Stream output) { this.Transform(input.CreateNavigator(), args, output, this.xmlResolver); }
/// <summary>Transforms the XML data in the <see cref="T:System.Xml.XPath.IXPathNavigable" /> using the specified <paramref name="args" /> and outputs the result to an <see cref="T:System.Xml.XmlWriter" />.</summary> /// <param name="input">An object implementing the <see cref="T:System.Xml.XPath.IXPathNavigable" /> interface. In the .NET Framework, this can be either an <see cref="T:System.Xml.XmlNode" /> (typically an <see cref="T:System.Xml.XmlDocument" />), or an <see cref="T:System.Xml.XPath.XPathDocument" /> containing the data to be transformed. </param> /// <param name="args">An <see cref="T:System.Xml.Xsl.XsltArgumentList" /> containing the namespace-qualified arguments used as input to the transformation. </param> /// <param name="output">The <see cref="T:System.Xml.XmlWriter" /> to which you want to output. </param> /// <param name="resolver">The <see cref="T:System.Xml.XmlResolver" /> used to resolve the XSLT document() function. If this is null, the document() function is not resolved.The <see cref="T:System.Xml.XmlResolver" /> is not cached after the <see cref="M:System.Xml.Xsl.XslTransform.Transform(System.Xml.XPath.IXPathNavigable,System.Xml.Xsl.XsltArgumentList,System.Xml.XmlWriter,System.Xml.XmlResolver)" /> method completes. </param> /// <exception cref="T:System.InvalidOperationException">There was an error processing the XSLT transformation. Note: This is a change in behavior from earlier versions. An <see cref="T:System.Xml.Xsl.XsltException" /> is thrown if you are using Microsoft .NET Framework version 1.1 or earlier.</exception> public void Transform(IXPathNavigable input, XsltArgumentList args, XmlWriter output, XmlResolver resolver) { this.Transform(input.CreateNavigator(), args, output, resolver); }
void Transform(XPathNavigator input, XsltArgumentList args, Stream output) { XslOutput xslOutput = (XslOutput)s.Outputs[String.Empty]; Transform(input, args, new StreamWriter(output, xslOutput.Encoding)); }
/// <summary>Transforms the XML data in the <see cref="T:System.Xml.XPath.XPathNavigator" /> using the specified <paramref name="args" /> and outputs the result to an <see cref="T:System.Xml.XmlReader" />.</summary> /// <returns>An <see cref="T:System.Xml.XmlReader" /> containing the results of the transformation.</returns> /// <param name="input">An <see cref="T:System.Xml.XPath.XPathNavigator" /> containing the data to be transformed. </param> /// <param name="args">An <see cref="T:System.Xml.Xsl.XsltArgumentList" /> containing the namespace-qualified arguments used as input to the transformation. </param> /// <exception cref="T:System.InvalidOperationException">There was an error processing the XSLT transformation. Note: This is a change in behavior from earlier versions. An <see cref="T:System.Xml.Xsl.XsltException" /> is thrown if you are using Microsoft .NET Framework version 1.1 or earlier.</exception> public XmlReader Transform(XPathNavigator input, XsltArgumentList args) { return(this.Transform(input, args, this.xmlResolver)); }
public void Transform(XmlReader input, XsltArgumentList arguments, Stream results) { CheckCommand(); CheckInput(input); command.Execute(input, new XmlUrlResolver(), arguments, results); }
public void Transform(XmlReader input, XsltArgumentList arguments, XmlWriter results, XmlResolver documentResolver) { CheckCommand(); CheckInput(input); command.Execute(input, documentResolver, arguments, results); }
// SxS: This method does not take any resource name and does not expose any resources to the caller. // It's OK to suppress the SxS warning. public void Transform(IXPathNavigable input, XsltArgumentList arguments, XmlWriter results, XmlResolver documentResolver) { CheckArguments(input, results); CheckCommand(); _command.Execute((object)input.CreateNavigator(), documentResolver, arguments, results); }
public void Transform(IXPathNavigable input, XsltArgumentList arguments, TextWriter results) { CheckCommand(); CheckInput(input); command.Execute(input, new XmlUrlResolver(), arguments, results); }
public void Transform(IXPathNavigable input, XsltArgumentList arguments, XmlWriter results) { Transform(input.CreateNavigator(), arguments, results, null); }
public void Transform(XmlReader input, XsltArgumentList arguments, XmlWriter results) { CheckArguments(input, results); Transform(input, arguments, results, XmlNullResolver.Singleton); }
public void Transform(XmlReader input, XsltArgumentList arguments, TextWriter results) { Transform(new XPathDocument(input, XmlSpace.Preserve), arguments, results); }
public void Transform(IXPathNavigable input, XsltArgumentList arguments, Stream results) { Transform(input.CreateNavigator(), arguments, results); }
private void Transform(string inputUri, XsltArgumentList arguments, XmlWriter results, XmlResolver documentResolver) { _command.Execute(inputUri, documentResolver, arguments, results); }
/// <summary> /// Default document as XPathNavigator. /// </summary> public override void Execute(IXPathNavigable contextDocument, XmlResolver dataSources, XsltArgumentList argumentList, Stream results) { if (results == null) { throw new ArgumentNullException("results"); } Execute(contextDocument, dataSources, argumentList, XmlWriter.Create(results, this.staticData.DefaultWriterSettings)); }
private void DrawProfilesModule() { XsltArgumentList args = new XsltArgumentList(); args.AddParam("root", "", Root.Domain); Search.Utilities.APISearchRequest apisearch = new APISearchRequest(); Search.Utilities.DataIO data = new Profiles.Search.Utilities.DataIO(); string queryid = string.Empty; string keyword = string.Empty; string personid = string.Empty; string nodeid = string.Empty; //I dont know what the root of /people should return so for now I require the queryid if (Request.QueryString["queryid"] != null) { queryid = Request.QueryString["queryid"].ToString().Trim(); } if (Request.QueryString["nodeid"] != null) { nodeid = Request.QueryString["nodeid"].ToString().Trim(); } keyword = data.KeyKeyword(queryid); personid = data.PersonID(queryid, nodeid); this.SearchData = apisearch.Execute(queryid, keyword, personid); litKeywordConnection.Text = XslHelper.TransformInMemory(Server.MapPath("~/Search/Modules/KeywordConnection/KeywordConnection.xslt"), args, this.SearchData.OuterXml); }