public AddParam ( string name, string namespaceUri, object parameter ) : void | ||
name | string | |
namespaceUri | string | |
parameter | object | |
return | void |
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 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); } }
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 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 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 CreateResultPage(XDocument result, bool isTrace) { var args = new XsltArgumentList(); args.AddParam("prmHCTraceLoadErrorFile", "", Path.Combine(Path.GetTempPath(), m_cache.ProjectId.Name + "HCLoadErrors.xml")); args.AddParam("prmShowTrace", "", isTrace.ToString().ToLowerInvariant()); return TraceTransform.Transform(m_mediator, result, isTrace ? "HCTrace" : "HCParse", args); }
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 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; }
protected override void TransformXml(XPathDocument document, XmlTextWriter writer) { XsltArgumentList args = new XsltArgumentList(); args.AddParam("separate-fixtures", "", (this.GenerateFixtureInSeparateFile) ? 1 : 0); args.AddParam("show-fixtures-summary", "", (this.ShowFixturesSummary) ? 1 : 0); args.AddParam("creation-time", "", this.CreationTime.ToString("u")); if (this.GenerateFixtureInSeparateFile) this.GenerateFixtureReports(document, args); UnitResourceManager.HtmlReport.Transform(document, args, writer); writer.Close(); }
protected override XElement BuildUploadXML() { // Get and transform this effectively does basic format validation XElement results = this.GetWorksheetXML(0, HttpContext.Current.Server.MapPath(@"~\Xslt\Senior\SeniorResults.xslt")); // Unify and return XsltArgumentList xal = new XsltArgumentList(); // Set some other parameters xal.AddParam("fileName", "", this.Filename); xal.AddParam("tournamentId", "", this.TournamentId); XElement transformed = XElement.Parse(Utility.Transform(results.ToString(), HttpContext.Current.Server.MapPath(@"~\Xslt\Senior\Senior.xslt"), xal)); return transformed; }
private void DrawProfilesModule() { XsltArgumentList args = new XsltArgumentList(); args.AddParam("root", "", Root.Domain); litPublication.Text = XslHelper.TransformInMemory(Server.MapPath("~/Profile/Modules/CustomViewInformationResource/CustomViewInformationResource.xslt"), args, base.BaseData.OuterXml); }
public void CreateCodeBaseXML() { try { package = Package.Open(fileCodeBase); XmlDocument sharedString = GetPartFile(OfficeFilePart.ShareString, 0); sharedString.Save(Common.SHARED_STRING); XmlDocument sheet = GetPartFile(OfficeFilePart.Sheet, 1); XsltArgumentList xsltArgListSheet = new XsltArgumentList(); XsltSettings settings = new XsltSettings(true, true); XslCompiledTransform xslTransSheet = new XslCompiledTransform(); xslTransSheet.Load(Common.XSLT_CODE_BASE, settings, new XmlUrlResolver()); xsltArgListSheet.AddParam("prmDocSharedStrings", "", sharedString.CreateNavigator()); string sOutXmlSheet = System.String.Empty; using (FileStream fs = new FileStream(Common.XML_CODE_BASE, FileMode.Create)) { xslTransSheet.Transform(sheet.CreateNavigator(), xsltArgListSheet, fs); } XslCompiledTransform xslRowSheet = new XslCompiledTransform(); xslRowSheet.Load(Common.XSLT_TO_ROW); xslRowSheet.Transform(Common.XML_CODE_BASE, Common.XML_ROW); } finally { package.Close(); } }
/// <summary> /// выполнить конвертацию структуры /// </summary> public void Do() { try { SendMessage("\n- Конвертация структуры курса"); XDocument doc = new XDocument(course); doc.Document.Declaration = new XDeclaration("1.0", "utf-8", "true"); XPathNavigator nv = doc.CreateNavigator(); XslCompiledTransform xslt = new XslCompiledTransform(); xslt.Load(convParams.ContentShemePath); XsltArgumentList xslArg = new XsltArgumentList(); xslArg.AddParam("itemsPath", "", convParams.RootFolderName); string outFile = Path.Combine(convParams.OutputAbsPath, convParams.StartFileName); using (FileStream fs = new FileStream(outFile, FileMode.Create)) { xslt.Transform(nv, xslArg, fs); } } catch(Exception ex) { LastError = ex.Message; throw new Exception("Исключение при конвертации структуры курса: "+ex.Message); } }
public ActionResult Index() { HttpServerUtilityBase server = base.HttpContext.Server; HttpResponseBase response = base.HttpContext.Response; HttpRequestBase request = base.HttpContext.Request; IContainerAccessor applicationInstance = base.HttpContext.ApplicationInstance as IContainerAccessor; this.Logger.Debug("GoogleSitemap handler >>>>>>>>>>>>>>>>>>"); string url = string.Format("http://{0}", request.Url.Host.ToLower()) + ((request.Url.Port != 80) ? (":" + request.Url.Port) : ""); url = this.AdjustUrlToContext(url); XsltArgumentList arguments = new XsltArgumentList(); arguments.AddParam("domain", "", url); try { string siteMapFile = WebConfiguration.Current.SiteMapFile; this.Logger.DebugFormat("GoogleSitemap config sitemap file {0}", new object[] { siteMapFile }); string uri = server.MapPath(siteMapFile); this.Logger.DebugFormat("GoogleSitemap mapped sitemap file {0}", new object[] { uri }); XPathDocument document = new XPathDocument(uri); XslCompiledTransform transform = new XslCompiledTransform(); EmbeddedResourceResolver stylesheetResolver = new EmbeddedResourceResolver(); transform.Load("Coats.Crafts.google-sitemap.xsl", XsltSettings.TrustedXslt, stylesheetResolver); StringWriter w = new StringWriter(); XmlTextWriter writer2 = new XmlTextWriter(w); transform.Transform((IXPathNavigable) document, arguments, (XmlWriter) writer2); return this.Content(w.ToString(), "text/xml", Encoding.UTF8); } catch (Exception exception) { this.Logger.Error("Error rendering Google Sitemap XSLT", exception); } return base.Content("Error creating Google Sitemap"); }
public static void CopyAdditionalParams(Dictionary<string, string> additionalParams, XsltArgumentList arguments) { foreach (KeyValuePair<string, string> pair in additionalParams) { arguments.AddParam(pair.Key, "", pair.Value); } }
/// <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(); }
public void split() { System.Xml.Xsl.XslCompiledTransform trans = new System.Xml.Xsl.XslCompiledTransform(); //XsltSettings settings = new XsltSettings(false, true); string xsltFile = @"C:\Users\yxzhk\WorkSpace\CodeDemo\CsPoc\CsPoc\XML\split.xsl"; using (StreamReader rdr = new StreamReader(xsltFile)) { using (XmlReader xmlRdr = XmlReader.Create(rdr)) { trans.Load(xmlRdr); } } string inputFile = @"C:\Users\yxzhk\WorkSpace\CodeDemo\CsPoc\CsPoc\XML\split.xml"; string outputFile = @"C:\Users\yxzhk\WorkSpace\CodeDemo\CsPoc\CsPoc\XML\split-out.xml"; XsltArgumentList xslArg = new XsltArgumentList(); xslArg.AddParam("tag", "", "ItemA,ItemB,ItemC"); //trans.Transform(inputFile,outputFile); using (XmlWriter w = XmlWriter.Create(outputFile)) { trans.Transform(inputFile, xslArg, w); } }
/// <summary> /// Repairs an html fragment (makes it Xhtml) and executes a transformation on it. /// </summary> /// <param name="html">The html to repair</param> /// <param name="xsltPath">The path to the XSLT to use for transformation</param> /// <param name="xsltParameters"></param> /// <param name="errorSummary">out value - warnings generated while repairing the html</param> /// <returns></returns> public static XDocument RepairXhtmlAndTransform(string html, string xsltPath, Dictionary<string, string> xsltParameters, out string errorSummary) { TidyHtmlResult tidyHtmlResult = MarkupTransformationServices.TidyHtml(html); errorSummary = tidyHtmlResult.ErrorSummary; XNode tidiedXhtml = tidyHtmlResult.Output; XDocument outputDocument = new XDocument(); XslCompiledTransform xslt = XsltServices.GetCompiledXsltTransform(xsltPath); using (XmlWriter writer = outputDocument.CreateXhtmlWriter()) { using (XmlReader reader = tidiedXhtml.CreateReader()) { if (xsltParameters != null && xsltParameters.Count > 0) { XsltArgumentList xsltArgumentList = new XsltArgumentList(); foreach (var xsltParameter in xsltParameters) { xsltArgumentList.AddParam(xsltParameter.Key, "", xsltParameter.Value ); } xslt.Transform(reader, xsltArgumentList, writer); } else { xslt.Transform(reader, writer); } } } return outputDocument; }
public static void Parse( XmlDocument xmlMetadata_in, string xsltTemplateURL_in, Hashtable xsltParameters_in, StringWriter parsedOutput_in ) { #region XsltArgumentList _xsltparameters = new XsltArgumentList().AddParam(...); XsltArgumentList _xsltparameters = new XsltArgumentList(); IDictionaryEnumerator _denum = xsltParameters_in.GetEnumerator(); _denum.Reset(); while (_denum.MoveNext()) { _xsltparameters.AddParam( _denum.Key.ToString(), "", System.Web.HttpUtility.UrlEncode( _denum.Value.ToString() ) ); } #endregion XPathNavigator _xpathnav = xmlMetadata_in.CreateNavigator(); XslTransform _xslttransform = new XslTransform(); _xslttransform.Load( xsltTemplateURL_in ); _xslttransform.Transform( _xpathnav, _xsltparameters, parsedOutput_in, null ); }
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(); }
protected void Button1_Click(object sender, EventArgs e) { XsltArgumentList argsList = new XsltArgumentList(); argsList.AddParam("calories", "", TextBox1.Text); Xml1.TransformArgumentList = argsList; Xml1.Visible = true; }
public static IHtmlString Transform(string sXmlPath, string sXslPath) { try { //load the Xml doc XPathDocument myXPathDoc = new XPathDocument(sXmlPath); XsltArgumentList args = new XsltArgumentList(); IDictionary<string, string> parameters = null; if (parameters != null) { foreach (string key in parameters.Keys) { args.AddParam(key, "", parameters[key]); } } XslCompiledTransform tt = new XslCompiledTransform(); //load the Xsl tt.Load(sXslPath); XmlReaderSettings settings = new XmlReaderSettings(); settings.DtdProcessing = DtdProcessing.Parse; settings.ValidationType = ValidationType.DTD; //create the output stream //XmlTextWriter myWriter = new XmlTextWriter("result.html", null); //StringWriter writer = new StringWriter(); //do the actual transform of Xml //myXslTrans.Transform(myXPathDoc, null, myWriter); //System.Text.StringBuilder sb = new System.Text.StringBuilder(); //StringWriter sw = new StringWriter(sb); using (XmlReader reader = XmlReader.Create(sXmlPath, settings)) { StringWriter writer = new StringWriter(); tt.Transform(reader, args, writer); return new HtmlString(writer.ToString()); } //myXslTrans.Transform(myXPathDoc, null, sw); //sw.Close(); //string results = sb.ToString(); //Console.WriteLine(results); //myWriter.Close(); //return new HtmlString(results); } catch (Exception e) { Console.WriteLine("Exception: {0}", e.ToString()); return new HtmlString(e.ToString()); } }
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(); } }
// // PROTECTED METHODS // protected virtual XsltArgumentList GetArgumentList() { XsltArgumentList argsList = new XsltArgumentList(); argsList.AddParam("title", string.Empty, Resources.TEXT_REPORT_TITLE); argsList.AddParam("credit", string.Empty, Resources.TEXT_REPORT_CREDIT); argsList.AddParam("disclaimer", string.Empty, Resources.TEXT_REPORT_DISCLAIMER); argsList.AddParam("creationdate", string.Empty, DateTime.Now.ToLongDateString()); argsList.AddParam("username", string.Empty, Environment.UserName); argsList.AddParam("userdomainname", string.Empty, Environment.UserDomainName); argsList.AddParam("machinename", string.Empty, Environment.MachineName); argsList.AddParam("osversion", string.Empty, Environment.OSVersion.ToString()); argsList.AddParam("dotnetversion", string.Empty, Environment.Version.ToString()); argsList.AddParam("assemblyversion", string.Empty, Assembly.GetExecutingAssembly().GetName().Version.ToString()); return argsList; }
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 void Render(ViewContext viewContext, TextWriter writer) { this.viewContext = viewContext; string url = viewContext.HttpContext.Request.Url.ToString(); construct.AppendPage("", url, viewData.PageVars); var args = new XsltArgumentList(); args.AddExtensionObject("urn:HtmlHelper", new HtmlHelper(viewContext, this)); args.AddParam("AjaxProScriptReferences", "", ajaxDeclaration); foreach (var pair in viewData.PageVars) { args.AddParam(pair.Key, construct.Message.NamespaceURI, pair.Value); } xslTransformer.Transform(new XmlInput(construct.Message.CreateNavigator()), args, new XmlOutput(writer)); }
public string Htmlize (XmlReader ecma_xml, Dictionary<string, string> extraArgs) { var args = new XsltArgumentList (); args.AddExtensionObject("monodoc:///extensions", ExtObject); foreach (var kvp in extraArgs) args.AddParam (kvp.Key, string.Empty, kvp.Value); return Htmlize(ecma_xml, args); }
private XsltArgumentList CreateArgs() { XsltArgumentList args = new XsltArgumentList(); InputParameterCollection parms = Context.Parameters; foreach (InputParameter parameter in parms) { args.AddParam(parameter.Name, "", parameter.Value); } return args; }
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 void WriteZed(XmlReader input) { System.IO.StringWriter dataHolder = new System.IO.StringWriter(); XmlWriter results = XmlWriter.Create((System.IO.TextWriter)dataHolder); string strDcDate = (string)TransformationArguments.GetParam("dcDate", ""); if (strDcDate == null) { strDcDate = DateTime.Now.ToString("yyyy-MM-dd"); TransformationArguments.AddParam("dcDate", "", strDcDate); } try { theTransformer.Transform(input, TransformationArguments, results); } catch (Exception eAnything) { results = null; } input.Close(); //Since the stream has been read to the end, we might as well close it. #region this region only needed for debugging, will be removed //TODO: the actual removal! string[] strSmilFiles = System.IO.Directory.GetFiles(strOutputDir, "*.smil"); foreach (string aSmilFile in strSmilFiles) { System.IO.File.Delete(aSmilFile); } #endregion XmlDocument resDoc = new XmlDocument(); resDoc.LoadXml(dataHolder.ToString()); XmlWriterSettings fileSettings = new XmlWriterSettings(); fileSettings.Indent = true; //TODO:Remove following line resDoc.Save(strOutputDir + "/raw.xml"); XmlNamespaceManager xPathNSManager = new XmlNamespaceManager((XmlNameTable) new NameTable()); xPathNSManager.AddNamespace("smil", "http://www.w3.org/2001/SMIL20/Language"); xPathNSManager.AddNamespace("opf", "http://openebook.org/namespaces/oeb-package/1.0/"); xPathNSManager.AddNamespace("ncx", "http://www.daisy.org/z3986/2005/ncx/"); XmlNode ncxTree = resDoc.DocumentElement.SelectSingleNode("//ncx:ncx", xPathNSManager); string ncxFilename = (string)TransformationArguments.GetParam("ncxFilename", ""); if (ncxFilename == "") { ncxFilename = "navigation.ncx"; } XmlWriter ncxFile = XmlWriter.Create(strOutputDir + "/" + ncxFilename, fileSettings); ncxFile.WriteNode(ncxTree.CreateNavigator(), false); ncxFile.Close(); ncxTree.ParentNode.RemoveChild(ncxTree); //remove the written bit #region Calculating running time, setting on smil file nodes as required TimeSpan prevDuration = new TimeSpan(); try { string tmpXpathStatement = "//*[self::smil:smil or self::smil:audio]"; XmlNodeList lstAudAndSmil = resDoc.DocumentElement.SelectNodes(tmpXpathStatement, xPathNSManager); for (int i = 0; i < lstAudAndSmil.Count; i++) { XmlElement curElement = (XmlElement)lstAudAndSmil[i]; switch (curElement.LocalName) { case "smil": XmlElement ndElapsed = (XmlElement)curElement.SelectSingleNode(".//smil:meta[@name='dtb:totalElapsedTime']", xPathNSManager); ndElapsed.SetAttribute("content", prevDuration.ToString().TrimEnd(".0".ToCharArray())); break; case "audio": try { prevDuration = prevDuration.Subtract(TimeSpan.Parse(curElement.GetAttribute("clipBegin"))); } catch { } try { prevDuration = prevDuration.Add(TimeSpan.Parse((curElement.GetAttribute("clipEnd")))); } catch { } break; default: break; } } } catch (Exception eAnything) { //TODO: Error forwarding System.Diagnostics.Debug.WriteLine(eAnything.ToString()); } //TODO:Remove following line //resDoc.Save(strOutputDir + "/raw.xml"); #endregion XmlElement metaDtbTotalDuration = (XmlElement)resDoc.SelectSingleNode("//opf:meta[@name='dtb:totalTime']", xPathNSManager); metaDtbTotalDuration.SetAttribute("content", prevDuration.ToString().TrimEnd(".0".ToCharArray())); XmlNode opfTree = resDoc.DocumentElement.SelectSingleNode("//opf:package", xPathNSManager); string opfFilename = (string)TransformationArguments.GetParam("packageFilename", ""); if (opfFilename == "") { opfFilename = "package.opf"; } XmlWriter opfFile = XmlWriter.Create(strOutputDir + "/" + opfFilename, fileSettings); opfFile.WriteNode(opfTree.CreateNavigator(), false); opfFile.Close(); opfTree.ParentNode.RemoveChild(opfTree); //remove the written bit XmlNodeList smilTrees = resDoc.DocumentElement.SelectNodes("//smil:smil", xPathNSManager); for (int i = smilTrees.Count - 1; i > -1; i--) { XmlElement newRoot = (XmlElement)smilTrees[i]; XmlWriter smilFile = XmlWriter.Create(strOutputDir + "/" + newRoot.GetAttribute("filename") + ".smil", fileSettings); newRoot.RemoveAttribute("filename"); smilFile.WriteNode(newRoot.CreateNavigator(), false); smilFile.Close(); newRoot.ParentNode.RemoveChild(newRoot); } //TODO:Remove following line //resDoc.Save(strOutputDir + "/raw.xml"); XmlNodeList filesToCopy = resDoc.DocumentElement.SelectNodes("filenames/file", xPathNSManager); foreach (XmlNode fileNode in filesToCopy) { string strSourceFileName = strContextFolder + "\\" + fileNode.InnerText; strSourceFileName = strSourceFileName.Replace("/", "\\"); string strDestFileName = fileNode.InnerText.Substring((fileNode.InnerText.LastIndexOf("/") > 0) ? fileNode.InnerText.LastIndexOf("/") + 1 : 0); strDestFileName = OuputDir + "\\" + strDestFileName; strDestFileName = strDestFileName.Replace("/", "\\"); try { System.IO.File.Copy(strSourceFileName, strDestFileName, true); } catch (Exception eAnything) { System.Diagnostics.Debug.WriteLine(eAnything.ToString()); } } }
private static XsltArgumentList MakeArgs( string[] args ) { if ( args.Length > 3 ){ var xsltArgs = new XsltArgumentList(); var pos = 0; while ( args.Length > ( 3 + (3*pos) ) ){ if ( string.IsNullOrEmpty( args[ 3 + (3*pos) +1 ] ) ){ break; } else if ( args[ 3 + (3*pos) +1 ] != "=" ){ break; } var parmName = args[3 + (3 * pos)]; var parmVal = args[3 + (3 * pos) + 2]; Console.WriteLine("Parm( " + pos.ToString() + ") {" + parmName + ", " + parmVal + "}"); xsltArgs.AddParam(parmName,string.Empty,parmVal ); ++pos; } return xsltArgs; } return null; }
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); }