/// <summary>
/// Processes the record.
/// </summary>
protected override void ProcessRecord()
{
this.WriteVerbose("Formatting log");
using (var xmlReader = new StringReader(this.Log))
{
var xpath = new XPathDocument(xmlReader);
using (var writer = new StringWriter())
{
var transform = new XslCompiledTransform();
Func<string, string> selector = file => !Path.IsPathRooted(file) ? Path.Combine(Environment.CurrentDirectory, file) : file;
foreach (var fileToLoad in this.FormatFile.Select(selector))
{
this.WriteVerbose("Loading format file " + fileToLoad);
using (var stream = File.OpenRead(fileToLoad))
{
using (var reader = XmlReader.Create(stream))
{
transform.Load(reader);
transform.Transform(xpath, null, writer);
}
}
}
this.WriteObject(writer.GetStringBuilder().ToString(), false);
}
}
}
public void ShouldAllowAnXsltToBeRunSuccessfully()
{
string xhtmlPage = "http://localhost/webdriver/xhtmlTest.html";
driver.Get(xhtmlPage);
XPathNavigator navigator = driver.CreateNavigator();
XmlDocument xslDoc = new XmlDocument();
xslDoc.LoadXml(
@"<?xml version=""1.0""?>
<xsl:stylesheet version=""1.0"" xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"">
<xsl:template match=""/"">
<xsl:copy-of select="".""/>
</xsl:template>
</xsl:stylesheet>");
XslCompiledTransform xsl = new XslCompiledTransform();
xsl.Load(xslDoc);
StringBuilder output = new StringBuilder();
xsl.Transform(navigator, new XsltArgumentList(), new StringWriter(output));
String result = output.ToString();
// Do we get text in the body of the transformed document?
Assert.IsTrue(result.Contains("XHTML Might Be The Future"), "No text from the body of the page");
// Do we get tag's?
Assert.IsTrue(result.Contains("<"), "No tags appear to have been opened");
Assert.IsTrue(result.Contains("</body"), "The body tag has not been closed. Check that tags are being output");
// Do we get the page's title?
Assert.IsTrue(result.Contains("XHTML Test Page"), "No title seen");
}
public static void Main()
{
XslCompiledTransform styleSheet = new XslCompiledTransform();
styleSheet.Load("../../style.xslt");
styleSheet.Transform("../../catalogue.xml", "../../catalogue.html");
Console.WriteLine("Please open project folder to see the result");
}
/// <summary>
/// Perform the xml translation
/// </summary>
/// <param name="xmlRaw"></param>
/// <param name="xslSheet"></param>
/// <returns></returns>
public static XmlDocument TransformXml(XmlDocument xmlRawClean, XslCompiledTransform xslSheet)
{
XmlDocument xmlTransform = null;
XmlTextWriter xmlWriter = null;
try
{
XPathDocument xmlClean = ConvertXmlDocumentToXPathDocument(xmlRawClean);
string sTempPath = FileUtilities.GetUniqueTempFileName();
xmlWriter = new XmlTextWriter(sTempPath, null);
xslSheet.Transform(xmlClean, null, xmlWriter);
xmlWriter.Close();
xmlTransform = new XmlDocument();
xmlTransform.Load(sTempPath);
// try to clean up the file we created
try
{
File.Delete(sTempPath);
}
catch
{
}
}
catch (Exception ex)
{
throw new Exception("TransformXml", ex.InnerException);
}
return xmlTransform;
}
public string GetHtml(string transform_path, string xml)
{
string xsltPath = Server.MapPath(transform_path) + "\\sdctemplate.xslt";
string csspath = Server.MapPath(transform_path) + "\\sdctemplate.css";
//3/10/2016 - change encoding to unicode
System.IO.MemoryStream stream = new System.IO.MemoryStream(System.Text.UnicodeEncoding.ASCII.GetBytes(xml));
System.Xml.XPath.XPathDocument document = new System.Xml.XPath.XPathDocument(stream);
System.IO.StringWriter writer = new System.IO.StringWriter();
System.Xml.Xsl.XslCompiledTransform transform = new System.Xml.Xsl.XslCompiledTransform();
System.Xml.Xsl.XsltSettings settings = new System.Xml.Xsl.XsltSettings(true, true);
System.Xml.XmlSecureResolver resolver = new System.Xml.XmlSecureResolver(new System.Xml.XmlUrlResolver(), csspath);
try
{
transform.Load(xsltPath, settings, resolver);
transform.Transform(document, null, writer);
}
catch (Exception ex)
{
throw ex;
}
return(writer.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();
}
}
public static String TransformXml(XmlTextReader xsltReader, XmlTextReader xmlReader)
{
// Create required writer for output
StringWriter stringWriter = new StringWriter();
XmlTextWriter transformedXml = new XmlTextWriter(stringWriter);
// Create a XslCompiledTransform to perform transformation
XslCompiledTransform xsltTransform = new XslCompiledTransform();
try
{
xsltTransform.Load(xsltReader);
xsltTransform.Transform(xmlReader, new XsltArgumentList(), transformedXml);
}
catch (XmlException xmlEx)
{
// TODO : log - "Could not load XSL transform: \n\n" + xmlEx.Message
throw;
}
catch (XsltException xsltEx)
{
// TODO : log - "Could not process the XSL: \n\n" + xsltEx.Message + "\nOn line " + xsltEx.LineNumber + " @ " + xsltEx.LinePosition)
throw;
}
catch (Exception ex)
{
// TODO : log
throw;
}
return stringWriter.ToString();
}
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 string TransformClaimDocumentToFoXml(ClaimDocument document)
{
FormDocument form = new FormDocument();
foreach (var claim in document.Claims)
{
if (claim.Type == ClaimTypeEnum.Professional)
{
var pages = _professionalTransformation.TransformClaimToClaimFormFoXml(claim);
form.Pages.AddRange(pages);
}
else if (claim.Type == ClaimTypeEnum.Institutional)
{
var pages = _institutionalTransformation.TransformClaimToClaimFormFoXml(claim);
form.Pages.AddRange(pages);
}
else
form.Pages.AddRange(_dentalTransformation.TransformClaimToClaimFormFoXml(claim));
}
var xml = form.Serialize();
var transformStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("OopFactory.X12.Hipaa.Claims.Services.Xsl.FormDocument-To-FoXml.xslt");
var transform = new XslCompiledTransform();
if (transformStream != null) transform.Load(XmlReader.Create(transformStream));
var outputStream = new MemoryStream();
transform.Transform(XmlReader.Create(new StringReader(xml)), new XsltArgumentList(), outputStream);
outputStream.Position = 0;
return new StreamReader(outputStream).ReadToEnd();
}
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;
}
}
static void Main(string[] args)
{
if (args.Length != 3)
{
Console.WriteLine("You have not entered the correct parameters");
return;
}
string xmlfile = args[0];
string xslfile = args[1];
string outfile = args[2];
try
{
var doc = new XPathDocument(xmlfile);
var transform = new XslCompiledTransform();
var settings = new XsltSettings(true, true);
transform.Load(xslfile, settings, new XmlUrlResolver());
var writer = new XmlTextWriter(outfile, null);
transform.Transform(doc, null, writer);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
}
}
protected void Store1_Submit(object sender, StoreSubmitDataEventArgs e)
{
try
{
var json = FormatType.Value.ToString();
var eSubmit = new StoreSubmitDataEventArgs(json, null);
var xml = eSubmit.Xml;
if (xml.InnerText == "")
{
X.Msg.Alert("Thông báo", "Không có dữ liệu để xuất ra file Excel").Show();
return;
}
Response.Clear();
Response.ContentType = "application/vnd.ms-excel";
Response.AddHeader("Content-Disposition", "attachment; filename=Export_Tieu_Chi_Danh_Gia.xls");
var xtExcel = new System.Xml.Xsl.XslCompiledTransform();
xtExcel.Load(Server.MapPath("../Export/Excel.xsl"));
xtExcel.Transform(xml, null, Response.OutputStream);
Response.End();
}
catch (Exception ex)
{
X.Msg.Alert("Thông báo", "Có lỗi xảy ra: " + ex.Message.ToString()).Show();
}
}
public static string Transform (string xml, string xslFile, IDictionary<string, string> xslParams)
{
XslCompiledTransform xslTrans = new XslCompiledTransform ();
xslTrans.Load (xslFile);
return Transform (xml, xslTrans, xslParams);
}
public static string ApplyXslt(this string xml, string xslt, ISubstitutionContext context, Func <string, string> processIncludes = null)
{
var temp = Path.GetTempFileName();
var res = new StringBuilder();
try
{
var c = new System.Xml.Xsl.XslCompiledTransform(true);
File.WriteAllText(temp, xslt);
c.Load(temp, new XsltSettings(true, true), new Resolver(context, temp, processIncludes));
using (var xmlreader = XmlReader.Create(new StringReader(xml)))
{
using (var resultWriter = XmlWriter.Create(new StringWriter(res), new XmlWriterSettings()
{
ConformanceLevel = ConformanceLevel.Fragment
}))
{
c.Transform(xmlreader, resultWriter);
}
}
}
finally
{
try { File.Delete(temp); }
catch { }
}
return(res.ToString());
}
static int Main(string[] args)
{
Console.WriteLine("XMLTo v0.1 [www.mosa-project.org]");
Console.WriteLine("Copyright 2009 by the MOSA Project. Licensed under the New BSD License.");
Console.WriteLine("Written by Philipp Garcia ([email protected])");
Console.WriteLine();
Console.WriteLine("Usage: XMLTo <xml file> <xsl file> <output file>");
Console.WriteLine();
if (args.Length < 3)
{
Console.Error.WriteLine("ERROR: Missing arguments");
return -1;
}
try {
XPathDocument myXPathDoc = new XPathDocument(args[0]);
XslCompiledTransform myXslTrans = new XslCompiledTransform();
myXslTrans.Load(args[1]);
XmlTextWriter myWriter = new XmlTextWriter(args[2], null);
myXslTrans.Transform(myXPathDoc, null, myWriter);
return 0;
}
catch (Exception e) {
Console.Error.WriteLine("Exception: {0}", e.ToString());
return -1;
}
}
static int Main (string [] args)
{
if (args.Length != 2) {
Console.WriteLine ("Usage: mono gen-apidiff-html.exe <diff_dir> <html_file>");
return 1;
}
string diff_dir = args[0];
string out_file = args[1];
var all = new XmlDocument ();
all.AppendChild(all.CreateElement ("assemblies"));
foreach (string file in Directory.EnumerateFiles(diff_dir, "*.apidiff")) {
Console.WriteLine ("Merging " + file);
var doc = new XmlDocument ();
doc.Load (file);
foreach (XmlNode child in doc.GetElementsByTagName ("assembly")) {
XmlNode imported = all.ImportNode (child, true);
all.DocumentElement.AppendChild (imported);
}
}
var transform = new XslCompiledTransform ();
transform.Load ("mono-api.xsl");
var writer = new StreamWriter (out_file);
Console.WriteLine (String.Format ("Transforming to {0}...", out_file));
transform.Transform (all.CreateNavigator (), null, writer);
writer.Close ();
return 0;
}
public static void Main()
{
XslCompiledTransform xsltStyle = new XslCompiledTransform();
xsltStyle.Load("../../catalogstyle.xslt");
xsltStyle.Transform("../../catalog.xml", "../../catalog.html");
Console.WriteLine("catalog.html created");
}
private static StringBuilder Transform(string gcmlPath)
{
if(!File.Exists(gcmlPath))
{
throw new GCMLFileNotFoundException("The GCML File" + gcmlPath + " does not exist.");
}
if(!File.Exists(xsltFilePath))
{
throw new XSLTFileNotFoundException("The XSLT File" + xsltFilePath + " does not exist.");
}
StringBuilder sb = new StringBuilder();
XmlTextReader xmlSource = new XmlTextReader(gcmlPath);
XPathDocument xpathDoc = new XPathDocument(xmlSource);
XslCompiledTransform xsltDoc = new XslCompiledTransform();
xsltDoc.Load(xsltFilePath);
StringWriter sw = new StringWriter(sb);
try
{
xsltDoc.Transform(xpathDoc, null, sw);
}
catch (XsltException except)
{
Console.WriteLine(except.Message);
throw except;
}
return sb;
}
public HxS(string workingDir, string hxsFile,
string title, string copyright, string locale,
TreeNodeCollection nodes,
Content contentDataSet,
Dictionary<string, string> links)
{
this.locale = locale;
this.title = title;
this.copyright = copyright;
this.nodes = nodes;
this.contentDataSet = contentDataSet;
this.links = links;
this.outputFile = Path.GetFullPath(hxsFile);
this.rawDir = Path.Combine(workingDir, "raw");
// The source shouldn't be hidden away. If an error happens (likely) the user needs to check logs etc.
//this.hxsDir = Path.Combine(workingDir, "hxs");
this.hxsDir = GetUniqueDir(hxsFile);
this.withinHxsDir = Path.Combine(hxsDir, hxsSubDir);
this.baseFilename = Path.GetFileNameWithoutExtension(hxsFile);
this.baseFilename = this.baseFilename.Replace(" ", "_"); //replace spaces with _ otherwise we get compile errors
this.logFile = Path.Combine(hxsDir, this.baseFilename + ".log");
this.projectFile = Path.Combine(hxsDir, baseFilename + ".hxc");
if (xform == null)
{
xform = new XslCompiledTransform(true);
xform.Load(transformFile);
}
}
public string Transform(String xml, String xsltPath)
{
string result = String.Empty;
string pathxsl = Path.Combine(DirectoryUtil.AssemblyDirectory, xsltPath);
System.Xml.Xsl.XslCompiledTransform transformador = new System.Xml.Xsl.XslCompiledTransform(true);
transformador.Load(pathxsl);
using (StringReader sri = new StringReader(xml)) // xmlInput is a string that contains xml
{
using (XmlReader xri = XmlReader.Create(sri))
{
using (StringWriter sw = new StringWriter())
{
using (XmlWriter xwo = XmlWriter.Create(sw, transformador.OutputSettings))
{
transformador.Transform(xri, xwo);
result = sw.ToString();
}
}
}
}
return(result);
}
/// <summary>
/// Creates a new SPARQL XSLT Writer
/// </summary>
/// <param name="stylesheetUri">Stylesheet URI</param>
public SparqlXsltWriter(String stylesheetUri)
{
//Load the Transform
this._transform = new XslCompiledTransform();
XsltSettings settings = new XsltSettings();
this._transform.Load(stylesheetUri, settings, null);
}
private void TransformXml()
{
XslCompiledTransform xslTransformer = new XslCompiledTransform();
xslTransformer.Load( Server.MapPath( AttributeValue("XSLTFile") ) );
Rock.Web.Cache.Page rootPage;
if ( AttributeValue( ROOT_PAGE ) != string.Empty )
{
int pageId = Convert.ToInt32( AttributeValue( ROOT_PAGE ) );
if ( pageId == -1 )
rootPage = PageInstance;
else
rootPage = Rock.Web.Cache.Page.Read( pageId );
}
else
rootPage = PageInstance;
int levelsDeep = Convert.ToInt32( AttributeValue( NUM_LEVELS ) );
XDocument pageXml = rootPage.MenuXml( levelsDeep, CurrentUser );
StringBuilder sb = new StringBuilder();
TextWriter tw = new StringWriter( sb );
xslTransformer.Transform( pageXml.CreateReader(), null, tw );
phContent.Controls.Clear();
phContent.Controls.Add( new LiteralControl( sb.ToString() ) );
}
public static void XSLTransform(XmlDocument doc, ref StreamWriter writer, string xsltUrl)
{
System.Xml.Xsl.XslCompiledTransform xslt = new System.Xml.Xsl.XslCompiledTransform();
xslt.Load(xsltUrl);
//Transform the file.
xslt.Transform(doc, null, writer);
}
private void Transform_Results(string xsltResourceName, XElement element, XmlWriter writer)
{
var xmlTransform = new System.Xml.Xsl.XslCompiledTransform();
var name = GetType().Assembly.GetManifestResourceNames().Where(a => a.EndsWith(xsltResourceName, StringComparison.Ordinal)).FirstOrDefault();
if (name == null)
{
return;
}
using (var xsltStream = GetType().Assembly.GetManifestResourceStream(name))
{
if (xsltStream == null)
{
throw new Exception($"Stream with name {name} cannot be found! We have {GetType().Assembly.GetManifestResourceNames()[0]}");
}
// add the extension so that we can get the hash from the name of the test
// Create an XsltArgumentList.
var xslArg = new XsltArgumentList();
var generator = new XsltIdGenerator();
xslArg.AddExtensionObject("urn:hash-generator", generator);
using (var xsltReader = XmlReader.Create(xsltStream))
using (var xmlReader = element.CreateReader())
{
xmlTransform.Load(xsltReader);
xmlTransform.Transform(xmlReader, xslArg, writer);
}
}
}
public static string Transform(string xml, string xslPath)
{
try
{
//create an XPathDocument using the reader containing the XML
MemoryStream m = new MemoryStream(System.Text.Encoding.Default.GetBytes(xml));
XPathDocument xpathDoc = new XPathDocument(new StreamReader(m));
//Create the new transform object
XslCompiledTransform transform = new XslCompiledTransform();
//String to store the resulting transformed XML
StringBuilder resultString = new StringBuilder();
XmlWriter writer = XmlWriter.Create(resultString);
transform.Load(xslPath);
transform.Transform(xpathDoc,writer);
return resultString.ToString();
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e.ToString());
return e.ToString();
}
}
public string GetSearchResultsHtml(string term, int skip, int take)
{
var response = new StringBuilder();
var xmlResults = this.SearchData.GetSearchResultsXML(term, skip, take);
if (xmlResults != null)
{
using (var xmlReader = XmlReader.Create(new StringReader(xmlResults.OuterXml)))
{
using (var xslReader = XmlReader.Create(HttpContext.Current.Server.MapPath(XSLTTransformFile)))
{
using (var xmlWriter = XmlWriter.Create(response, new XmlWriterSettings
{
OmitXmlDeclaration = true
}))
{
var xslTransformer = new XslCompiledTransform();
xslTransformer.Load(xslReader, new XsltSettings(true, true), new XmlUrlResolver
{
Credentials = CredentialCache.DefaultCredentials
});
xslTransformer.Transform(xmlReader, xmlWriter);
}
}
}
}
return response.ToString();
}
protected static void MigrateUsingXslt(TextReader xslStream, TextReader xmlStream, string destinationFilePath)
{
var transform = new XslCompiledTransform();
using (xslStream)
{
using (xmlStream)
{
using (var destinationStream = new StreamWriter(destinationFilePath))
{
var xslReader = XmlReader.Create(xslStream);
transform.Load(xslReader);
xslReader.Close();
xslStream.Close();
var reader = XmlReader.Create(xmlStream);
var settings = new XmlWriterSettings { Indent = true };
var writer = XmlWriter.Create(destinationStream, settings);
transform.Transform(reader, writer);
var tempfiles = transform.TemporaryFiles;
if (tempfiles != null) // tempfiles will be null when debugging is not enabled
{
tempfiles.Delete();
}
writer.Close();
reader.Close();
destinationStream.Close();
}
xmlStream.Close();
}
}
}
public object BeforeSendRequest(ref Message request, IClientChannel channel)
{
if (!request.IsEmpty)
{
XmlReader bodyReader = request.GetReaderAtBodyContents().ReadSubtree();
MemoryStream stream = new MemoryStream();
XmlWriter writer = XmlWriter.Create(stream);
if (transform == null)
{
transform = new XslCompiledTransform(true);
var reader = XmlReader.Create(new StringReader(Properties.Resources.XmlCleaner));
transform.Load(reader);
}
transform.Transform(bodyReader, writer);
stream.Flush();
stream.Seek(0, SeekOrigin.Begin);
bodyReader = XmlReader.Create(stream);
Message changedMessage = Message.CreateMessage(request.Version, null, bodyReader);
changedMessage.Headers.CopyHeadersFrom(request.Headers);
changedMessage.Properties.CopyProperties(request.Properties);
request = changedMessage;
}
return null;
}
public static void Main()
{
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load(XsltPath);
xslt.Transform(CataloguePath, HtmlPath);
Console.WriteLine("Successfully transformed in catalogue.html");
}
public bool GenerateReport(string fileName)
{
bool retCode = false;
ResetReportViwer();
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load(rptXslPath);
if ( File.Exists(fileName) == true)
{
XPathDocument myXPathDoc = new XPathDocument(fileName);
StringWriter sw = new StringWriter();
XmlWriter xmlWriter = new XmlTextWriter(sw);
// using makes sure that we flush the writer at the end
xslt.Transform(myXPathDoc, null, xmlWriter);
xmlWriter.Flush();
xmlWriter.Close();
string xml = sw.ToString();
HtmlDocument htmlDoc = axBrowser.Document;
htmlDoc.Write(xml);
retCode = true;
}
else
{
retCode = false;
}
return retCode;
}
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 static string XslTransInMemory(string xmlData, string xslData, XsltArgumentList argslist)
{
try
{
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(xmlData);
byte[] bytes = System.Text.Encoding.UTF8.GetBytes(xslData);
var xslStream = new System.IO.MemoryStream(bytes)
{
Position = 0
};
XmlReader xslStylesheet = default(System.Xml.XmlReader);
xslStylesheet = new System.Xml.XmlTextReader(xslStream);
var xslt = new System.Xml.Xsl.XslCompiledTransform();
var settings = new System.Xml.Xsl.XsltSettings {
EnableDocumentFunction = true
};
xslt.Load(xslStylesheet, settings, null);
var myWriter = new System.IO.StringWriter();
xslt.Transform(xmlDoc, argslist, myWriter);
return(myWriter.ToString());
}
catch (Exception ex)
{
return(ex.ToString() + " .............. " + xslData);
}
}
public static void Main()
{
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load("../../../14.catalog.xslt");
xslt.Transform("..\\..\\..\\XmlCatalogDirectory\\text.xml", "../../../14. Catalog.html");
Console.WriteLine("Successfully transformed!");
}
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);
}
}
private static void Main()
{
var xsl = new XslCompiledTransform();
xsl.Load(Constants.FilePathForXslt);
xsl.Transform(Constants.FilePathForCatalogue, SaveFilePath);
Console.WriteLine("Catalogue.xml created in project folder.");
}
public static void Main()
{
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load("../../Catalog.xslt");
xslt.Transform("../../Catalog.xml", "../../Catalog.html");
Console.WriteLine("File Catalog.html is created.");
}
static void Main()
{
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load("../../style.xslt");
xslt.Transform("../../../CatalogHolder/catalogue.xml", "../../catalogue.html");
Console.WriteLine("result saved as catalogue.html");
}
private void ApplyTransform()
{
var xslt = new System.Xml.Xsl.XslCompiledTransform();
xslt.Load(FormData.XslTransformPath);
xslt.Transform(FormData.InputSchemePath, FormData.OutputSchemePath);
MessageBox.Show("Transform done", "Action completed", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
//• page-start-number: Page start number (default: 1)
//• page-setup-paper-width: Paper width in TWIPS (default: 11907 TWIPS = 21 cm, i.e. A4 format)
//• page-setup-paper-height: Paper height in TWIPS (default: 16840 TWIPS = 29.7 cm, i.e. A4 format)
//• page-setup-margin-top: Top margin in TWIPS (default: 1440 TWIPS = 1 inch = 2.54 cm)
//• page-setup-margin-bottom: Bottom margin in TWIPS (default: 1440 TWIPS = 1 inch = 2.54 cm)
//• page-setup-margin-left: Left margin in TWIPS (default: 1134 TWIPS = 2 cm)
//• page-setup-margin-right: Right margin in TWIPS (default: 1134 TWIPS = 2 cm)
//• font-size-default: Default font size in TWIPS (default: 20 TWIPS = 10 pt.)
//• font-name-default: Default font name (default: 'Times New Roman')
//• font-name-fixed: Default font name for fixed-width text, like PRE or CODE (default: 'Courier New')
//• font-name-barcode: Barcode font name (default: '3 of 9 Barcode')
//• header-font-size-default: Header default font size in TWIPS (default: 14 TWIPS = 7 pt.)
//• header-distance-from-edge: Default distance between top of page and top of header, in TWIPS (default: 720 TWIPS = 1.27 cm)
//• header-indentation-left: Header left indentation in TWIPS (default: 0)
//• footer-font-size-default: Footer default font size in TWIPS (default: 14 TWIPS = 7 pt.)
//• footer-distance-from-edge: Default distance between bottom of page and bottom of footer, in TWIPS (default: 720 TWIPS = 1.27 cm)
//• use-default-footer: Boolean flag: 1 to use default footer (page number and date) or 0 no footer (default: 1)
//• document-protected: Boolean flag: 1 protected (cannot be modified) or 0 unprotected (default: 1)
//• normalize-space: Boolean flag: 1 spaces are normalized and trimmed, or 0 no normalization no trim (default: 0)
//• my-normalize-space: Boolean flag: 1 spaces are normalized (NOT TRIMMED), or 0 no normalization (default: 1)
public static string Html2Rtf(string html, NameValueCollection parameters)
{
// Load data.
var xml = new System.Xml.XmlDocument();
xml.Load(EngineHelper.GetResourceStream("Help.htm"));
xml.DocumentElement.SetAttribute("xmlns", "http://www.w3.org/1999/xhtml");
xml.DocumentElement.SetAttribute("xmlns:xhtml2rtf", "http://www.lutecia.info/download/xmlns/xhtml2rtf");
//xml.DocumentElement.SetAttribute("SelectionLanguage", "XPath");
//xml.DocumentElement.SetAttribute("SelectionNamespaces", "xmlns='http://www.w3.org/1999/xhtml' xmlns:xhtml='http://www.w3.org/1999/xhtml'");
xml.Load(new StringReader(xml.OuterXml));
// Load style sheet.
var xslDoc = new System.Xml.XmlDocument();
xslDoc.Load(EngineHelper.GetResourceStream("xhtml2rtf.xsl"));
//xslDoc.DocumentElement.SetAttribute("SelectionLanguage", "XPath");
//xslDoc.DocumentElement.SetAttribute("SelectionNamespaces", "xmlns:xhtml='http://www.w3.org/1999/xhtml' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'");
//xslDoc.Load(new StringReader(xslDoc.OuterXml));
// Create namespace manager.
XmlNamespaceManager man = new XmlNamespaceManager(xslDoc.NameTable);
man.AddNamespace("xsl", "http://www.w3.org/1999/XSL/Transform");
// Set parameters in stylesheet
if (parameters != null)
{
foreach (var name in parameters.AllKeys)
{
var value = parameters[name];
var xmlParam = xslDoc.DocumentElement.SelectSingleNode("//xsl:param[@name='" + name + "']", man);
if (xmlParam != null)
{
var xmlParamValue = xmlParam.SelectSingleNode("@select", man);
if (xmlParamValue != null)
{
xmlParamValue.InnerText = value;
}
}
}
}
// Load the String into a TextReader
System.IO.StringReader tr = new System.IO.StringReader(xslDoc.OuterXml);
// Use that TextReader as the Source for the XmlTextReader
System.Xml.XmlReader xr = new System.Xml.XmlTextReader(tr);
// Create a new XslTransform class
var xsl = new System.Xml.Xsl.XslCompiledTransform(true);
// Load the XmlReader StyleSheet into the XslTransform class
xsl.Load(xr, new XsltSettings(false, true), (XmlResolver)null);
// Create output
var sb = new System.Text.StringBuilder();
var tw = new System.IO.StringWriter(sb);
xsl.Transform(xml, (XsltArgumentList)null, tw);
// Return RTF document.
return(sb.ToString());
}
public static void ValidateXslt(this string str)
{
var com = new System.Xml.Xsl.XslCompiledTransform();
using (var reader = XmlReader.Create(new StringReader(str)))
{
com.Load(reader);
}
}
//
// .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());
}
/* public static System.Xml.XmlDocument XslTransform(System.Xml.XPath.IXPathNavigable xmlSourceDoc, System.Xml.Xsl.XslCompiledTransform xsltDoc)
* {
* System.IO.MemoryStream outputStream = new System.IO.MemoryStream();
* System.Xml.XmlDocument outputDoc = new System.Xml.XmlDocument();
*
* xsltDoc.Transform(xmlSourceDoc, null, outputStream);
* if (outputStream.Length != 0)
* outputStream.Position = 0;
*
* // if it's a node, it's a partial doc
* if (xmlSourceDoc is System.Xml.XmlDocument)
* outputDoc.Load(outputStream);
* else
* {
* byte[] buff = new byte[outputStream.Length];
* outputStream.Read(buff, 0, buff.Length);
* System.Text.StringBuilder sb = new StringBuilder(buff.Length);
* System.Web.HttpContext.Current.Response.OutputStream.Write(buff, 0, buff.Length);
* System.Web.HttpContext.Current.Response.End();
* return null;
* sb.Append(Encoding.ASCII.GetChars(buff));
* sb.Replace("?", string.Empty);
* outputDoc.LoadXml("<html>" + sb.ToString() + "</html>");
* }
* return outputDoc;
* }
*/
public static System.Xml.Xsl.XslCompiledTransform GetXslCompiledTransform(string xsltFilename)
{
System.Xml.Xsl.XslCompiledTransform xslTransform = (System.Xml.Xsl.XslCompiledTransform)RestNet.Cache.Get(xsltFilename);
if (xslTransform == null)
{
xslTransform = new System.Xml.Xsl.XslCompiledTransform();
xslTransform.Load(new XmlTextReader(xsltFilename), XsltSettings.TrustedXslt, new XmlUrlResolver());
string[] fnTemp = { xsltFilename };
RestNet.Cache.Set(xsltFilename, xslTransform, fnTemp, null, true, TimeSpan.MaxValue);
}
return(xslTransform);
}
public static System.Xml.Xsl.XslCompiledTransform GetXSLContent(string ContentURL)
{
System.Xml.Xsl.XslCompiledTransform functionReturnValue = null;
functionReturnValue = new System.Xml.Xsl.XslCompiledTransform();
WebRequest req = WebRequest.Create(ContentURL);
WebResponse result = req.GetResponse();
Stream ReceiveStream = result.GetResponseStream();
XmlReader objXSLTransform = new XmlTextReader(result.GetResponseStream());
functionReturnValue.Load(objXSLTransform, null, null);
return(functionReturnValue);
}
protected virtual System.Xml.Xsl.XslCompiledTransform DoGetTransformer(int cacheduration, IPDFDataSource source, PDFDataContext context)
{
if (null == _transformer)
{
string path = this.XSLTPath;
if (string.IsNullOrEmpty(path))
{
throw new NullReferenceException(string.Format(Errors.XSLTPathOrTransformerNotSetOnInstance, source.ID));
}
path = source.MapPath(path);
IPDFCacheProvider cache = ((Scryber.Components.Document)source.Document).CacheProvider;
System.Xml.Xsl.XslCompiledTransform transformer;
object found;
if (cacheduration > 0 && cache.TryRetrieveFromCache(XSLTCacheType, path, out found))
{
transformer = (System.Xml.Xsl.XslCompiledTransform)found;
}
else
{
transformer = new System.Xml.Xsl.XslCompiledTransform(XSLTUseDebug);
try
{
transformer.Load(path);
}
catch (Exception ex)
{
throw new PDFDataException(string.Format(Errors.XSLTCouldNotBeLoadedFromPath, path), ex);
}
if (cacheduration > 0)
{
cache.AddToCache(XSLTCacheType, path, transformer, new TimeSpan(0, cacheduration, 0));
}
}
_transformer = transformer;
}
return(_transformer);
}
/// <summary>
///
/// </summary>
/// <param name="xslt"></param>
/// <param name="pathDoc"></param>
/// <param name="uriPrms"></param>
/// <returns></returns>
public static string TransformXSLToHTML(string xslFilePath, XPathDocument pathDoc)
{
System.Xml.Xsl.XslCompiledTransform xslTransform = new System.Xml.Xsl.XslCompiledTransform();
XsltArgumentList arg = GetArgumentListFromUrl();
//SET SETTINGS
XmlReaderSettings set = new XmlReaderSettings();
set.ProhibitDtd = false;
set.XmlResolver = null;
XmlReader xslRdr = XmlReader.Create(xslFilePath);
xslTransform.Load(xslRdr);
//TRANSFORM
System.IO.StringWriter sw = new System.IO.StringWriter();
xslTransform.Transform(pathDoc, arg, sw);
return(System.Web.HttpUtility.HtmlDecode(sw.ToString()));
}
public static string Transform(string xslFilePath, XsltArgumentList arg, string xmlUrl, string controlId, string cacheDuration)
{
System.Xml.Xsl.XslCompiledTransform xslTransform = new System.Xml.Xsl.XslCompiledTransform();
xslTransform.Load(xslFilePath);
//Add helper class
XslFunctions func = new XslFunctions(HttpContext.Current.Request.Url.ToString());
if (arg == null)
{
arg = new XsltArgumentList();
}
arg.AddExtensionObject("awp:functions", func);
//TRANSFORM
System.IO.StringWriter sw = new System.IO.StringWriter();
xslTransform.Transform(xmlUrl, arg, sw);
return(System.Web.HttpUtility.HtmlDecode(sw.ToString()));
}
/// <summary>
/// 获得Docx文件用xslt转出来的html字符串
/// </summary>
/// <param name="titleStyleId">论文标题样式Id</param>
/// <returns>xslt转出来的html字符串</returns>
public string TransToStr(string titleStyleId, string authorInfo, string affiliationInfo)
{
//用来接收将xml转成html的流
MemoryStream ms = new MemoryStream();
//xslt编译转换对象
System.Xml.Xsl.XslCompiledTransform trans = new System.Xml.Xsl.XslCompiledTransform();//------------trans
//xslt参数对象
XsltArgumentList argsList = new XsltArgumentList();
argsList.AddParam("titleStyleId", "", titleStyleId);
//将作者信息html作为参数 传入到xslt文件中
argsList.AddParam("authorInfo", "", authorInfo);
//将单位信息html作为参数 传入到xslt文件中
argsList.AddParam("affiliationInfo", "", affiliationInfo);
//根据xslt文件路径读取 xslt文件内容
using (StreamReader rdr = new StreamReader(new FileStream(this.xsltpath, FileMode.Open)))
{
//将读到的xslt内容加载到XmlReader里面
using (XmlReader xmlRdr = new XmlTextReader(rdr))
{
//将xmlRdr内容加载到trans里面
trans.Load(xmlRdr);
}
}
//创建一个新的XmlDocument对象
XmlDocument document = new XmlDocument();//------------document
//用document对象加载xml内容
document.LoadXml(this.xmlcontent);
trans.Transform(document, argsList, ms);
ms.Position = 0;
StreamReader reader = new StreamReader(ms, Encoding.UTF8);
string result = reader.ReadToEnd();
return(result);
}
public string GetOriginalChain(string stringXML)
{
StringWriter sw = new StringWriter();
try
{
XslCompiledTransform xslt = new System.Xml.Xsl.XslCompiledTransform();
XsltSettings sets = new XsltSettings(true, true);
var resolver = new XmlUrlResolver();
xslt.Load(xsltPath, sets, resolver);
XmlDocument FromXmlFile = new System.Xml.XmlDocument();
FromXmlFile.LoadXml(stringXML);
xslt.Transform(FromXmlFile, null, sw);
}
catch (Exception ex)
{
throw new Exception("No se pudo generar la cadena", ex.InnerException);
}
return(sw.ToString());
}
public static string XslTrans(string xmlData, string xslFilePath)
{
try
{
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml(xmlData);
var xslt = new System.Xml.Xsl.XslCompiledTransform();
xslt.Load(xslFilePath);
var myWriter = new System.IO.StringWriter();
xslt.Transform(xmlDoc, null, myWriter);
return(myWriter.ToString());
}
catch (Exception ex)
{
return(ex.ToString());
}
}
public string GetXmlPage(string templatePath, string dataPath)
{
if (templatePath == null)
{
throw new ArgumentNullException("Missing xslt template path. Set XsltTemplatePath for ILayoutService in controller's constructor");
}
string xsl = templatePath;
string xml = dataPath;
System.Xml.XPath.XPathDocument doc = new System.Xml.XPath.XPathDocument(xml);
XslCompiledTransform trans = new System.Xml.Xsl.XslCompiledTransform();
trans.Load(xsl);
StringWriter writer = new StringWriter();
trans.Transform(doc, null, writer);
var decoded = HttpUtility.HtmlDecode(writer.ToString());
return(decoded.ToString());
}
/// <summary>
/// Loads the stylesheet into the transform engine
/// </summary>
private System.Xml.Xsl.XslCompiledTransform GetXslTransform(string xslsrc, int portalId)
{
if (!string.IsNullOrEmpty(xslsrc))
{
switch (Globals.GetURLType(xslsrc))
{
case TabType.Url:
return(GetXslContentByWebRequest(xslsrc, ProhibitDtd, EnableDocument, EnableScript));
default:
var trans = new System.Xml.Xsl.XslCompiledTransform();
using (var compiledStylesheet = Utils.CreateXmlReader(xslsrc, portalId, ProhibitDtd))
{
var settings = new XsltSettings(EnableDocument, EnableScript);
trans.Load(compiledStylesheet, settings, new XmlUrlResolver());
}
return(trans);
}
}
return(null);
}
/// <summary>
/// GetXSLContent loads the xsl content into an Xsl.XslCompiledTransform
/// </summary>
/// <param name = "contentUrl">The url to the xsl text</param>
/// <param name = "prohibitDtd"></param>
/// <returns>A XslCompiledTransform</returns>
private static System.Xml.Xsl.XslCompiledTransform GetXslContentByWebRequest(string contentUrl, bool prohibitDtd, bool enableDocument, bool enableScript)
{
var xslCompiledTransform = new System.Xml.Xsl.XslCompiledTransform();
var req = Globals.GetExternalRequest(contentUrl);
using (var result = req.GetResponse())
{
using (var receiveStream = result.GetResponseStream())
{
if (receiveStream != null)
{
var xmlReaderSettings = new XmlReaderSettings();
xmlReaderSettings.DtdProcessing = DtdProcessing.Prohibit;
using (var objXslTransform = XmlReader.Create(receiveStream, xmlReaderSettings))
{
var settings = new XsltSettings(enableDocument, enableScript);
xslCompiledTransform.Load(objXslTransform, settings, new XmlUrlResolver());
}
}
}
}
return(xslCompiledTransform);
}
/// <summary>
/// Begins the style preparation.
/// </summary>
/// <remarks>Documented by Dev02, 2008-09-12</remarks>
public static void BeginStylePreparation(string stylesheetPath)
{
stylePrepareThread = new Thread(delegate()
{
try
{
Debug.WriteLine("Style preparation thread started.");
serializer = new XmlSerializer(typeof(Style));
versionTransform10_11 = new System.Xml.Xsl.XslCompiledTransform();
XsltSettings settings = new XsltSettings(true, false); //enable document() function
versionTransform10_11.Load(Path.Combine(stylesheetPath, @"System\Transformer\versionTransform10_11.xsl"), settings, null);
Debug.WriteLine("Style preparation thread finished successfully.");
}
catch (Exception exp)
{
Trace.WriteLine("Style preparation thread crashed: " + exp.ToString());
}
});
stylePrepareThread.IsBackground = true;
stylePrepareThread.Name = "Style Preparation Thread";
stylePrepareThread.CurrentCulture = Thread.CurrentThread.CurrentCulture;
stylePrepareThread.CurrentUICulture = Thread.CurrentThread.CurrentUICulture;
stylePrepareThread.Start();
}
public static System.Xml.Xsl.XslCompiledTransform GetXslCompiledTransform(XmlDocument xsltDocument)
{
System.Xml.Xsl.XslCompiledTransform xslTransform = new System.Xml.Xsl.XslCompiledTransform();
xslTransform.Load(xsltDocument, XsltSettings.TrustedXslt, new XmlUrlResolver());
return(xslTransform);
}
public static string XslTransformToString(System.Xml.XPath.IXPathNavigable xmlSourceDoc, System.Xml.Xsl.XslCompiledTransform stylesheet)
{
System.IO.StringWriter sResult = new System.IO.StringWriter();
stylesheet.Transform(xmlSourceDoc, null, sResult);
return(sResult.ToString());
}
public static string XslTransformToString(System.Xml.XPath.IXPathNavigable xmlSourceDoc, string xsltFilename)
{
System.Xml.Xsl.XslCompiledTransform stylesheet = GetXslCompiledTransform(GetFullXmlFilename(xsltFilename));
return(XslTransformToString(xmlSourceDoc, stylesheet));
}
public static System.Xml.XmlDocument XslTransform(System.Xml.XPath.IXPathNavigable xmlSourceDoc, string xsltFilename, XsltArgumentList xslArgs)
{
System.Xml.Xsl.XslCompiledTransform stylesheet = GetXslCompiledTransform(GetFullXmlFilename(xsltFilename));
return(XslTransform(xmlSourceDoc, stylesheet, xslArgs));
}
public static System.Xml.XmlDocument XslTransform(System.Xml.XPath.IXPathNavigable xmlSourceDoc, System.Xml.Xsl.XslCompiledTransform xsltDoc)
{
return(XslTransform(xmlSourceDoc, xsltDoc, null));
}
public static System.Xml.XmlDocument XslTransform(System.Xml.XPath.IXPathNavigable xmlSourceDoc, System.Xml.Xsl.XslCompiledTransform xsltDoc, XsltArgumentList xslArgs)
{
System.Xml.XmlDocument outputDoc = new System.Xml.XmlDocument();
System.IO.MemoryStream ms = new System.IO.MemoryStream();
xsltDoc.Transform(xmlSourceDoc, xslArgs, ms);
ms.Position = 0;
outputDoc.Load(ms);
return(outputDoc);
}
// Code for input validation
static int Idoit(string csv, string xsltstr, string outputcsvfile, bool outputheader, string xsdstr, out string firstErrors)
{
XDocument doc = ConvertCsvToXML(csv, new[] { "," });
Upx upx;
upx.startrectype63 = 0;
upx.startrectype64 = 0;
upx.outputrectype60 = false;
firstErrors = "";
if (outputheader == true && xsdstr.Length > 0)
{
int errorcount = 0;
string errstr = "";
XmlSchemaSet schemas = new XmlSchemaSet();
schemas.Add("", System.Xml.XmlReader.Create(new StringReader(xsdstr)));
doc.Validate(schemas, (o, e) =>
{
// Console.WriteLine("{0}", e.Message);
if (e.Message.IndexOf("attribute is not declared") == -1)
{
if (errorcount < 20)
{
errstr += e.Message + "\n";
}
errorcount++;
}
});
if (errorcount > 0)
{
firstErrors = errstr;
Console.WriteLine(errstr);
return(errorcount);
}
}
XDocument newDoc = new XDocument();
using (System.Xml.XmlWriter writer = newDoc.CreateWriter())
{
System.Xml.Xsl.XslCompiledTransform xslt = new System.Xml.Xsl.XslCompiledTransform();
System.Xml.Xsl.XsltSettings settings = new System.Xml.Xsl.XsltSettings()
{
EnableDocumentFunction = true
};
xslt.Load(System.Xml.XmlReader.Create(new StringReader(xsltstr)), settings, new System.Xml.XmlUrlResolver());
xslt.Transform(doc.CreateReader(), writer);
//System.Xml.Xsl.XslCompiledTransform xslt = new System.Xml.Xsl.XslCompiledTransform();
//xslt.Load(System.Xml.XmlReader.Create(new StringReader(xsltstr)));
//xslt.Transform(doc.CreateReader(), writer);
}
string ext = Path.GetExtension(outputcsvfile);
if (ext == ".csv")
{
converttocsv(newDoc, outputcsvfile, "rec", RowDelimit.NewLine, ColumnDelimit.Comma, outputheader);
}
if (ext == ".upx")
{
Console.WriteLine("=======GENERATING UPX=========");
converttoupx(newDoc, outputcsvfile, "rec", RowDelimit.NewLine, ColumnDelimit.Comma, outputheader, ref upx);
}
return(0);
}
