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);
}
