public string[] TransformModel(string xmlFilePath)
{
var xmlFile = FileSystem.ResolveFile(xmlFilePath);
if (!xmlFile.Exists())
{
throw new FileNotFoundException(xmlFilePath);
}
var basePath = Path.GetDirectoryName(xmlFile.Name);
TextReader inputXmlContent = null;
using (var fsInputStream = xmlFile.Content.GetStream(FileAccess.Read)) {
var vfsResolver = new VfsXmlResolver(FileSystem, basePath);
var xmlRdr = XmlReader.Create(
new StreamReader(fsInputStream), null,
new XmlParserContext(null, null, null, XmlSpace.Default)
{
BaseURI = vfsResolver.AbsoluteBaseUri.ToString()
});
var xIncludingXmlRdr = new Mvp.Xml.XInclude.XIncludingReader(xmlRdr);
xIncludingXmlRdr.XmlResolver = vfsResolver;
var xPathDoc = new XPathDocument(xIncludingXmlRdr);
var nav = xPathDoc.CreateNavigator();
inputXmlContent = new StringReader(nav.OuterXml);
}
return(TransformModel(inputXmlContent, basePath, Path.GetFileNameWithoutExtension(xmlFile.Name)));
}
public string Provide(Context ruleContext)
{
if (String.IsNullOrEmpty(ruleContext.Xml))
{
throw new Exception("xml missed");
}
if (String.IsNullOrEmpty(ruleContext.Xsl))
{
throw new Exception("xsl missed");
}
var xslTransformer = GetTransformer(ruleContext);
StringWriter resWriter = new StringWriter();
Mvp.Xml.XInclude.XIncludingReader xmlIncludeContentRdr = new Mvp.Xml.XInclude.XIncludingReader(new StringReader(ruleContext.Xml));
xmlIncludeContentRdr.XmlResolver = new FileManagerXmlResolver(ruleContext.FileManager, ruleContext.XmlBasePath);
// !!! Note: XIncludingReader has bug: when used directly with XslTransform (incorrect transformation occurs).
XPathDocument xmlXPathDoc = new XPathDocument(xmlIncludeContentRdr);
if (ruleContext.XmlSelectXPath != null)
{
if (log.IsEnabledFor(LogEvent.Debug))
{
log.Write(LogEvent.Debug,
new{ Action = "select from XML", XmlSelectXPath = ruleContext.XmlSelectXPath });
}
try {
string selectedXmlContent = xmlXPathDoc.CreateNavigator().SelectSingleNode(ruleContext.XmlSelectXPath).OuterXml;
xmlXPathDoc = new XPathDocument(new StringReader(selectedXmlContent));
} catch (Exception ex) {
log.Write(LogEvent.Error,
new{ Action = "select from XML", Exception = ex, XPath = ruleContext.XmlSelectXPath });
throw new Exception("Cannot select XML (XPath=" + ruleContext.XmlSelectXPath + "):" + ex.Message, ex);
}
}
else
{
string allXmlContent = xmlXPathDoc.CreateNavigator().OuterXml;
xmlXPathDoc = new XPathDocument(new StringReader(allXmlContent));
}
//xslTransformer.Transform(new XmlTextReader(new StringReader(xmlContent)), new XmlTextWriter(resWriter));
xslTransformer.Transform(xmlXPathDoc, null,
new XmlTextWriter(resWriter)
{
Formatting = Formatting.Indented,
IndentChar = '\t',
Indentation = 1
});
string resContent = resWriter.ToString();
return(resContent);
}
internal protected void Read()
{
XmlSchemaSet schemaSet;
XmlSchema schema;
XmlReaderSettings xmlReaderSettings;
schemaSet = new XmlSchemaSet(_nametable);
schema = ResourceManager.GetXmlSchema("XInclude");
schemaSet.Add(schema);
schema = ResourceManager.GetXmlSchema(SCHEMA_NAME);
schemaSet.Add(schema);
xmlReaderSettings = new XmlReaderSettings();
xmlReaderSettings.CloseInput = false;
xmlReaderSettings.ConformanceLevel = ConformanceLevel.Document;
xmlReaderSettings.IgnoreComments = true;
xmlReaderSettings.IgnoreWhitespace = true;
xmlReaderSettings.Schemas = schemaSet;
xmlReaderSettings.ValidationFlags = XmlSchemaValidationFlags.ReportValidationWarnings | XmlSchemaValidationFlags.AllowXmlAttributes | XmlSchemaValidationFlags.ProcessIdentityConstraints;
xmlReaderSettings.ValidationType = ValidationType.Schema;
xmlReaderSettings.ValidationEventHandler += xmlReaderSettings_ValidationEventHandler;
XmlDocument xml;
xml = new XmlDocument(_nametable);
_validationResult.Clear();
XmlDocument tDoc = new XmlDocument();
using (Mvp.Xml.XInclude.XIncludingReader rdr = new Mvp.Xml.XInclude.XIncludingReader(_reader))
{
rdr.XmlResolver = _xmlResolver;
tDoc.Load(rdr);
}
using (MemoryStream ms = new MemoryStream())
{
using (XmlWriter wr = XmlWriter.Create(ms))
{
tDoc.WriteTo(wr);
}
ms.Position = 0;
using (XmlReader rdr = XmlReader.Create(ms, xmlReaderSettings))
{
xml.Load(rdr);
}
}
if (_validationResult.Count == 0)
{
_ormXmlDocument = xml;
}
}
public object Create(object parent, object configContext, XmlNode section)
{
try {
string componentsXml;
if (section.Name == "components")
{
componentsXml = section.OuterXml;
}
else
{
StringBuilder tmpsb = new StringBuilder();
tmpsb.Append("<components>");
tmpsb.Append(section.InnerXml);
tmpsb.Append("</components>");
componentsXml = tmpsb.ToString();
}
string rootDir = GetAppBasePath();
if (section.Attributes["includebasepath"] != null)
{
var explicitBase = section.Attributes["includebasepath"].Value;
rootDir = Path.IsPathRooted(explicitBase) ? explicitBase : Path.Combine(rootDir, explicitBase);
}
var xmlRdr = XmlReader.Create(new StringReader(componentsXml), null,
new XmlParserContext(null, null, null, XmlSpace.Default)
{
BaseURI = rootDir
});
Mvp.Xml.XInclude.XIncludingReader xmlContentRdr = new Mvp.Xml.XInclude.XIncludingReader(xmlRdr);
LocalFileManager fileManager = new LocalFileManager(rootDir);
xmlContentRdr.XmlResolver = new FileManagerXmlResolver(fileManager, "./");
XPathDocument xmlXPathDoc = new XPathDocument(xmlContentRdr);
IModifyXmlDocumentHandler preprocessor = GetPreprocessor(section.Name, fileManager);
XmlComponentsConfig config = new XmlComponentsConfig(
xmlXPathDoc.CreateNavigator().OuterXml, preprocessor);
return(config);
} catch (Exception ex) {
throw new ConfigurationException(ex.Message, ex);
}
}
public virtual object Create(object parent, object input, XmlNode section)
{
try {
log.Write(LogEvent.Info, "Loading application configuration");
var appBasePath = GetAppBasePath();
var appFs = new LocalFileSystem(appBasePath);
var sourceFileNames = new List <string>();
appFs.Open += (sender, args) => {
var fullFileName = Path.GetFullPath(Path.Combine(appBasePath, args.File.Name).Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar));
if (!sourceFileNames.Contains(fullFileName))
{
sourceFileNames.Add(fullFileName);
}
};
var vfsResolver = new NI.Vfs.VfsXmlResolver(appFs, "./");
var xmlRdr = XmlReader.Create(new StringReader(section.InnerXml), null,
new XmlParserContext(null, null, null, XmlSpace.Default)
{
BaseURI = vfsResolver.AbsoluteBaseUri.ToString()
});
var xIncludingXmlRdr = new Mvp.Xml.XInclude.XIncludingReader(xmlRdr);
xIncludingXmlRdr.XmlResolver = vfsResolver;
// workaround for strange bug that prevents XPathNavigator to Select nodes with XIncludingReader
var xPathDoc = new XPathDocument(xIncludingXmlRdr);
var fullConfigXmlRdr = XmlReader.Create(new StringReader(xPathDoc.CreateNavigator().OuterXml));
var config = new NReco.Application.Ioc.XmlComponentConfiguration(fullConfigXmlRdr);
config.SourceFileNames = sourceFileNames.ToArray();
return(config);
} catch (Exception ex) {
throw new ConfigurationException(ex.Message, ex);
}
}
public object Create(object parent, object configContext, XmlNode section)
{
try {
string componentsXml;
if (section.Name=="components") {
componentsXml = section.OuterXml;
} else {
StringBuilder tmpsb = new StringBuilder();
tmpsb.Append("<components>");
tmpsb.Append(section.InnerXml);
tmpsb.Append("</components>");
componentsXml = tmpsb.ToString();
}
string rootDir = GetAppBasePath();
if (section.Attributes["includebasepath"] != null) {
var explicitBase = section.Attributes["includebasepath"].Value;
rootDir = Path.IsPathRooted(explicitBase) ? explicitBase : Path.Combine(rootDir, explicitBase);
}
var xmlRdr = XmlReader.Create(new StringReader(componentsXml), null,
new XmlParserContext(null, null, null, XmlSpace.Default) { BaseURI = rootDir });
Mvp.Xml.XInclude.XIncludingReader xmlContentRdr = new Mvp.Xml.XInclude.XIncludingReader(xmlRdr);
LocalFileManager fileManager = new LocalFileManager(rootDir);
xmlContentRdr.XmlResolver = new FileManagerXmlResolver(fileManager,"./");
XPathDocument xmlXPathDoc = new XPathDocument(xmlContentRdr);
IModifyXmlDocumentHandler preprocessor = GetPreprocessor(section.Name, fileManager);
XmlComponentsConfig config = new XmlComponentsConfig(
xmlXPathDoc.CreateNavigator().OuterXml, preprocessor);
return config;
} catch (Exception ex) {
throw new ConfigurationException(ex.Message, ex);
}
}
public void ExecuteForFiles(string[] files)
{
var matchRuleFileNameRegex = new Regex(RuleFileNameRegexPattern, RegexOptions.Compiled | RegexOptions.Singleline);
// sort files - processing order is defined
Array.Sort <string>(files);
IList <string> executionPlan = new List <string>();
// build execution plan
foreach (string filePath in files)
{
string fName = Path.GetFileName(filePath);
if (fName.Length > 0 && matchRuleFileNameRegex.IsMatch(fName))
{
executionPlan.Add(Path.GetFullPath(filePath));
}
}
log.Write(LogEvent.Info, "Found {0} rule file(s)", executionPlan.Count);
// stats
IDictionary <IFileRule, int> counters = new Dictionary <IFileRule, int>();
foreach (var rule in Rules)
{
counters[rule] = 0;
}
// execute in exact order
foreach (string ruleFile in executionPlan)
{
string fileContent = FileManager.Read(ruleFile);
log.Write(LogEvent.Info, "Processing rule file: {0}", ruleFile);
var ruleFileReadArgs = new FileRuleEventArgs(ruleFile, null);
// raise event
if (RuleFileReadStart != null)
{
RuleFileReadStart(this, ruleFileReadArgs);
}
Mvp.Xml.XInclude.XIncludingReader xmlIncludeContentRdr = new Mvp.Xml.XInclude.XIncludingReader(new StringReader(fileContent));
xmlIncludeContentRdr.XmlResolver = new FileManagerXmlResolver(FileManager, Path.GetDirectoryName(ruleFile));
XPathDocument ruleXPathDoc = new XPathDocument(xmlIncludeContentRdr);
XPathNavigator ruleFileNav = ruleXPathDoc.CreateNavigator();
XPathNodeIterator ruleNavs =
ruleFileNav.SelectSingleNode("rules") != null?
ruleFileNav.Select("rules/*") :
ruleFileNav.Select("*");
// raise event
if (RuleFileReadEnd != null)
{
RuleFileReadEnd(this, ruleFileReadArgs);
}
foreach (XPathNavigator ruleNav in ruleNavs)
{
for (int i = 0; i < Rules.Length; i++)
{
if (Rules[i].IsMatch(ruleNav))
{
var r = Rules[i];
// for now its hardcoded rule that handles XslTransformRule caching issue
if (r is XslTransformFileRule)
{
((XslTransformFileRule)r).TransformRule.CacheEnabled = false;
}
var ruleContext = new FileRuleContext(ruleFile, FileManager, ruleNav);
if (RuleExecuting != null)
{
RuleExecuting(this, new FileRuleEventArgs(ruleFile, r));
}
try {
Rules[i].Execute(ruleContext);
} catch (Exception ex) {
throw new Exception(String.Format("Rule processing failed: {0} ({1})", ex.Message, ruleContext), ex);
}
if (RuleExecuted != null)
{
RuleExecuted(this, new FileRuleEventArgs(ruleFile, r));
}
counters[Rules[i]]++;
}
}
}
}
foreach (var rule in Rules)
{
log.Write(LogEvent.Info, "Applied {0} for {1} file(s)", rule, counters[rule]);
}
}
public void ExecuteForFiles(string[] files)
{
var matchRuleFileNameRegex = new Regex(RuleFileNameRegexPattern, RegexOptions.Compiled | RegexOptions.Singleline);
// sort files - processing order is defined
Array.Sort<string>(files);
IList<string> executionPlan = new List<string>();
// build execution plan
foreach (string filePath in files) {
string fName = Path.GetFileName(filePath);
if (fName.Length > 0 && matchRuleFileNameRegex.IsMatch(fName) ) {
executionPlan.Add(Path.GetFullPath(filePath));
}
}
log.Write(LogEvent.Info, "Found {0} rule file(s)", executionPlan.Count);
// stats
IDictionary<IFileRule, int> counters = new Dictionary<IFileRule, int>();
foreach (var rule in Rules)
counters[rule] = 0;
// execute in exact order
foreach (string ruleFile in executionPlan) {
string fileContent = FileManager.Read(ruleFile);
log.Write(LogEvent.Info, "Processing rule file: {0}", ruleFile);
var ruleFileReadArgs = new FileRuleEventArgs(ruleFile, null);
// raise event
if (RuleFileReadStart != null)
RuleFileReadStart(this, ruleFileReadArgs);
Mvp.Xml.XInclude.XIncludingReader xmlIncludeContentRdr = new Mvp.Xml.XInclude.XIncludingReader(new StringReader(fileContent));
xmlIncludeContentRdr.XmlResolver = new FileManagerXmlResolver(FileManager, Path.GetDirectoryName(ruleFile));
XPathDocument ruleXPathDoc = new XPathDocument(xmlIncludeContentRdr);
XPathNavigator ruleFileNav = ruleXPathDoc.CreateNavigator();
XPathNodeIterator ruleNavs =
ruleFileNav.SelectSingleNode("rules")!=null ?
ruleFileNav.Select("rules/*") :
ruleFileNav.Select("*");
// raise event
if (RuleFileReadEnd != null)
RuleFileReadEnd(this, ruleFileReadArgs);
foreach (XPathNavigator ruleNav in ruleNavs) {
for (int i = 0; i < Rules.Length; i++)
if (Rules[i].IsMatch(ruleNav)) {
var r = Rules[i];
// for now its hardcoded rule that handles XslTransformRule caching issue
if (r is XslTransformFileRule)
((XslTransformFileRule)r).TransformRule.CacheEnabled = false;
var ruleContext = new FileRuleContext(ruleFile, FileManager, ruleNav);
if (RuleExecuting != null)
RuleExecuting(this, new FileRuleEventArgs(ruleFile, r));
try {
Rules[i].Execute(ruleContext);
} catch (Exception ex) {
throw new Exception(String.Format("Rule processing failed: {0} ({1})", ex.Message, ruleContext), ex);
}
if (RuleExecuted != null)
RuleExecuted(this, new FileRuleEventArgs(ruleFile, r));
counters[Rules[i]]++;
}
}
}
foreach (var rule in Rules) {
log.Write(LogEvent.Info, "Applied {0} for {1} file(s)", rule, counters[rule]);
}
}
