private MvpXslTransform GetMvpXslTransform2()
{
if (xslt2 == null)
{
xslt2 = new MvpXslTransform();
xslt2.Load("../../Common/MvpXslTransformTests/resolver-test.xslt", XsltSettings.TrustedXslt, null);
}
return xslt2;
}
private MvpXslTransform GetMvpXslTransform()
{
if (xslt == null)
{
xslt = new MvpXslTransform();
xslt.Load("../../Common/MvpXslTransformTests/test1.xslt");
}
return xslt;
}
public XsltView(XsltTemplate viewTemplate, XsltViewData viewData, string ajaxDeclaration, HttpContextBase httpContext)
{
this.viewTemplate = viewTemplate;
this.viewData = viewData;
this.ajaxDeclaration = ajaxDeclaration;
construct = new XmlResponseBuilder(httpContext);
InitializeConstruct();
xslTransformer = viewTemplate.XslTransformer;
}
public static XmlDocument CalculateVariableBindings(IXPathNavigable sourceXml, IList<VariableBinding> bindings)
{
string xslt = PrepareXslTransform(bindings);
log.Info("XSLT: {0}", xslt);
MvpXslTransform tr = new MvpXslTransform();
StringReader sr = new StringReader(xslt);
XmlReader xr = XmlReader.Create(sr);
tr.Load(xr);
XsltArgumentList al = new XsltArgumentList();
StringWriter sw = new StringWriter();
tr.Transform(new XmlInput(sourceXml), al, new XmlOutput(sw));
log.Info("Transformed: {0}", sw.ToString());
XmlDocument doc = new XmlDocument();
doc.LoadXml(sw.ToString());
return doc;
}
public static string Transform(string xslt, string xml, IAsyncConnection conn)
{
var xal = new XsltArgumentList();
xal.AddExtensionObject(Namespace, new ArasXsltExtensions(conn));
var xsl = new MvpXslTransform();
xsl.SupportedFunctions = Mvp.Xml.Exslt.ExsltFunctionNamespace.All;
using (var reader = new StringReader(xslt))
{
using (var xmlReader = XmlReader.Create(reader))
{
xsl.Load(xmlReader);
}
}
using (var writer = new System.IO.StringWriter())
{
xsl.Transform(new XmlInput(new StringReader(xml)), xal, new XmlOutput(writer));
return writer.ToString();
}
}
public static string GetXmlString(string stylesheet, string xmlstring, List<XsltExtensionParam> listExtensionParam,
bool enableDocumentFunction, bool enableScript)
{
MvpXslTransform xslt = new MvpXslTransform();
string text = string.Empty;
try {
using (XmlReader strm = XmlReader.Create(new MemoryStream(ASCIIEncoding.Default.GetBytes(stylesheet)))) {
if (enableDocumentFunction && enableScript) {
XsltSettings xslSettings = new XsltSettings(enableDocumentFunction, enableScript);
XmlResolver xmlResolver = new XmlUrlResolver();
xslt.Load(strm, xslSettings, xmlResolver);
} else if (enableDocumentFunction && !enableScript) {
XsltSettings xslSettings = new XsltSettings(enableDocumentFunction, false);
XmlResolver xmlResolver = new XmlUrlResolver();
xslt.Load(strm, xslSettings, xmlResolver);
} else {
xslt.Load(strm);
}
}
using (TextReader stringReader = new StringReader(xmlstring)) {
XPathDocument mydata = new XPathDocument(stringReader);
XmlInput a = new XmlInput(mydata);
using (TextWriter txtWriter = new StringWriter()) {
XsltArgumentList b = new XsltArgumentList();
foreach (XsltExtensionParam oep in listExtensionParam) {
b.AddExtensionObject(oep.Namespace, oep.Object);
}
xslt.Transform(a, b, new XmlOutput(txtWriter));
text = txtWriter.ToString();
}
}
} catch (Exception ex) {
}
return text;
}
private static byte[] GenerateFo(string htmlContent, HttpContextBase context)
{
var pageReader = new StringReader(htmlContent);
var htmlReader = XmlReader.Create(pageReader, new XmlReaderSettings{DtdProcessing = DtdProcessing.Parse});
var xsl = new XmlDocument();
using (var xslReader = XmlReader.Create(GetXsltStreamFromResources("xslfo-stories"), new XmlReaderSettings { DtdProcessing = DtdProcessing.Ignore }))
{
xsl.Load(xslReader);
}
var foWriterSettings = new XmlWriterSettings { ConformanceLevel = ConformanceLevel.Auto };
var foOutput = new StringWriter();
var foWriter = XmlWriter.Create(foOutput, foWriterSettings);
var xslt = new MvpXslTransform();
xslt.Load(xsl, XsltSettings.TrustedXslt, new EmbeddedStylesheetResolver(StylesheetNameFormat, typeof(PdfResult)));
xslt.EnforceXHTMLOutput = false;
var arguments = new XsltArgumentList();
arguments.AddExtensionObject("urn:dash.common", new XsltExtensions.Common());
arguments.AddParam("root-url", string.Empty, string.Format("{0}://{1}/", context.Request.Url.Scheme, context.Request.Url.Authority));
try
{
xslt.Transform(new XmlInput(htmlReader), arguments, new XmlOutput(foWriter));
}
finally
{
htmlReader.Close();
foWriter.Close();
}
var fo = foOutput.ToString();
return Encoding.Default.GetBytes(fo);
}
public void TestXPointerIndentationBug()
{
XmlUrlResolver resolver = new XmlUrlResolver();
resolver.Credentials = CredentialCache.DefaultCredentials;
XsltSettings xsltSettings = new XsltSettings();
xsltSettings.EnableDocumentFunction = true;
XmlReaderSettings settings = new XmlReaderSettings();
settings.ProhibitDtd = false;
XmlReader reader = XmlReader.Create("../../XInclude/tests/Transform.xsl", settings);
XIncludingReader xInputReader = new XIncludingReader("../../XInclude/tests/FileA.xml");
try
{
MvpXslTransform processor = new MvpXslTransform(false);
processor.Load(reader, xsltSettings, resolver);
//xInputReader.XmlResolver = new XMLBase();
XmlDocument xInputDoc = new XmlDocument();
xInputDoc.Load(xInputReader);
XmlInput xInput = new XmlInput(xInputDoc);
StringWriter stringW = new StringWriter();
XmlOutput xOutput = new XmlOutput(stringW);
processor.Transform(xInput, null, xOutput);
processor.TemporaryFiles.Delete();
Assert.AreEqual("<?xml version=\"1.0\" encoding=\"utf-16\"?>NodeA Content", stringW.ToString());
}
finally
{
reader.Close();
xInputReader.Close();
}
}
public void NoExsltTest()
{
MvpXslTransform xslt = new MvpXslTransform();
xslt.Load("../../Common/MvpXslTransformTests/exslt-test.xslt");
XmlInput input = new XmlInput("../../Common/MvpXslTransformTests/test.xml");
MemoryStream ms = new MemoryStream();
xslt.SupportedFunctions = Mvp.Xml.Exslt.ExsltFunctionNamespace.None;
try
{
xslt.Transform(input, Arguments, new XmlOutput(ms));
}
catch (XsltException) { return; }
Assert.Fail("Shoudn't be here.");
}
public void ExsltTest()
{
MvpXslTransform xslt = new MvpXslTransform();
xslt.Load("../../Common/MvpXslTransformTests/exslt-test.xslt");
XmlInput input = new XmlInput("../../Common/MvpXslTransformTests/test.xml");
MemoryStream ms = new MemoryStream();
xslt.Transform(input, Arguments, new XmlOutput(ms));
string expected = "<out>3</out>";
CompareResults(Encoding.ASCII.GetBytes(expected), ms.ToArray());
}
public static void MvpTransform(string sXmlPath, string sXslPath, string outfilename)
{
MvpXslTransform xslt = new MvpXslTransform();
xslt.Load(sXslPath);
xslt.Transform(new XmlInput(sXmlPath), null, new XmlOutput(outfilename));
}
public override void xslTransformer(XPathNavigator xNav, XsltArgumentList xArgs)
{
XsltSettings settings = new XsltSettings(true, true);
XmlUrlResolver r = new XmlUrlResolver();
r.Credentials = System.Net.CredentialCache.DefaultCredentials;
MvpXslTransform xslObj = new MvpXslTransform();
xslObj.SupportCharacterMaps = false; // causes error reading
var readersettings = new XmlReaderSettings();
using (XmlReader xslreader = XmlReader.Create(classXSLObjectSource, readersettings))
{
xslObj.Load(xslreader, settings, r);
XmlInput xm = new XmlInput(xNav);
XmlOutput xo;
try
{
if (!(clsFileIO == null))
{
xo = new XmlOutput(clsFileIO);
xslObj.Transform(xm, xArgs, xo);
clsTEXTResult = "FILE SAVED";
}
else if (!(clsHTTPResponse == null))
{
xo = new XmlOutput(clsHTTPResponse.OutputStream);
xslObj.Transform(xm, xArgs, xo);
clsTEXTResult = "OUTPUT STREAMED TO HTTP RESPONSE";
}
else if (!(clsXMLObjectReturn == null))
{
using (StringWriter sWrit = new StringWriter())
{
xo = new XmlOutput(sWrit);
xslObj.Transform(xm, xArgs, xo);
clsXMLObjectReturn.LoadXml(sWrit.ToString());
}
}
else
{
using (StringWriter sWrit = new StringWriter())
{
xo = new XmlOutput(sWrit);
xslObj.Transform(xm, xArgs, xo);
// default - results to text
clsTEXTResult = sWrit.ToString();
}
}
}
catch (Exception unhandled)
{
throw unhandled;
}
finally
{
xslObj = null;
xm = null;
xo = null;
}
}
}
public void MatchRootMvpXml()
{
XmlDocument xsltDoc = new XmlDocument();
xsltDoc.LoadXml( @"
<xsl:stylesheet version='1.0'
xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>
<xsl:output method='xml' omit-xml-declaration='no' encoding='UTF-8'/>
<xsl:template match='/'><root>Matched</root></xsl:template>
</xsl:stylesheet>
" );
MvpXslTransform transform = new MvpXslTransform();
var resolver = new XmlUrlResolver();
transform.Load( xsltDoc, XsltSettings.TrustedXslt, resolver );
StringBuilder builder = new StringBuilder();
XmlWriter writer = new XmlTextWriter( new StringWriter( builder ) );
CollectionOfSimple c = new CollectionOfSimple( true );
ObjectXPathContext context = new ObjectXPathContext();
context.DetectLoops = true;
XPathNavigator nav = context.CreateNavigator( c );
transform.Transform(
new XmlInput( nav, resolver ),
null,
new XmlOutput( writer ) );
writer.Close();
Assert.AreEqual( "<root>Matched</root>", builder.ToString() );
}
/// <summary>
/// Creates XslCompiledTransform instance for given reader and resolver.
/// </summary>
private MvpXslTransform CreateTransform(XmlResolver stylesheetResolver, XmlReader stylesheetReader)
{
MvpXslTransform xslt = new MvpXslTransform();
xslt.SupportCharacterMaps = options.ProcessCharacterMaps;
xslt.EnforceXHTMLOutput = options.EnforceXhtmlOutput;
try
{
xslt.Load(stylesheetReader, XsltSettings.TrustedXslt, stylesheetResolver);
}
catch (XsltException xslte)
{
string errors = GetCompileErrors(xslt.CompiledTransform);
if (!string.IsNullOrEmpty(errors))
{
errors += Environment.NewLine;
}
errors += Reporter.GetFullMessage(xslte);
throw new NXsltException(errors);
}
catch (XmlException xe)
{
string uri = options.LoadStylesheetFromStdin ? NXsltStrings.FromStdin : xe.SourceUri;
throw new NXsltException(NXsltStrings.ErrorParsingDoc, uri, Reporter.GetFullMessage(xe));
}
catch (Exception e)
{
string uri = options.LoadStylesheetFromStdin ? NXsltStrings.FromStdin : stylesheetReader.BaseURI;
throw new NXsltException(NXsltStrings.ErrorCompileStyle, uri, Reporter.GetFullMessage(e));
}
return xslt;
}
/// <summary>
/// Actual transformation and error handling.
/// </summary>
private void TransformImpl(XmlReader srcReader, MvpXslTransform xslt, XmlResolver resolver, XmlOutput results)
{
xslt.MultiOutput = options.MultiOutput;
try
{
xslt.Transform(new XmlInput(srcReader, resolver), options.XslArgList, results);
}
catch (XmlException xe)
{
string uri = options.LoadSourceFromStdin ? NXsltStrings.FromStdin : xe.SourceUri;
throw new NXsltException(NXsltStrings.ErrorParsingDoc, uri, Reporter.GetFullMessage(xe));
}
catch (XmlSchemaValidationException ve)
{
string uri = options.LoadSourceFromStdin ? NXsltStrings.FromStdin : srcReader.BaseURI;
throw new NXsltException(NXsltStrings.ErrorParsingDoc, uri, Reporter.GetFullMessage(ve));
}
catch (Exception e)
{
throw new NXsltException(NXsltStrings.ErrorTransform, Reporter.GetFullMessage(e));
}
}
/// <summary>
/// Performs XSL Transformation.
/// </summary>
private void Transform(XmlReader srcReader, MvpXslTransform xslt, XmlResolver resolver)
{
Stopwatch transformTimer = null;
if (options.ShowTiming)
{
transformTimer = new Stopwatch();
transformTimer.Start();
}
if (options.OutFile != null)
{
//Transform to a file
FileStream fs;
try
{
fs = File.Open(options.OutFile, FileMode.Create);
}
catch
{
throw new NXsltException(NXsltStrings.ErrorCreatingFile, options.OutFile);
}
try
{
XmlOutput results = new XmlOutput(fs);
results.XmlResolver = new OutputResolver(Path.GetDirectoryName(options.OutFile));
TransformImpl(srcReader, xslt, resolver, results);
}
finally
{
fs.Close();
}
}
else
{
//Transform to Console
XmlOutput results = new XmlOutput(Console.Out);
results.XmlResolver = new OutputResolver(Directory.GetCurrentDirectory());
TransformImpl(srcReader, xslt, resolver, results);
}
//Save transfomation time
if (options.ShowTiming)
{
transformTimer.Stop();
timings.XsltExecutionTime = transformTimer.ElapsedMilliseconds;
}
}
