/// <inheritdoc/>
public EntityResult GetEntity(UrlResolver parent, SageContext context, string uri)
{
var request = WebRequest.Create(uri);
request.Timeout = timeout;
if (!string.IsNullOrWhiteSpace(accept))
request.Headers.Add(HttpRequestHeader.AcceptEncoding, accept);
if (!string.IsNullOrWhiteSpace(acceptLanguage))
request.Headers.Add(HttpRequestHeader.AcceptLanguage, acceptLanguage);
var result = new EntityResult();
try
{
WebResponse response = request.GetResponse();
result.Entity = new StreamReader(response.GetResponseStream());
}
catch (Exception ex)
{
XmlDocument document = new XmlDocument();
document.InnerXml = string.Format("<error uri=\"{0}\">{1}</error>", uri, ex.Message);
result.Entity = new XmlNodeReader(document);
}
return result;
}
/// <inheritdoc/>
public EntityResult GetEntity(UrlResolver parent, SageContext context, string resourceUri)
{
string resourceName = this.GetResourceName(resourceUri);
XmlReaderSettings settings = CacheableXmlDocument.CreateReaderSettings(parent);
CacheableXmlDocument resourceDoc;
// first check if we have a registered provider for the specified resour name
if (providers.ContainsKey(resourceName))
{
XmlProvider provider = providers[resourceName];
log.DebugFormat("Found a specific resource provider for {0}: {1}",
resourceUri,
Util.GetMethodSignature(provider.Method));
resourceDoc = provider(context, resourceUri);
}
else
{
string sourcePath = context.Path.Expand(resourceName);
if (sourcePath == null || !File.Exists(sourcePath))
throw new FileNotFoundException(string.Format("The specified resource '{0}' doesn't exist.", resourceUri));
resourceDoc = context.Resources.LoadXml(sourcePath);
}
XmlReader reader = XmlReader.Create(new StringReader(resourceDoc.OuterXml), settings, resourceUri);
return new EntityResult { Entity = reader, Dependencies = resourceDoc.Dependencies };
}
/// <summary>
/// Renders the result of the original view with an additional <see cref="XsltTransform"/>.
/// </summary>
/// <param name="viewContext">The view context.</param>
/// <param name="writer">The writer to write to.</param>
public override void Render(ViewContext viewContext, TextWriter writer)
{
Contract.Requires<ArgumentNullException>(viewContext != null);
Contract.Requires<ArgumentException>(viewContext.Controller is SageController);
Contract.Requires<ArgumentNullException>(writer != null);
if (this.View is XsltView)
{
XsltView view = (XsltView) this.View;
StringBuilder sb = new StringBuilder();
using (StringWriter sw = new StringWriter(sb))
{
view.Transform(viewContext, sw);
SageController controller = (SageController) viewContext.Controller;
UrlResolver resolver = new UrlResolver(controller.Context);
XmlReaderSettings settings = CacheableXmlDocument.CreateReaderSettings(resolver);
XmlReader reader = XmlReader.Create(new StringReader(sb.ToString()), settings);
XmlDocument viewXml = new XmlDocument();
viewXml.Load(reader);
processor.Transform(viewXml, writer, controller.Context);
}
this.DisableCaching(viewContext);
}
else
{
base.Render(viewContext, writer);
}
}
/// <summary>
/// Gets an <see cref="EntityResult"/> that represents the actual resource mapped from the specified <paramref name="uri"/>.
/// </summary>
/// <param name="parent">The <see cref="UrlResolver"/> that owns this resolved and calls this method.</param>
/// <param name="context">The current <see cref="SageContext"/> under which this code is executing.</param>
/// <param name="uri">The uri to resolve.</param>
/// <returns>
/// An object that represents the resource mapped from the specified <paramref name="uri"/>.
/// </returns>
public EntityResult GetEntity(UrlResolver parent, SageContext context, string uri)
{
string sourcePath = uri.Replace(Scheme + "://", string.Empty);
EntityResult result = null;
Stopwatch sw = new Stopwatch();
long time = sw.TimeMilliseconds(() => result = this.GetClientResourceReader(context, sourcePath));
log.DebugFormat("Time taken to get resource reader for '{0}': {1}ms", uri, time);
return result;
}
/// <summary>
/// Initializes a new instance of the <see cref="MsXsltTransform"/> class, using the specified
/// <paramref name="stylesheetMarkup"/>.
/// </summary>
/// <param name="context">The current context.</param>
/// <param name="stylesheetMarkup">The markup to initialize the transform with.</param>
public MsXsltTransform(SageContext context, XmlDocument stylesheetMarkup)
{
Contract.Requires<ArgumentNullException>(context != null);
Contract.Requires<ArgumentNullException>(stylesheetMarkup != null);
UrlResolver resolver = new UrlResolver(context);
processor = new XslCompiledTransform();
try
{
processor.Load(stylesheetMarkup, XsltSettings.TrustedXslt, resolver);
dependencies.AddRange(resolver.Dependencies);
}
catch (Exception ex)
{
ProblemInfo problem = this.DetectProblemType(ex);
throw new SageHelpException(problem, ex);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SaxonXsltTransform"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="stylesheetMarkup">The stylesheet markup.</param>
/// <exception cref="SageHelpException"></exception>
public SaxonXsltTransform(SageContext context, XmlDocument stylesheetMarkup)
{
Contract.Requires<ArgumentNullException>(context != null);
Contract.Requires<ArgumentNullException>(stylesheetMarkup != null);
UrlResolver resolver = new UrlResolver(context);
processor = new Processor();
XdmNode input = processor.NewDocumentBuilder().Build(stylesheetMarkup);
XsltTransformer transformer = processor.NewXsltCompiler().Compile(XmlReader.Create(stylesheetMarkup.OuterXml)).Load();
try
{
//this.processor.Load(stylesheetMarkup, XsltSettings.TrustedXslt, resolver);
dependencies.AddRange(resolver.Dependencies);
}
catch //(Exception ex)
{
//ProblemInfo problem = this.DetectProblemType(ex);
//throw new SageHelpException(problem, ex);
}
}
private void LoadInternal(string filename, SageContext context, bool processIncludes = true)
{
UrlResolver resolver = new UrlResolver(context);
XmlReader xmlReader;
XmlReaderSettings settings = CacheableXmlDocument.CreateReaderSettings(resolver);
var resolvedUri = context == null ? filename : context.Path.Resolve(filename);
Uri uri = new Uri(resolvedUri, UriKind.RelativeOrAbsolute);
IDisposable reader = resolver.GetEntity(uri, null, null) as IDisposable;
if (reader is XmlReader)
xmlReader = (XmlReader) reader;
else if (reader is Stream)
xmlReader = XmlReader.Create((Stream) reader, settings, filename);
else if (reader is TextReader)
xmlReader = XmlReader.Create((TextReader) reader, settings, filename);
else
xmlReader = XmlReader.Create(filename, settings);
this.AddDependencies(filename);
using (xmlReader)
{
try
{
base.Load(xmlReader);
this.AddDependencies(resolver.Dependencies);
}
finally
{
if (xmlReader.ReadState != ReadState.Closed)
xmlReader.Close();
}
}
baseUri = uri.ToString();
if (processIncludes)
this.ProcessIncludes(this.DocumentElement, context);
}
/// <inheritdoc/>
public override void Transform(XmlNode inputXml, XmlWriter outputWriter, SageContext context, Dictionary<string, object> arguments = null)
{
var startTime = DateTime.Now.Ticks;
XmlWriter xmlWriter = XmlWriter.Create(outputWriter, this.OutputSettings);
XmlWriter output = new XHtmlXmlWriter(xmlWriter);
XmlNodeReader reader = new XmlNodeReader(inputXml);
UrlResolver resolver = new UrlResolver(context);
XsltArgumentList transformArgs = this.GetArguments(arguments);
try
{
processor.Transform(reader, transformArgs, output, resolver);
}
catch (Exception ex)
{
ProblemInfo problem = this.DetectProblemType(ex);
throw new SageHelpException(problem, ex);
}
finally
{
reader.Close();
output.Close();
xmlWriter.Close();
}
var ellapsed = new TimeSpan(DateTime.Now.Ticks - startTime);
log.DebugFormat("XSLT transform completed in {0}ms", ellapsed.Milliseconds);
}
private static CacheableXmlDocument LoadSourceDocument(string path, SageContext context)
{
UrlResolver resolver = new UrlResolver(context);
CacheableXmlDocument result = new CacheableXmlDocument();
result.Load(path, context);
result.AddDependencies(path);
result.AddDependencies(resolver.Dependencies.ToArray());
return result;
}
/// <summary>
/// Validates the specified document <paramref name="document"/> against the XML schema loaded from the specified
/// <paramref name="schemaPath"/>, and returns an object that contains the validation information.
/// </summary>
/// <param name="document">The document to validate.</param>
/// <param name="schemaPath">The path to the XML schema to use to validate the document against.</param>
/// <returns>An object that contains the validation information</returns>
public static ValidationResult ValidateDocument(XmlDocument document, string schemaPath)
{
Contract.Requires<ArgumentNullException>(document != null);
Contract.Requires<ArgumentNullException>(!string.IsNullOrWhiteSpace(schemaPath));
ValidationResult result = new ValidationResult();
XmlSchemaSet schemaSet = null;
if (!string.IsNullOrWhiteSpace(schemaPath))
{
UrlResolver resolver = new UrlResolver();
XmlReaderSettings settings = CacheableXmlDocument.CreateReaderSettings(resolver);
XmlReader reader = XmlReader.Create(schemaPath, settings);
XmlSchema schema = XmlSchema.Read(reader, null);
schemaSet = new XmlSchemaSet { XmlResolver = resolver };
schemaSet.Add(schema);
schemaSet.Compile();
}
XDocument xdocument = XDocument.Parse(document.OuterXml, LoadOptions.SetLineInfo);
xdocument.Validate(schemaSet, (sender, args) =>
{
if (args.Severity == XmlSeverityType.Error)
{
result.Success = false;
var lineInfo = sender as IXmlLineInfo;
if (lineInfo != null)
{
result.Exception = new XmlException(args.Message, args.Exception, lineInfo.LineNumber, lineInfo.LinePosition);
}
else
{
result.Exception = args.Exception;
}
}
});
return result;
}
