/// <summary>
/// Transformes CAML xml fragment trough XSL stylesheet.
/// </summary>
/// <param name="caml">Source xml = CAML fragment</param>
/// <param name="ti">Transformation</param>
/// <returns>Transformed text</returns>
public static string TransformCAML(XmlNode caml, TransformationInfo ti)
{
XslCompiledTransform xslTransform = new XslCompiledTransform();
// Read stylesheet code from transformation
StringReader stream = new StringReader(ti.TransformationCode);
XmlTextReader xmlReader = new XmlTextReader(stream);
xslTransform.Load(xmlReader);
// Create XMLDocument from CAML fragment
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(caml.InnerXml);
StringWriter transformed = new StringWriter();
xslTransform.Transform(xmlDoc, null, transformed);
return transformed.ToString();
}
public static object GetData(StageParams config)
{
XmlDocument input = Util.Validate<XmlDocument>( config.data, "XSLTStage" );
string xslPath = config.context.Server.MapPath( config.map );
if (!File.Exists(xslPath))
throw new FileLoadException(String.Format("Style sheet {0} is not found", xslPath));
XslCompiledTransform transform = new XslCompiledTransform();
transform.Load(xslPath, new XsltSettings(false, true), new XmlUrlResolver());
XsltArgumentList al = new XsltArgumentList();
int index = 0;
foreach (XmlNode node in config.stage)
if ( node.Attributes["type"] != null )
al.AddParam( node.Name, "", config.allParams[index++]);
if (!config.last)
{
MemoryStream output = new MemoryStream();
transform.Transform(input, al, output);
return output;
}
else
{
transform.Transform(input, al, config.outputStream);
return null;
}
}
public static string Transform(string xsltFile, string xml, XsltArgumentList xslArg)
{
string result = "";
try {
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load(xsltFile);
// XmlWriterSettings.OmitXmlDeclaration
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(new StringReader(xml));
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.OmitXmlDeclaration = true;
settings.NewLineOnAttributes = true;
using (StringWriter sw = new StringWriter()) {
using (XmlWriter writer = XmlWriter.Create(sw, settings)) {
xslt.Transform(xmlDoc, xslArg, writer);
}
sw.Flush();
result = sw.ToString();
}
} catch (Exception ex) {
Console.WriteLine(ex.ToString());
}
return result;
}
static void Main()
{
var xslt = new XslCompiledTransform();
xslt.Load(stylesheet);
xslt.Transform(inputFile, outputFile);
Console.WriteLine("HTML file saved to {0}", outputFile);
}
static void Main()
{
XslCompiledTransform xslt =
new XslCompiledTransform();
xslt.Load("../../../MusicCatalogue.xslt");
xslt.Transform("../../../MusicCatalogue.xml", "../../../14.MusicCatalogue.html");
Console.WriteLine("Successfully transformed!");
}
static void Main()
{
string originPathXslt = "../../../xml/catalogue.xslt";
string originPathXml = "../../../xml/catalogue.xml";
string destinationPath = "../../../xml/catalogue.html";
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load(originPathXslt);
xslt.Transform(originPathXml, destinationPath);
}
protected void ToExcel_Click(object sender, EventArgs e)
{
string json = ExcelGridData.Value.ToString();
StoreSubmitDataEventArgs eSubmit = new StoreSubmitDataEventArgs(json, null);
XmlNode xml = eSubmit.Xml;
this.Response.Clear();
this.Response.ContentType = "application/vnd.ms-excel";
this.Response.AddHeader("Content-Disposition", "attachment; filename=SaleRank.xls");
XslCompiledTransform xtExcel = new XslCompiledTransform();
xtExcel.Load(Server.MapPath("./Styles/Excel.xsl"));
xtExcel.Transform(xml, null, this.Response.OutputStream);
this.Response.End();
}
protected void Page_Load(object sender, EventArgs e)
{
Response.ContentType = "text/xml";
string xsltFile = Server.MapPath("books.xslt");
string xmlFile = Server.MapPath("books.xml");
XslCompiledTransform xslt = new XslCompiledTransform(true); //Pass in true to enable XSLT Debugging
xslt.Load(xsltFile);
XPathDocument doc = new XPathDocument(xmlFile);
xslt.Transform(doc, new XmlTextWriter(Response.Output));
}
private XDocument TransformMarkup(XElement inputRoot)
{
var newTree = new XDocument();
using (XmlWriter writer = newTree.CreateWriter())
{
var xslTransformer = new XslCompiledTransform();
xslTransformer.LoadFromPath(this.MapPath(XsltFileName));
xslTransformer.Transform(inputRoot.CreateReader(), writer);
}
return newTree;
}
static void Main()
{
string decorationLine = new string('-', Console.WindowWidth);
Console.Write(decorationLine);
Console.WriteLine("***Transforming the XML document 'albums-catalogue.xml' to a HTML");
Console.WriteLine("file using 'albums-catalogue.xsl' stylesheet file with XSLT***");
Console.Write(decorationLine);
XslCompiledTransform xslTransformer = new XslCompiledTransform();
xslTransformer.Load("../../albums-catalogue.xsl");
xslTransformer.Transform("../../albums-catalogue.xml", "../../albums-catalogue.html");
Console.WriteLine("Completed! You can see the HTML file in project's directory!");
}
protected void Page_Load(object sender, EventArgs e)
{
string m = "<?xml version=\"1.0\"?>";
m += "<address>";
m += "<addressline1>" + "Veerannapet" + "</addressline1>";
m += "<addressline2>" + "Veerannapet2" + "</addressline2>";
m += "<city>" + "Mahabubnagar" + "</city>";
m += "<postcode>" + "509001" + "</postcode>";
m += "</address>";
string result1 = m.Replace("<?xml version=\"1.0\"?>", "");
XmlDocument docs = new XmlDocument();
docs.LoadXml(result1);
string json = Newtonsoft.Json.JsonConvert.SerializeXmlNode(docs);
XmlDocument doc = (XmlDocument)JsonConvert.DeserializeXmlNode(json, "Report");
XslCompiledTransform xsl = new XslCompiledTransform();
StringWriter result = new StringWriter();
xsl.Load(Server.MapPath("Focus.xslt"));
XmlTextWriter tx = new XmlTextWriter(result);
XmlDeclaration xmldecl;
xmldecl = doc.CreateXmlDeclaration("1.0", null, null);
XmlElement root = doc.DocumentElement;
doc.InsertBefore(xmldecl, root);
//string strs = doc.InnerXml.ToString();
doc.WriteTo(tx);
xsl.Transform(doc, null, tx);
result.Close();
result.Flush();
string str = result.ToString();
// ... And the result you'll send back will be usable in a report:
Response.ContentType = "text/xml";
Response.Write(str.ToString());
Response.Flush();
Response.Close();
}
public void Consume(string contentFolder, string siteFolder, string filename, string ext)
{
string contentFile = contentFolder + "/" + filename;
string templateFile = GetTemplateFilename(filename, ext);
SiteFile = siteFolder + "/index.html";
try {
//XsltArgumentList xslArg = BuildXsltArgumentList();
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load(templateFile);
using (StringWriter sw = new StringWriter()) {
using (XmlWriter writer = XmlWriter.Create(sw)) {
xslt.Transform(contentFile, XslArgs, writer);
}
sw.Flush();
Content = sw.ToString();
}
} catch (Exception ex) {
ReportError(templateFile, contentFile, ex);
}
}
//read in the blog posts from an RSS feed, using an XSLT stylesheet
protected void LoadLatestBlogPosts()
{
try
{
string LatestBlogPostsRssUrl = System.Configuration.ConfigurationManager.AppSettings["LatestBlogPostsRssUrl"];
string LatestBlogPostsXslUrl = Server.MapPath(string.Format("xsl/{0}", ConfigurationManager.AppSettings["LatestBlogPostsXslFile"]));
XmlDocument latestBlogPostsDoc = new XmlDocument();
XslCompiledTransform latestBlogPostsXsl = new XslCompiledTransform();
StringBuilder latestBlogPostsStringBuilder = new StringBuilder();
StringWriter latestBlogPostsStringWriter = new StringWriter(latestBlogPostsStringBuilder);
latestBlogPostsDoc.Load(LatestBlogPostsRssUrl);
latestBlogPostsXsl.Load(LatestBlogPostsXslUrl);
latestBlogPostsXsl.Transform(latestBlogPostsDoc, null, latestBlogPostsStringWriter);
//latestBlogPostsStringBuilder.Append("Cached at " + DateTime.Now.ToString());
LatestBlogPostsLiteral.Text = latestBlogPostsStringBuilder.ToString();
}
catch (Exception ex)
{
//no op; since the .text assignment is the last line, then the section will simply not display if there are errors
}
}
protected void imgSearchIcon_Click(object sender, ImageClickEventArgs e)
{
string helpCultureName = _cultureCookie != null ? _cultureCookie.Value : string.Empty;
string rootUrl = HelpSiteMapProvider.GetProviderRootUrlByCultureName(helpCultureName);
string contentIndexName = "HelpContentIndex:" + rootUrl;
ContentIndex myContentIndex = null;
ContentSearchResult mySearchResult = null;
XmlDocument doc = new XmlDocument();
XslCompiledTransform xslt = new XslCompiledTransform();
XsltArgumentList xsltArgs = new XsltArgumentList();
StringWriter xsltResult = null;
string exprPageTitle = @"(?si)(?:(?<=<meta\s*name\s*=\s*(?:""|')menuText(?:""|')\s*content\s*=\s*(?:""|'))(?<contentAttribute>.*?[^(?:"")]*)(?=(?:"")[^>]*>)|(?<=<meta\s*content\s*=\s*(?:""|'))(?<contentAttribute>.*?[^(?:"")]*)(?=(?:"")\s*name\s*=\s*(?:""|')menuText(?:""|')\s*[^>]*>))";
if (txtSearch.Text.Length > 0)
{
try
{
myContentIndex = Application[contentIndexName] as ContentIndex;
if (myContentIndex == null)
{
myContentIndex = new ContentIndex(Page.MapPath(rootUrl), exprPageTitle);
Application[contentIndexName] = myContentIndex;
}
mySearchResult = myContentIndex.Search(txtSearch.Text);
doc.LoadXml(mySearchResult.ToXml());
xslt.Load(Server.MapPath("css/searchResult.xsl"));
xsltArgs.AddParam("hrefPrefix", string.Empty, Request.Url.GetLeftPart(System.UriPartial.Path) + "?page=Help&content=");
xsltArgs.AddParam("relativeURL", string.Empty, rootUrl);
xsltArgs.AddParam("mappedURL", string.Empty, Page.MapPath(rootUrl));
xsltResult = new StringWriter();
xslt.Transform(doc, xsltArgs, xsltResult);
litMainContent.Text = xsltResult.ToString();
}
catch (XmlException xmlEx)
{
if (xmlEx.Message.ToLowerInvariant().Contains("root"))
{ //Missing root element.
litMainContent.Text = String.Format(GetLocalResourceObject("NoContentFound").ToString(), txtSearch.Text);
}
else
{
litMainContent.Text = String.Format(GetLocalResourceObject("UnableToSearch").ToString(), xmlEx.Message);
}
}
catch (Exception ex)
{
litMainContent.Text = String.Format(GetLocalResourceObject("UnableToSearch").ToString(), ex.Message);
}
finally
{
if (xsltResult != null)
xsltResult.Close();
}
}
}
static void Main()
{
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load(@"../../students.xsl");
xslt.Transform(@"../../StudentSystem.xml", "../../students.html");
}
/// <summary>
/// Obtains the content of the web part.
/// </summary>
/// <param name="partData">The part data.</param>
/// <returns></returns>
private string ObtainWebPartContent(WebPart partData)
{
string content = null;
if ((partData.ContentLink != null) && (partData.ContentLink.Length > 0))
{
content = FetchNetworkContent(partData.ContentLink);
}
if (content == null)
{
content = partData.Content;
}
if ((partData.ContentType == 1) || (partData.ContentType == 2))
{
return("<font color=red><b>Unsupported Web Part Content Format</b></font>");
}
if (partData.ContentType == 3)
{
XmlDocument document = new XmlDocument();
document.LoadXml(content);
string xslContent = null;
if ((partData.XSLLink != null) && (partData.XSLLink.Length > 0))
{
xslContent = FetchNetworkContent(partData.XSLLink);
}
if (xslContent == null)
{
xslContent = partData.XSL;
}
StringWriter output = new StringWriter();
#if FW10
XslTransform transform = new XslTransform();
transform.Load(new XmlTextReader(new StringReader(xslContent)));
transform.Transform(document, null, output);
#else
#if FW11
XslTransform transform = new XslTransform();
transform.Load(new XmlTextReader(new StringReader(xslContent)), new XmlUrlResolver(), new Evidence());
transform.Transform(document, null, output, new XmlUrlResolver());
#else
// setup and perform the XSLT transformation
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load(new XmlTextReader(new StringReader(xslContent)));
xslt.Transform(document, null, output);
#endif
#endif
content = output.ToString();
}
return(content);
}
public static MvcHtmlString RenderXslt(string xslPath, string xmlString, List<KeyValuePair<string, string>> parameters = null)
{
string xsltResult = string.Empty;
try
{
// XML Settings
XmlReaderSettings xmlSettings = new XmlReaderSettings();
xmlSettings.XmlResolver = null;
xmlSettings.IgnoreComments = true;
xmlSettings.DtdProcessing = DtdProcessing.Ignore;
xmlSettings.ValidationType = ValidationType.None;
// Attaches an action to the valiation event handler. This will write out error messages in the Output pane.
#if DEBUG
xmlSettings.ValidationEventHandler += (sender, e) =>
{
Debug.WriteLine(string.Format("{0}({1},{2}): {3} - {4}", e.Exception.SourceUri, e.Exception.LineNumber, e.Exception.LinePosition, e.Severity, e.Message));
};
#endif
// XSLT Settings
XmlReaderSettings xsltSettings = new XmlReaderSettings();
xsltSettings.XmlResolver = null;
xsltSettings.DtdProcessing = DtdProcessing.Ignore;
xsltSettings.ValidationType = ValidationType.None;
// Attaches an action to the valiation event handler. This will write out error messages in the Output pane.
#if DEBUG
xsltSettings.ValidationEventHandler += (sender, e) =>
{
Debug.WriteLine(string.Format("{0}({1},{2}): {3} - {4}", e.Exception.SourceUri, e.Exception.LineNumber, e.Exception.LinePosition, e.Severity, e.Message));
};
#endif
// Init params
XsltArgumentList xslArgs = new XsltArgumentList();
if (parameters != null)
{
foreach (KeyValuePair<string, string> param in parameters)
xslArgs.AddParam(param.Key, string.Empty, param.Value);
}
// Load XML
using (XmlReader reader = XmlReader.Create(new StringReader(xmlString), xmlSettings))
{
// Load XSL
XsltSettings xslSettings = new XsltSettings(true, true); // Need to enable the document() fucntion
using (XmlReader xslSource = XmlReader.Create(xslPath, xsltSettings))
{
XslCompiledTransform xsltDoc = new XslCompiledTransform();
xsltDoc.Load(xslSource, xslSettings, new XmlUrlResolver());
// Transform
using (var sw = new UTF8StringWriter())
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
settings.OmitXmlDeclaration = true;
using (var xw = XmlWriter.Create(sw, settings))
{
xsltDoc.Transform(reader, xslArgs, sw);
}
xsltResult = sw.ToString();
}
}
}
}
catch { } // custom error handling here
// Return result
return MvcHtmlString.Create(xsltResult);
}
// Function : Export_with_XSLT_Web
// Arguments : dsExport, sHeaders, sFileds, FormatType, FileName
// Purpose : Exports dataset into CSV / Excel format
private void Export_with_XSLT_Web(DataSet dsExport, string[] sHeaders, string[] sFileds, ExportFormat FormatType, string FileName)
{
try
{
// Appending Headers
response.Clear();
response.Buffer= true;
if(FormatType == ExportFormat.CSV)
{
response.ContentType = "text/csv";
response.AppendHeader("content-disposition", "attachment; filename=" + FileName);
}
else
{
response.ContentType = "application/vnd.ms-excel";
response.AppendHeader("content-disposition", "attachment; filename=" + FileName);
}
// XSLT to use for transforming this dataset.
MemoryStream stream = new MemoryStream( );
XmlTextWriter writer = new XmlTextWriter(stream, Encoding.Default);
CreateStylesheet(writer, sHeaders, sFileds, FormatType);
writer.Flush( );
stream.Seek( 0, SeekOrigin.Begin);
XmlDocument xsl = new XmlDocument();
xsl.Load(stream);
//XslTransform xslTran = new XslTransform();
//xslTran.Load(new XmlTextReader(stream), null, null);
//System.IO.StringWriter sw = new System.IO.StringWriter();
//xslTran.Transform(xmlDoc, null, sw, null);
XmlDataDocument xmlDoc = new XmlDataDocument(dsExport);
StringWriter sw = new StringWriter();
XmlTextWriter xtw = new XmlTextWriter(sw);
XslCompiledTransform t = new XslCompiledTransform();
t.Load((IXPathNavigable)xsl, null, null);
t.Transform((IXPathNavigable)xmlDoc, xtw);
//Writeout the Content
response.Write(sw.ToString());
sw.Close();
xtw.Close();
writer.Close();
stream.Close();
response.End();
sw.Dispose();
stream.Dispose();
}
catch(ThreadAbortException Ex)
{
string ErrMsg = Ex.Message;
}
catch(Exception Ex)
{
throw Ex;
}
}
protected void Page_Load(object sender, EventArgs e)
{
string username = Convert.ToString(Session["username"]);
Label1.Text = "Welcome" + " " + " " + username;
if (!IsPostBack)
{
// The page is being loaded and accessed for the first time.
// Retrieve user input from the form.
if (Request.QueryString["s"] == null)
// Set the default stock symbol to YHOO.
m_symbol = "YHOO";
else
// Get the user's input.
m_symbol = Request.QueryString["s"].ToString().ToUpper();
// Update the textbox value.
txtSymbol.Value = m_symbol;
// This DIV that contains text and DIVs that displays stock quotes and chart from Yahoo.
// Set the innerHTML property to replaces the existing content of the DIV.
divService.InnerHtml = "<br />";
if (m_symbol.Trim() != "")
{
try
{
// Return the stock quote data in XML format.
String arg = GetQuote(m_symbol.Trim());
if (arg == null)
return;
// Read XML.
// Declare an XmlDocument object to represents an XML document.
XmlDocument xd = new XmlDocument();
// Loads the XML data from a stream.
xd.LoadXml(arg);
// Read XSLT
// Declare an XslCompiledTransform object to transform XML data using an XSLT style sheet.
XslCompiledTransform xslt = new XslCompiledTransform();
// Use the Load method to load the Xsl transform object.
xslt.Load(Server.MapPath("stock.xsl"));
// Transform the XML document into HTML.
StringWriter fs = new StringWriter();
xslt.Transform(xd.CreateNavigator(), null, fs);
string result = fs.ToString();
// Replace the characters ">" and "<" back to "<" and ">".
divService.InnerHtml = "<br />" + result.Replace("<", "<").Replace(">", ">") + "<br />";
// Display stock charts.
String[] symbols = m_symbol.Replace(",", " ").Split(' ');
// Loop through each stock
for (int i = 0; i < symbols.Length; ++i)
{
if (symbols[i].Trim() == "")
continue;
int index = divService.InnerHtml.ToLower().IndexOf(symbols[i].Trim().ToLower() + " is invalid.");
// If index = -1, the stock symbol is valid.
if (index == -1)
{
// Use a random number to defeat cache.
Random random = new Random();
divService.InnerHtml += "<img id='imgChart_" + i.ToString() + "' src='http://ichart.finance.yahoo.com/b?s=" + symbols[i].Trim().ToUpper() + "& " + random.Next() + "' border=0><br />";
// 1 days
divService.InnerHtml += "<a style='font-family: Arial, Helvetica, sans-serif; font-size: 14px; color: Blue;' href='javascript:changeChart(0," + i.ToString() + ", \"" + symbols[i].ToLower() + "\");'><span id='div1d_" + i.ToString() + "'><b>1d</b></span></a> ";
// 5 days
divService.InnerHtml += "<a style='font-family: Arial, Helvetica, sans-serif; font-size: 14px; color: Blue;' href='javascript:changeChart(1," + i.ToString() + ", \"" + symbols[i].ToLower() + "\");'><span id='div5d_" + i.ToString() + "'>5d</span></a> ";
// 3 months
divService.InnerHtml += "<a style='font-family: Arial, Helvetica, sans-serif; font-size: 14px; color: Blue;' href='javascript:changeChart(2," + i.ToString() + ", \"" + symbols[i].ToLower() + "\");'><span id='div3m_" + i.ToString() + "'>3m</span></a> ";
// 6 months
divService.InnerHtml += "<a style='font-family: Arial, Helvetica, sans-serif; font-size: 14px; color: Blue;' href='javascript:changeChart(3," + i.ToString() + ", \"" + symbols[i].ToLower() + "\");'><span id='div6m_" + i.ToString() + "'>6m</span></a> ";
// 1 yeas
divService.InnerHtml += "<a style='font-family: Arial, Helvetica, sans-serif; font-size: 14px; color: Blue;' href='javascript:changeChart(4," + i.ToString() + ", \"" + symbols[i].ToLower() + "\");'><span id='div1y_" + i.ToString() + "'>1y</span></a> ";
// 2 years
divService.InnerHtml += "<a style='font-family: Arial, Helvetica, sans-serif; font-size: 14px; color: Blue;' href='javascript:changeChart(5," + i.ToString() + ", \"" + symbols[i].ToLower() + "\");'><span id='div2y_" + i.ToString() + "'>2y</span></a> ";
// 5 years
divService.InnerHtml += "<a style='font-family: Arial, Helvetica, sans-serif; font-size: 14px; color: Blue;' href='javascript:changeChart(6," + i.ToString() + ", \"" + symbols[i].ToLower() + "\");'><span id='div5y_" + i.ToString() + "'>5y</span></a> ";
// Max
divService.InnerHtml += "<a style='font-family: Arial, Helvetica, sans-serif; font-size: 14px; color: Blue;' href='javascript:changeChart(7," + i.ToString() + ", \"" + symbols[i].ToLower() + "\");'><span id='divMax_" + i.ToString() + "'>Max</span></a><br><br /><br /> ";
}
}
}
catch
{
// Handle exceptions
}
}
}
}
/// <summary>
/// Loads an HTML document from an Internet resource and saves it to the specified XmlTextWriter, after an XSLT transformation.
/// </summary>
/// <param name="htmlUrl">The requested URL, such as "http://Myserver/Mypath/Myfile.asp". May not be null.</param>
/// <param name="xsltUrl">The URL that specifies the XSLT stylesheet to load.</param>
/// <param name="xsltArgs">An XsltArgumentList containing the namespace-qualified arguments used as input to the transform.</param>
/// <param name="writer">The XmlTextWriter to which you want to save.</param>
/// <param name="xmlPath">A file path where the temporary XML before transformation will be saved. Mostly used for debugging purposes.</param>
public void LoadHtmlAsXml(string htmlUrl, string xsltUrl, XsltArgumentList xsltArgs, XmlTextWriter writer,
string xmlPath)
{
if (htmlUrl == null)
{
throw new ArgumentNullException("htmlUrl");
}
HtmlDocument doc = Load(htmlUrl);
if (xmlPath != null)
{
XmlTextWriter w = new XmlTextWriter(xmlPath, doc.Encoding);
doc.Save(w);
w.Close();
}
if (xsltArgs == null)
{
xsltArgs = new XsltArgumentList();
}
// add some useful variables to the xslt doc
xsltArgs.AddParam("url", "", htmlUrl);
xsltArgs.AddParam("requestDuration", "", RequestDuration);
xsltArgs.AddParam("fromCache", "", FromCache);
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load(xsltUrl);
xslt.Transform(doc, xsltArgs, writer);
}
/// <summary>Performs code generation</summary>
/// <param name="inputFileName">Name of file to convert</param>
/// <param name="inputFileContent">Content of file to convert</param>
/// <returns>File converted</returns>
/// <version version="1.5.4">Script and document() function are now enabled in XSL transformations.</version>
/// <version version="1.5.4">One more parameter is passed to XSL Template - <c>language</c>.</version>
public override string DoGenerateCode(string inputFileName, string inputFileContent)
{
string transformerFileName = Tools.ResourcesT.TransforCodeGeneratorResources.NOTFOUND;
StringWriter outputWriter = new StringWriter();
try {
FileInfo inputFileInfo = new FileInfo(inputFileName);
// get the source document
XmlDocument sourceDocument = new XmlDocument();
sourceDocument.LoadXml(inputFileContent);
// get the filename of the transformer
var transformerPIs = sourceDocument.SelectNodes("/processing-instruction('transformer')");
if (transformerPIs.Count > 0)
{
transformerFileName = transformerPIs[0].Value;
}
if (!File.Exists(transformerFileName) && !System.IO.Path.IsPathRooted(transformerFileName))
{
// try in the same dir as the file
transformerFileName = Path.Combine(inputFileInfo.DirectoryName, transformerFileName);
if (!File.Exists(transformerFileName))
{
// try in the dir where this dll lives
FileInfo assemblyFileInfo = new FileInfo(Assembly.GetExecutingAssembly().Location);
transformerFileName = Path.Combine(assemblyFileInfo.DirectoryName, transformerFileName);
}
}
// get the xslt document
XPathDocument transformerDoc = new XPathDocument(transformerFileName);
// create the transform
XslCompiledTransform xslTransform = new XslCompiledTransform();
var settings = new XsltSettings(true, true);
xslTransform.Load(transformerDoc.CreateNavigator(), settings, null);
FileInfo fi = new FileInfo(inputFileName);
XsltArgumentList args = new XsltArgumentList();
AssemblyName assemblyName = Assembly.GetExecutingAssembly().GetName();
args.AddParam("generator", String.Empty, assemblyName.FullName);
args.AddParam("version", String.Empty, assemblyName.Version.ToString());
args.AddParam("fullfilename", String.Empty, inputFileName);
args.AddParam("filename", String.Empty, fi.Name);
args.AddParam("date-created", String.Empty, DateTime.Today.ToLongDateString());
args.AddParam("created-by", String.Empty, String.Format("{0}\\{1}", Environment.UserDomainName, Environment.UserName));
args.AddParam("namespace", String.Empty, FileNamespace);
args.AddParam("classname", String.Empty, fi.Name.Substring(0, fi.Name.LastIndexOf(".")));
args.AddParam("language", string.Empty, CodeProvider.FileExtension);
// do the transform
xslTransform.Transform(sourceDocument, args, outputWriter);
XDocument result = XDocument.Parse(outputWriter.ToString());
Tools.CodeDomT.Xml2CodeDom x2d = new Tools.CodeDomT.Xml2CodeDom();
outputWriter = new StringWriter();
base.CodeProvider.GenerateCodeFromCompileUnit(x2d.Xml2CompileUnit(result), outputWriter, new System.CodeDom.Compiler.CodeGeneratorOptions());
} catch (Exception ex) {
string bCommentStart;
string bCommentEnd;
string lCommentStart;
if (this.GetDefaultExtension().ToLower() == ".vb")
{
bCommentStart = "'";
bCommentEnd = "'";
lCommentStart = "'";
}
else
{
bCommentStart = "/*";
bCommentEnd = "*/";
lCommentStart = "";
}
outputWriter.WriteLine(bCommentStart);
outputWriter.WriteLine(lCommentStart + "\t" + Tools.ResourcesT.TransforCodeGeneratorResources.ERRORUnableToGenerateOutputForTemplate);
outputWriter.WriteLine(lCommentStart + "\t'{0}'", inputFileName);
outputWriter.WriteLine(lCommentStart + "\t" + Tools.ResourcesT.TransforCodeGeneratorResources.UsingTransformer);
outputWriter.WriteLine(lCommentStart + "\t'{0}'", transformerFileName);
outputWriter.WriteLine(lCommentStart + "");
outputWriter.WriteLine(lCommentStart + ex.ToString());
outputWriter.WriteLine(bCommentEnd);
}
return(outputWriter.ToString());
}
static int Main(string[] args)
{
var cl = CommandLine.Parse(args);
if (cl == null)
{
return(-1);
}
/*
*
*/
string assemblyPath = Path.Combine(Environment.CurrentDirectory, cl.Assembly);
if (File.Exists(assemblyPath) == false)
{
Konsole.Fatal("ERR: File '{0}' not found.", cl.Assembly);
return(1);
}
/*
*
*/
AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.AssemblyResolve += new ResolveEventHandler((sender, eventArgs) =>
{
string folderPath = Path.GetDirectoryName(assemblyPath);
string depPath = Path.Combine(folderPath, new AssemblyName(eventArgs.Name).Name + ".dll");
if (File.Exists(depPath) == false)
{
return(null);
}
Konsole.Debug("need: '{0}'", depPath);
return(Assembly.LoadFrom(depPath));
});
/*
*
*/
Konsole.Debug("load: '{0}'", assemblyPath);
Assembly assembly;
try
{
assembly = Assembly.LoadFile(assemblyPath);
}
catch (FileLoadException ex)
{
Konsole.Fatal(ex, "ERR: Could not load assembly '{0}'.", assemblyPath);
return(2);
}
catch (BadImageFormatException ex)
{
Konsole.Fatal(ex, "ERR: Could not load assembly '{0}'.", assemblyPath);
return(3);
}
/*
*
*/
XmlDocument doc = new XmlDocument();
var module = doc
.AddElement("module")
.AddAttribute("name", cl.Application);
/*
*
*/
var controllers = assembly.GetExportedTypes().Where(type => typeof(ApiController).IsAssignableFrom(type));
List <Type> types = new List <Type>();
foreach (var c in controllers)
{
var service = module
.AddElement("service")
.AddAttribute("name", c.Name.Substring(0, c.Name.Length - "Controller".Length))
.AddAttribute("ref", ToReference(c));
foreach (var m in c.GetMethods(BindingFlags.Public | BindingFlags.Instance))
{
var post = m.GetCustomAttribute <HttpPostAttribute>();
if (post == null)
{
continue;
}
var method = service
.AddElement("method")
.AddAttribute("name", m.Name);
Type requestType = m.GetParameters()[0].ParameterType;
Type responseType = m.ReturnType.GetGenericArguments()[0];
var request = method.AddElement("request").AddAttribute("ref", ToReference(requestType));
EmitTypeDefinition(request, requestType);
WalkTypes(types, requestType);
var response = method.AddElement("response").AddAttribute("ref", ToReference(responseType));
EmitTypeDefinition(response, responseType);
WalkTypes(types, responseType);
}
}
/*
* Emit all of the used types.
*/
var typesDef = module.AddElement("types");
foreach (var t in types)
{
var xml = t.GetCustomAttribute <XmlTypeAttribute>();
if (xml == null)
{
Console.WriteLine("warn: type '{0}' does not have XmlType attribute.", t.FullName);
}
if (t.IsEnum == true)
{
var enumDef = typesDef.AddElement("enumeration")
.AddAttribute("name", t.Name)
.AddAttribute("ref", ToReference(t));
if (xml != null)
{
enumDef.AddAttribute("ns", xml.Namespace);
}
foreach (string n in t.GetEnumNames())
{
enumDef.AddElement("enum").AddAttribute("value", n);
}
}
else
{
var typeDef = typesDef.AddElement("type")
.AddAttribute("name", t.Name)
.AddAttribute("ref", ToReference(t));
if (xml != null)
{
typeDef.AddAttribute("ns", xml.Namespace);
}
EmitTypeDefinition(typeDef, t);
}
}
/*
* Add documentation
*/
Dictionary <string, XmlDocument> xmldocs = new Dictionary <string, XmlDocument>();
foreach (XmlElement elem in doc.SelectNodes(" //*[ @ref ] "))
{
string[] tref = elem.Attributes["ref"].Value.Split(',');
XmlDocument xmldoc = LoadDocumentation(xmldocs, Path.GetDirectoryName(assemblyPath), tref[1]);
if (xmldoc == null)
{
continue;
}
if (elem.LocalName == "service")
{
foreach (XmlElement method in elem.SelectNodes(" method "))
{
var memberName = "M:" + tref[0] + "." + method.Attributes["name"].Value;
var summaryNode = xmldoc.SelectSingleNode($" /doc/members/member[ starts-with( @name, '{ memberName }' ) ]/summary ");
if (summaryNode != null)
{
string summary = summaryNode.InnerText.Trim();
if (summary.Length > 0)
{
method.AddElement("summary").InnerText = summary;
}
}
}
}
if (elem.LocalName == "request" || elem.LocalName == "response" || elem.LocalName == "type")
{
foreach (XmlElement property in elem.SelectNodes(" p "))
{
string memberName = "P:" + tref[0] + "." + property.Attributes["name"].Value;
var summaryNode = xmldoc.SelectSingleNode($" /doc/members/member[ starts-with( @name, '{ memberName }' ) ]/summary ");
if (summaryNode != null)
{
string summary = summaryNode.InnerText.Trim();
if (summary.Length > 0)
{
property.AddElement("summary").InnerText = summary;
}
}
}
}
}
// doc.Save( Console.Out );
/*
*
*/
XslCompiledTransform xslt = new XslCompiledTransform();
using (StringReader sr = new StringReader(Resources.ToClient))
{
using (XmlReader xr = XmlReader.Create(sr))
{
xslt.Load(xr);
}
}
/*
*
*/
string output = Path.Combine(Environment.CurrentDirectory, cl.Output);
Konsole.Info("Generating {0}...", output);
using (TextWriter xw = new StreamWriter(output, false, Encoding.UTF8))
{
XsltArgumentList xargs = new XsltArgumentList();
xargs.AddParam("Namespace", "", cl.Namespace);
xargs.AddParam("Async", "", cl.Async);
xargs.AddParam("Sync", "", cl.Sync);
xargs.AddExtensionObject("urn:eo-util", new XsltExtensionObject());
try
{
xslt.Transform(doc, xargs, xw);
}
catch (Exception ex)
{
Konsole.Fatal(ex);
}
}
return(0);
}
private void Button1_Click(object sender, EventArgs e)
{
try
{
if (text_box_text_change == false)
{
MessageBox.Show("Ustaw datę!", "Raport Maker V2");
return;
}
XmlDocument doc = new XmlDocument();
doc.Load(@"config_raport_maker.xml");
XmlNodeList xml_zaiks = doc.GetElementsByTagName("zaiks");
for (int i = 0; i < xml_zaiks.Count; i++)
{
XmlNode xml_dest_folder_zaiks = xml_zaiks[i].SelectSingleNode("destination_folder");
XmlNode xml_dest_folder_ekstra_zaiks = xml_zaiks[i].SelectSingleNode("destination_folder_ekstra");
XmlNode xml_get_folder_zaiks = xml_zaiks[i].SelectSingleNode("get_folder_szczecin");
XmlNode xml_get_folder_x_zaiks = xml_zaiks[i].SelectSingleNode("get_folder_x");
destination_folder_zaiks = xml_dest_folder_zaiks.InnerText;
destination_folder_ekstra_zaiks = xml_dest_folder_ekstra_zaiks.InnerText;
get_folder_szczecin_zaiks = xml_get_folder_zaiks.InnerText;
get_folder_szn_ekstra_zaiks = xml_get_folder_x_zaiks.InnerText;
}
XmlNodeList xml_stoart = doc.GetElementsByTagName("stoart");
for (int i = 0; i < xml_stoart.Count; i++)
{
XmlNode xml_dest_folder_stoart = xml_stoart[i].SelectSingleNode("destination_folder");
XmlNode xml_dest_folder_ekstra_stoart = xml_stoart[i].SelectSingleNode("destination_folder_ekstra");
XmlNode xml_get_folder_stoart = xml_stoart[i].SelectSingleNode("get_folder_szczecin");
XmlNode xml_get_folder_x_stoart = xml_stoart[i].SelectSingleNode("get_folder_x");
destination_folder_stoart = xml_dest_folder_stoart.InnerText;
destination_folder_ekstra_stoart = xml_dest_folder_ekstra_stoart.InnerText;
get_folder_szczecin_stoart = xml_get_folder_stoart.InnerText;
get_folder_szn_ekstra_stoart = xml_get_folder_x_stoart.InnerText;
}
miesiac = dateTimePicker1.Value.Month.ToString();
rok = dateTimePicker1.Value.Year.ToString();
Radiocheck_ktory_folder();
Radiocheck();
if (error == true)
{
return;
}
List <string> array3 = new List <string>();
List <string> array4 = new List <string>();
czynadpisac = false;
int z = 0;
progressBar1.Value = 0;
progressBar1.Step = 1;
progressBar1.Minimum = 0;
progressBar1.Maximum = array2.Count;
if (File.Exists(fname))
{
DialogResult dr = MessageBox.Show("Raport już istnieje\nCzy chcesz go nadpisać?", "Raport Maker V2", MessageBoxButtons.YesNo);
switch (dr)
{
case DialogResult.Yes:
FileInfo fff = new FileInfo(fname);
fff.Delete();
czynadpisac = true;
break;
case DialogResult.No:
czynadpisac = false;
return;
}
}
else if (!File.Exists(fname))
{
czynadpisac = true;
}
if (czynadpisac == true)
{
foreach (string file in array2)
{
XslCompiledTransform xslt2 = new XslCompiledTransform();
xslt2.Load(f_xslt);
string path = Path.GetFileNameWithoutExtension(file);
string f_out2 = @"raport_maker_help\" + path + "_" + z + ".txt";
xslt2.Transform(file, f_out2);
z++;
progressBar1.PerformStep();
progressBar1.Refresh();
}
string[] array = Directory.GetFiles(@"raport_maker_help\", "*.txt", SearchOption.AllDirectories);
foreach (string file in array)
{
string[] lines = File.ReadAllLines(file);
for (int i = 0; i < lines.Length; i++)
{
array3.Add(lines[i]);
}
}
array3.Sort();
array4.Add("Data|Godz.aud.|Tytul audycji|Tytul utworu|Kompozytor|Autor tekstu|Tlumacz|Czas|Wykonawca|Producent|Wydawca|");
foreach (string s in array3)
{
StringBuilder ss = new StringBuilder(s);
ss.Remove(17, 6);
array4.Add(ss.ToString());
//array4.Add(s);
}
File.WriteAllLines(fname, array4, Encoding.UTF8);
string dsa = @"raport_maker_help\";
DirectoryInfo di = new DirectoryInfo(dsa);
array2.Clear();
array3.Clear();
array4.Clear();
foreach (FileInfo file in di.GetFiles())
{
file.Delete();
}
}
else
{
MessageBox.Show("Wybierz folder do zapisu!", "Raport Maker V2");
return;
}
progressBar1.Value = 0;
FileInfo f1 = new FileInfo(fname);
MessageBox.Show("Zakończono. Plik \n\n" + f1.Name + "\n\nzostał zapisany.", "Raport Maker V2");
}
catch (Exception ex)
{
MessageBox.Show("Błąd: " + ex);
FileInfo ffff = new FileInfo(fname);
ffff.Delete();
array2.Clear();
}
}
/// <summary>
/// Loads the RDF Dataset from the TriX input using a RDF Handler
/// </summary>
/// <param name="handler">RDF Handler to use</param>
/// <param name="parameters">Parameters indicating the input to read from</param>
public void Load(IRdfHandler handler, IStoreParams parameters)
{
if (handler == null)
{
throw new ArgumentNullException("handler", "Cannot parse an RDF Dataset using a null RDF Handler");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters", "Cannot parse an RDF Dataset using null Parameters");
}
//Try and get the Input from the parameters
TextReader input = null;
if (parameters is StreamParams)
{
//Get Input Stream
input = ((StreamParams)parameters).StreamReader;
//Issue a Warning if the Encoding of the Stream is not UTF-8
if (!((StreamReader)input).CurrentEncoding.Equals(Encoding.UTF8))
{
this.RaiseWarning("Expected Input Stream to be encoded as UTF-8 but got a Stream encoded as " + ((StreamReader)input).CurrentEncoding.EncodingName + " - Please be aware that parsing errors may occur as a result");
}
}
else if (parameters is TextReaderParams)
{
input = ((TextReaderParams)parameters).TextReader;
}
if (input != null)
{
//First try and load as XML and apply any stylesheets
try
{
XmlDocument doc = new XmlDocument();
doc.Load(input);
input.Close();
XmlDocument inputDoc = new XmlDocument();
bool inputReady = false;
//If XSL isn't supported we can't apply it
#if !NO_XSL
//Try and apply any stylesheets (which are used to extend TriX) to get basic TriX syntax
foreach (XmlNode child in doc.ChildNodes)
{
if (child.NodeType == XmlNodeType.ProcessingInstruction)
{
if (child.Name == "xml-stylesheet")
{
//Load in the XML a 2nd time so we can transform it properly if needed
if (!inputReady)
{
inputDoc.LoadXml(doc.OuterXml);
inputReady = true;
}
Regex getStylesheetURI = new Regex("href=\"([^\"]+)\"");
String stylesheetUri = getStylesheetURI.Match(child.Value).Groups[1].Value;
//Load the Transform
XslCompiledTransform transform = new XslCompiledTransform();
XsltSettings settings = new XsltSettings();
transform.Load(stylesheetUri, settings, null);
//Apply the Transform
MemoryStream temp = new MemoryStream();
transform.Transform(inputDoc, XmlWriter.Create(temp));
temp.Flush();
temp.Seek(0, SeekOrigin.Begin);
inputDoc.Load(temp);
}
}
}
#endif
//Start parsing
if (!inputReady)
{
inputDoc = doc;
}
this.TryParseGraphset(inputDoc, handler);
input.Close();
}
catch (XmlException xmlEx)
{
try
{
input.Close();
}
catch
{
//No catch actions - just cleaning up
}
//Wrap in a RDF Parse Exception
throw new RdfParseException("Unable to Parse this TriX since System.Xml was unable to parse the document into a DOM Tree, see the inner exception for details", xmlEx);
}
catch
{
try
{
input.Close();
}
catch
{
//No catch actions - just cleaning up
}
throw;
}
}
else
{
throw new RdfStorageException("Parameters for the TriXParser must be of the type StreamParams/TextReaderParams");
}
}
private void StartTransform()
{
try
{
while (true)
{
var xmlReader = _defaulDocument.Source as XmlReader;
if (xmlReader != null)
{
XslCompiledTransform.Transform(xmlReader, _args, _writer, _defaulDocument.Resolver);
break;
}
var nav = _defaulDocument.Source as IXPathNavigable;
if (nav != null)
{
XslCompiledTransform.Transform(nav, _args, _writer);
break;
}
var str = _defaulDocument.Source as string;
if (str != null)
{
using (var reader = Create(str, ReaderSettings))
{
XslCompiledTransform.Transform(reader, _args, _writer, _defaulDocument.Resolver);
}
break;
}
var strm = _defaulDocument.Source as Stream;
if (strm != null)
{
using (var reader = Create(strm, ReaderSettings))
{
XslCompiledTransform.Transform(reader, _args, _writer, _defaulDocument.Resolver);
}
break;
}
var txtReader = _defaulDocument.Source as TextReader;
if (txtReader != null)
{
using (var reader = Create(txtReader, ReaderSettings))
{
XslCompiledTransform.Transform(reader, _args, _writer, _defaulDocument.Resolver);
}
break;
}
throw new Exception("Unexpected XmlInput");
}
_writer.Close();
}
catch (Exception e)
{
if (_multiThread)
{
// we need this exception on main thread. So pass it through pipe.
_pipe.WriteException(e);
}
else
{
throw;
}
}
}
public string Transform(string message, string version)
{
// XSLT Transformation can be either performed by the internal XSLT 1.0 processor
// or via the SAXON processor, which supports XSLT 3.0
logger.Info("Performing XSLT transform before sending to " + this.queueName);
if (version == "1.0")
{
//Use the in built XSL 1.0 MS Processor
logger.Info("Performing XSLT transform using XSL 1.0 Processor");
try {
foreach (string sheet in styleSheets)
{
FileInfo xslt = new FileInfo(sheet);
XmlDocument doc = new XmlDocument();
doc.LoadXml(message);
XDocument newTree = new XDocument();
using (XmlWriter writer = newTree.CreateWriter()) {
// Load the style sheet.
XslCompiledTransform xs = new XslCompiledTransform();
xs.Load(sheet);
// Execute the transform and output the results to a writer.
xs.Transform(doc, writer);
}
message = newTree.ToString();
}
}
catch (Exception ex) {
logger.Error("XSL 1.0 Transformation Error");
logger.Error(ex.Message);
return(null);
}
logger.Info("XSLT transform using 1.0 Processor Complete");
return(message);
}
else
{
//Use the SAXON 2.0/3.0 Processor (not as fast)
logger.Info("Performing XSLT transform using Saxon XSL 3.0 Processor");
try {
foreach (string sheet in styleSheets)
{
FileStream stream = File.Open(new FileInfo(sheet).ToString(), FileMode.Open);
XmlDocument doc = new XmlDocument();
doc.LoadXml(message);
Processor processor = new Processor();
XdmNode input = processor.NewDocumentBuilder().Build(doc);
Xslt30Transformer transformer = processor.NewXsltCompiler().Compile(stream).Load30();
Serializer serializer = processor.NewSerializer();
StringWriter strWriter = new StringWriter();
serializer.SetOutputWriter(strWriter);
// Transform the source XML and serialize the result document
transformer.ApplyTemplates(input, serializer);
message = strWriter.ToString();
}
logger.Info("XSLT transform using 3.0 Processor Complete");
return(message);
}
catch (Exception ex) {
logger.Error("XSL 3.0 Transformation Error");
logger.Error(ex.Message);
return(null);
}
}
}
/// <summary> Use the native .NET library to transform a source XML file with the XSLT file and return the string </summary>
/// <param name="SourceFile"> Source XML file, to be transformed </param>
/// <param name="XSLT_File"> XSLT file to perform the transform </param>
/// <returns> XSLT return arguments including a flag for success, and possibly an exception </returns>
public static XSLT_Transformer_ReturnArgs Native_Transform(string SourceFile, string XSLT_File)
{
// Keep track of the start time
DateTime starTime = DateTime.Now;
// Create the return object
XSLT_Transformer_ReturnArgs returnArgs = new XSLT_Transformer_ReturnArgs();
returnArgs.Engine = XSLT_Transformer_Engine_Enum.Native_dotNet;
// Ensure the XSLT file exists
if (!File.Exists(XSLT_File))
{
returnArgs.Successful = false;
returnArgs.ErrorMessage = "Indicated XSLT file ( " + XSLT_File + " ) does not exist.";
return(returnArgs);
}
// Ensure the source file exists
if (!File.Exists(SourceFile))
{
returnArgs.Successful = false;
returnArgs.ErrorMessage = "Indicated source file ( " + SourceFile + " ) does not exist.";
return(returnArgs);
}
try
{
// Create the XsltSettings object with script enabled.
XsltSettings xslt_settings = new XsltSettings(true, true);
// Create the transform and load the XSL indicated
XslCompiledTransform transform = new XslCompiledTransform();
transform.Load(XSLT_File, xslt_settings, new XmlUrlResolver());
// Apply the transform to convert the XML into HTML
StringWriter results = new StringWriter();
XmlReaderSettings settings = new XmlReaderSettings
{
DtdProcessing = DtdProcessing.Parse
};
using (XmlReader transformreader = XmlReader.Create(SourceFile, settings))
{
transform.Transform(transformreader, null, results);
}
// Write the transformed string
returnArgs.TransformedString = results.ToString();
returnArgs.Successful = true;
}
catch (Exception ee)
{
returnArgs.Successful = false;
returnArgs.ErrorMessage = ee.Message;
returnArgs.InnerException = ee;
}
// Determine the elapsed time, in milliseconds
returnArgs.Milliseconds = DateTime.Now.Subtract(starTime).TotalMilliseconds;
return(returnArgs);
}
/// <summary>
/// Performs the customization.
/// </summary>
protected override void ExecuteTask()
{
if (-1 == _buildNumber)
{
Log(Level.Info, "No customization performed.");
return;
}
#region transform
Log(Level.Verbose, "Loading stylesheet...");
var transform = new XslCompiledTransform();
using (var stream = AssemblyExtensions.OpenScopedResourceStream <CustomizeAssemblyTask>("CustomInfo_cs.xsl"))
{
using (var reader = XmlReader.Create(stream))
{
transform.Load(reader);
}
}
#endregion
#region Version
if (null == Version)
{
if (null == VersionFile)
{
VersionFile = new FileInfo(Path.Combine(BaseDirectory.FullName, "Version.xml"));
}
Log(Level.Verbose, "Loading VersionFile = {0}...", VersionFile.FullName);
using (var stream = VersionFile.Open(FileMode.Open, FileAccess.Read, FileShare.Read))
{
var doc = new XmlDocument();
doc.Load(stream);
Version = doc;
}
}
#endregion
#region arguments
var arguments = new XsltArgumentList();
Action <string, object> addParam = (name, value) =>
{
if (value != null)
{
Log(Level.Verbose, "Adding param {0} = {1}", name, value);
arguments.AddParam(name, String.Empty, value);
}
};
addParam("buildNumber", _buildNumber);
addParam("registeredUserDisplayName", _registeredUserDisplayName);
addParam("registeredUserEmailAddress", _registeredUserEmailAddress);
#endregion
foreach (string project in EnumerateProjectNames())
{
Log(Level.Info, "Customizing {0}...", project);
var projectDir = Path.Combine(BaseDirectory.FullName, project);
var outputFile = Path.Combine(projectDir, "Properties/CustomInfo.cs");
if (File.Exists(outputFile))
{
Log(Level.Verbose, "Deleting {0}...", outputFile);
File.Delete(outputFile);
}
Log(Level.Verbose, "Generating {0}...", outputFile);
using (var stream = File.Open(outputFile, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.Read))
{
transform.Transform(Version, arguments, stream);
}
}
}
protected void BtnSaveToExcel(object sender, EventArgs e)
{
string json = ExcelGridData.Value.ToString();
json = json.Replace("d_name", "店铺");
json = json.Replace("name4", "虚拟结构");
json = json.Replace("name5", "虚拟结构");
json = json.Replace("styleid", "款号");
json = json.Replace("colorid", "颜色");
json = json.Replace("s2s", "2");
json = json.Replace("s3s", "3");
json = json.Replace("s4s", "4");
json = json.Replace("s5s", "5");
json = json.Replace("s6s", "6");
json = json.Replace("total", "合计");
StoreSubmitDataEventArgs eSubmit = new StoreSubmitDataEventArgs(json, null);
XmlNode xml = eSubmit.Xml;
this.Response.Clear();
this.Response.ContentType = "application/vnd.ms-excel";
this.Response.AddHeader("Content-Disposition", "attachment; filename=Report.xls");
XslCompiledTransform xtExcel = new XslCompiledTransform();
xtExcel.Load(Server.MapPath("ExcelTemp/Excel.xsl"));
xtExcel.Transform(xml, null, this.Response.OutputStream);
this.Response.End();
}
public void CreateElementsAndAttributesUsingXsltInline(object param0, object param1)
{
int numOfRepeat = 300; // from the test case
bool isValidChar = (bool)param0;
CharType charType = (CharType)param1;
var startChars = new CharType[] { CharType.NameStartChar, CharType.NameStartSurrogateHighChar, CharType.NameStartSurrogateLowChar };
string charsToChooseFrom = isValidChar ? UnicodeCharHelper.GetValidCharacters(charType) : UnicodeCharHelper.GetInvalidCharacters(charType);
Assert.True(charsToChooseFrom.Length > 0);
foreach (bool enableDebug in new bool[] { /*true,*/ false }) // XSLT debugging not supported in Core
{
foreach (string name in FuzzNames(!isValidChar, charType, numOfRepeat))
{
XslCompiledTransform transf = new XslCompiledTransform(enableDebug);
try
{
using (XmlReader r = XmlReader.Create(new StringReader(String.Format(createElementsXsltInline, name)))) transf.Load(r);
Assert.True(isValidChar);
}
catch (Exception)
{
if (isValidChar)
{
throw;
}
else
{
continue; //exception expected -> continue
}
}
// if loading of the stylesheet passed, then we should be able to provide
StringBuilder sb = new StringBuilder();
using (XmlReader r = XmlReader.Create(new StringReader("<root/>"))) transf.Transform(r, null, new StringWriter(sb));
// TODO: verification for valid case
}
}
return;
}
static void Main(string[] args)
{
Options options = null;
try
{
// Get the args.
options = OptionsFactory.GetOptions(args);
}
catch (Exception)
{
Console.WriteLine("An error occured.");
Console.WriteLine("Usage :");
OptionsFactory.cmdParser.HelpOption.ShowHelp(OptionsFactory.cmdParser.Options);
throw;
}
// Read input file.
Console.WriteLine("Reading file {0}", options.Input);
XDocument input = XDocument.Load(options.Input);
if (options.IsVerbose)
{
Console.Write(input.ToString());
}
// Validate input file if requested
if (options.Xsd != null)
{
Console.WriteLine("Validating file with {0}", options.Xsd);
XDocument xsd = XDocument.Load(options.Xsd);
if (options.IsVerbose)
{
Console.Write(xsd.ToString());
}
XmlSchemaSet xsdSchemas = new XmlSchemaSet();
bool hasErrors = false;
xsdSchemas.Add(string.Empty, XmlReader.Create(new StringReader(xsd.ToString())));
input.Validate(xsdSchemas, (o, e) => { Console.WriteLine("Errors validating XML : {0}", e.Message); hasErrors = true; });
if (hasErrors)
{
Console.WriteLine("Exiting");
Environment.Exit(0);
}
}
Console.WriteLine("Transforming file with {0}", options.Xslt);
XDocument xslt = XDocument.Load(options.Xslt);
if (options.IsVerbose)
{
Console.Write(xslt.ToString());
}
XDocument output = new XDocument();
using (XmlWriter writer = output.CreateWriter())
{
// Load the style sheet.
XslCompiledTransform xsltCompiled = new XslCompiledTransform();
xsltCompiled.Load(XmlReader.Create(new StringReader(xslt.ToString())));
// Execute the transform and output the results to a writer.
xsltCompiled.Transform(output.CreateReader(), writer);
}
Console.WriteLine("Output of the transformation to {0}", options.Output);
Console.Write(output.ToString());
if (options.IsVerbose)
{
output.Save(options.Output);
}
Console.WriteLine("Exiting");
}
private static String ParseResponse(string response)
{
XmlDocument doc = null;
XslCompiledTransform myXslTransform = null;
TextWriter sw = null;
string result;
try
{
doc = new XmlDocument(); ;
myXslTransform = new XslCompiledTransform();
sw = new StringWriter();
doc.LoadXml(response);
myXslTransform.Load(new XmlTextReader(new StringReader(Resources.Resource.xml2json)));
JavaScriptSerializer serializer = new JavaScriptSerializer();
myXslTransform.Transform(doc, null, sw);
result = sw.ToString();
}
catch
{
result = System.Web.Configuration.WebConfigurationManager.AppSettings["errorParsingOrLoading"];
logger.Error(result);
}
finally
{
sw.Close();
}
return result;
}
public static void ConverXmlToHtml()
{
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load(@"..\..\..\XML_export\test.xsl");
xslt.Transform(@"..\..\..\XML_export\test.xml", @"..\..\..\XML_export\students.html");
}
public void CreateElementsAndAttributesUsingXsltAndXPath(object param0, object param1)
{
bool isValidChar = (bool)param0;
CharType charType = (CharType)param1;
var startChars = new CharType[] { CharType.NameStartChar, CharType.NameStartSurrogateHighChar, CharType.NameStartSurrogateLowChar };
string charsToChooseFrom = isValidChar ? UnicodeCharHelper.GetValidCharacters(charType) : UnicodeCharHelper.GetInvalidCharacters(charType);
Assert.True(charsToChooseFrom.Length > 0);
foreach (bool enableDebug in new bool[] { /*true,*/ false }) // XSLT debugging not supported in Core
{
XslCompiledTransform transf = new XslCompiledTransform(enableDebug);
using (XmlReader r = XmlReader.Create(new StringReader(createElementsXsltAndXpath))) transf.Load(r);
for (int i = 0; i < charsToChooseFrom.Length; i++)
{
XsltArgumentList arguments = new XsltArgumentList();
arguments.AddParam("mode", "", Array.Exists(startChars, x => x == charType) ? "start" : "middle");
string strToInject = GenerateStringToInject(charsToChooseFrom, i, charType);
if (strToInject[0] == ':')
{
continue;
}
arguments.AddParam("char", "", strToInject);
StringBuilder sb = new StringBuilder();
try
{
using (XmlReader r = XmlReader.Create(new StringReader("<root/>"))) transf.Transform(r, arguments, new StringWriter(sb));
Assert.True(isValidChar);
// TODO: verification for valid case
}
catch (Exception)
{
if (isValidChar)
{
throw;
}
else
{
continue; //exception expected -> continue
}
}
}
}
return;
}
// Function : Export_with_XSLT_Windows
// Arguments : dsExport, sHeaders, sFileds, FormatType, FileName
// Purpose : Exports dataset into CSV / Excel format
private void Export_with_XSLT_Windows(DataSet dsExport, string[] sHeaders, string[] sFileds, ExportFormat FormatType, string FileName)
{
try
{
// XSLT to use for transforming this dataset.
MemoryStream stream = new MemoryStream( );
XmlTextWriter writer = new XmlTextWriter(stream, Encoding.UTF8);
CreateStylesheet(writer, sHeaders, sFileds, FormatType);
writer.Flush( );
stream.Seek( 0, SeekOrigin.Begin);
XmlDocument xsl = new XmlDocument();
xsl.Load(stream);
//XslTransform xslTran = new XslTransform();
//xslTran.Load(new XmlTextReader(stream), null, null);
//System.IO.StringWriter sw = new System.IO.StringWriter();
//xslTran.Transform(xmlDoc, null, sw, null);
XmlDataDocument xmlDoc = new XmlDataDocument(dsExport);
StringWriter sw = new StringWriter();
XmlTextWriter xtw = new XmlTextWriter(sw);
XslCompiledTransform t = new XslCompiledTransform();
t.Load((IXPathNavigable)xsl, null, null);
t.Transform((IXPathNavigable)xmlDoc, xtw);
//Writeout the Content
File.WriteAllText(FileName, sw.ToString());
sw.Close();
xtw.Close();
writer.Close();
stream.Close();
sw.Dispose();
stream.Dispose();
}
catch(Exception Ex)
{
throw Ex;
}
}
/// <summary>
/// Metodo encargado de obtener la cadena original a partir de un flujo de documento XML
/// </summary>
/// <param name="flujoCFD">Flujo que contiene el CFD</param>
/// <param name="archivo_xslt">URI del archivo de transformación</param>
/// <param name="archivo_xslt_alternativo">URI del archivo de transformación a utilizar si el primero no puede ser utilizado</param>
/// <param name="cadena_original">Resultado de transformación de archivo (Cadena Original)</param>
/// <returns></returns>
public static RetornoOperacion CadenaCFD(Stream flujoCFD, string archivo_xslt, string archivo_xslt_alternativo, out string cadena_original)
{
//Declarando variable de retorno e inicializnado parámetro de salida
RetornoOperacion resultado = new RetornoOperacion("Transformación exitosa.", true);
cadena_original = "";
bool enLinea = true;
//Instanciamos un nuevo objecto de compilacion xslt
var xslt = new XslCompiledTransform();
//Intentando generar Cadena Original
try
{
//Cargamos nuestro archivo xslt de la ruta indicada
xslt.Load(archivo_xslt);
}
catch (Exception)
{
//Estableciendo error con la versión en linea
enLinea = false;
try
{
//Cargamos nuestro archivo local .xslt de la ruta indicada
xslt.Load(archivo_xslt_alternativo);
}
catch (Exception e)
{
resultado = new RetornoOperacion(e.Message + "<br/>" + "Error con la transformación local, la cadena original no pudo ser generada.");
}
}
//Si no hay errores hasta este punto
if (resultado.OperacionExitosa)
{
//Intentando generar Cadena Original
try
{
//Instanciamos de manera temporal un flujo de escritura de archivos
using (MemoryStream flujo = new MemoryStream())
{
//Colocando posición sobre primer elemento para evitar lecturas vacias del flujo
flujoCFD.Position = 0;
//Instanciando Navegador
XPathDocument d = new XPathDocument(flujoCFD);
//Aplicamos el estilo
xslt.Transform(d, null, flujo);
//Creamos un flujo de lectura
var s = new StreamReader(flujo);
//Si el flujo de lectura existe
if (s != null)
{
//Posicionando al inicio del flujo
s.BaseStream.Position = 0;
//Estableciendo valor de retorno
cadena_original = s.ReadToEnd();
}
//Cerrando lector de flujo con el archivo temporal
s.Close();
//Si NO se generó conn la versión en linea
if (!enLinea)
{
//Actualizando mensaje de resultado
resultado = new RetornoOperacion("Error con la transformación en linea, se generó la cadena original con una versión local.", true);
}
}
}
//En caso de error
catch (Exception ex)
{
//Registrando error
resultado = new RetornoOperacion(ex.Message);
}
}
//Devolviendo cadena resultante
return(resultado);
}
protected void BtnSaveToExcel(object sender, EventArgs e)
{
string json = ExcelGridData.Value.ToString();
json = json.Replace("retailid", "单据号");
json = json.Replace("setdate", "销售日期");
json = json.Replace("znums", "数量");
json = json.Replace("zxsums", "现价金额");
json = json.Replace("zssums", "结算金额");
json = json.Replace("FCalcSums", "实销金额");
json = json.Replace("yhsum", "优惠金额");
json = json.Replace("s_sums", "实收金额");
json = json.Replace("vipcode", "VIP卡号");
json = json.Replace("s_name", "营业员");
json = json.Replace("x_name", "班组");
json = json.Replace("crdate", "制单日期");
json = json.Replace("cr_name", "制单人");
json = json.Replace("comment", "备注");
StoreSubmitDataEventArgs eSubmit = new StoreSubmitDataEventArgs(json, null);
XmlNode xml = eSubmit.Xml;
this.Response.Clear();
this.Response.ContentType = "application/vnd.ms-excel";
this.Response.AddHeader("Content-Disposition", "attachment; filename=Retail" + DateTime.Now.ToString("yyyyMMddHHmmss") + ".xls");
XslCompiledTransform xtExcel = new XslCompiledTransform();
xtExcel.Load(Server.MapPath("ExcelTemp/Excel.xsl"));
xtExcel.Transform(xml, null, this.Response.OutputStream);
this.Response.End();
}
private string saveXslt(string fileName, string fileContents, bool ignoreDebugging)
{
StreamWriter SW;
string tempFileName = IOHelper.MapPath(SystemDirectories.Xslt + "/" + System.DateTime.Now.Ticks + "_temp.xslt");
SW = File.CreateText(tempFileName);
SW.Write(fileContents);
SW.Close();
// Test the xslt
string errorMessage = "";
if (!ignoreDebugging)
{
try
{
// Check if there's any documents yet
if (content.Instance.XmlContent.SelectNodes("/root/node").Count > 0)
{
XmlDocument macroXML = new XmlDocument();
macroXML.LoadXml("<macro/>");
XslCompiledTransform macroXSLT = new XslCompiledTransform();
page umbPage = new page(content.Instance.XmlContent.SelectSingleNode("//node [@parentID = -1]"));
XsltArgumentList xslArgs;
xslArgs = macro.AddMacroXsltExtensions();
library lib = new library(umbPage);
xslArgs.AddExtensionObject("urn:umbraco.library", lib);
HttpContext.Current.Trace.Write("umbracoMacro", "After adding extensions");
// Add the current node
xslArgs.AddParam("currentPage", "", library.GetXmlNodeById(umbPage.PageID.ToString()));
HttpContext.Current.Trace.Write("umbracoMacro", "Before performing transformation");
// Create reader and load XSL file
// We need to allow custom DTD's, useful for defining an ENTITY
XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.ProhibitDtd = false;
using (XmlReader xmlReader = XmlReader.Create(tempFileName, readerSettings))
{
XmlUrlResolver xslResolver = new XmlUrlResolver();
xslResolver.Credentials = CredentialCache.DefaultCredentials;
macroXSLT.Load(xmlReader, XsltSettings.TrustedXslt, xslResolver);
xmlReader.Close();
// Try to execute the transformation
HtmlTextWriter macroResult = new HtmlTextWriter(new StringWriter());
macroXSLT.Transform(macroXML, xslArgs, macroResult);
macroResult.Close();
}
}
else
{
errorMessage = "stub";
//base.speechBubble(speechBubbleIcon.info, ui.Text("errors", "xsltErrorHeader", base.getUser()), "Unable to validate xslt as no published content nodes exist.");
}
}
catch (Exception errorXslt)
{
//base.speechBubble(speechBubbleIcon.error, ui.Text("errors", "xsltErrorHeader", base.getUser()), ui.Text("errors", "xsltErrorText", base.getUser()));
//errorHolder.Visible = true;
//closeErrorMessage.Visible = true;
//errorHolder.Attributes.Add("style", "height: 250px; overflow: auto; border: 1px solid CCC; padding: 5px;");
errorMessage = (errorXslt.InnerException ?? errorXslt).ToString();
// Full error message
errorMessage = errorMessage.Replace("\n", "<br/>\n");
//closeErrorMessage.Visible = true;
string[] errorLine;
// Find error
MatchCollection m = Regex.Matches(errorMessage, @"\d*[^,],\d[^\)]", RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
foreach (Match mm in m)
{
errorLine = mm.Value.Split(',');
if (errorLine.Length > 0)
{
int theErrorLine = int.Parse(errorLine[0]);
int theErrorChar = int.Parse(errorLine[1]);
errorMessage = "Error in XSLT at line " + errorLine[0] + ", char " + errorLine[1] + "<br/>";
errorMessage += "<span style=\"font-family: courier; font-size: 11px;\">";
string[] xsltText = fileContents.Split("\n".ToCharArray());
for (int i = 0; i < xsltText.Length; i++)
{
if (i >= theErrorLine - 3 && i <= theErrorLine + 1)
{
if (i + 1 == theErrorLine)
{
errorMessage += "<b>" + (i + 1) + ": >>> " + Server.HtmlEncode(xsltText[i].Substring(0, theErrorChar));
errorMessage += "<span style=\"text-decoration: underline; border-bottom: 1px solid red\">" + Server.HtmlEncode(xsltText[i].Substring(theErrorChar, xsltText[i].Length - theErrorChar)).Trim() + "</span>";
errorMessage += " <<<</b><br/>";
}
else
{
errorMessage += (i + 1) + ": " + Server.HtmlEncode(xsltText[i]) + "<br/>";
}
}
}
errorMessage += "</span>";
}
}
}
}
if (errorMessage == "" && fileName.ToLower().EndsWith(".xslt"))
{
//Hardcoded security-check... only allow saving files in xslt directory...
string savePath = IOHelper.MapPath(SystemDirectories.Xslt + "/" + fileName);
if (savePath.StartsWith(IOHelper.MapPath(SystemDirectories.Xslt)))
{
SW = File.CreateText(savePath);
SW.Write(fileContents);
SW.Close();
errorMessage = "true";
}
else
{
errorMessage = "Illegal path";
}
}
System.IO.File.Delete(tempFileName);
return(errorMessage);
}
/// <summary>
/// Apply a map to a xml message
/// </summary>
/// <param name="mapFullName">Map full name (Class, strong name)</param>
/// <param name="messageIn">Xml message to be transformed</param>
/// <returns>The transformed xml document</returns>
public static TransformResults Transform(string mapFullName, XmlDocument messageIn)
{
if (string.IsNullOrWhiteSpace(mapFullName))
{
return(new TransformResults());
}
var msgOut = new XmlDocument();
StringWriter writer = null;
Debug.Write("[Resolver] Transform using the map in " + mapFullName);
// Check parameters
if (messageIn == null)
{
throw new ArgumentNullException("messageIn");
}
if (string.IsNullOrEmpty(mapFullName))
{
throw new ArgumentNullException("mapFullName");
}
// Extract the class name and the strong name from the MapFullName
var className = mapFullName.Split(',')[0];
var pos = mapFullName.IndexOf(',');
if (pos == -1)
{
throw new ArgumentException(string.Format(Resources.ExceptionMapFullName, mapFullName));
}
var strongName = mapFullName.Substring(pos);
strongName = strongName.Trim();
if (strongName.StartsWith(","))
{
strongName = strongName.Substring(1);
}
strongName = strongName.Trim();
TransformResults transformResults;
try
{
// Load the map
var mapAssembly = Assembly.Load(strongName);
var map = mapAssembly.CreateInstance(className);
if (map == null)
{
throw new EsbResolutionException(
string.Format(Resources.ExceptionMapClassInvalid, className));
}
// Extract the xslt
var xmlContentProp = map.GetType().GetProperty("XmlContent");
var xsl = xmlContentProp.GetValue(map, null);
// Extract xsl and extension objects
var xsltArgumentsProp = map.GetType().GetProperty("XsltArgumentListContent");
var xsltArguments = xsltArgumentsProp.GetValue(map, null);
// Extract source schemas
var sourceSchemasProp = map.GetType().GetProperty("SourceSchemas");
var sourceSchemas = (string[])sourceSchemasProp.GetValue(map, null);
// Extract target schemas
var targetSchemasProp = map.GetType().GetProperty("TargetSchemas");
var targetSchemas = (string[])targetSchemasProp.GetValue(map, null);
// Load all the external assemblies
var xmlExtension = new XmlDocument();
var xslArgList = new XsltArgumentList();
if (xsltArguments != null)
{
// Load the argument list and create all the needed instances
xmlExtension.LoadXml(xsltArguments.ToString());
var xmlExtensionNodes = xmlExtension.SelectNodes(Resources.XPathExtensionObject);
if (xmlExtensionNodes != null)
{
foreach (XmlNode extObjNode in xmlExtensionNodes)
{
var extAttributes = extObjNode.Attributes;
if (extAttributes == null)
{
continue;
}
var namespaceNode = extAttributes.GetNamedItem("Namespace");
var assemblyNode = extAttributes.GetNamedItem("AssemblyName");
var classNode = extAttributes.GetNamedItem("ClassName");
var extAssembly = Assembly.Load(assemblyNode.InnerText);
var extObj = extAssembly.CreateInstance(classNode.InnerText);
if (extObj != null)
{
xslArgList.AddExtensionObject(namespaceNode.InnerText, extObj);
}
}
}
}
// Apply xsl to msg in
var xslDoc = new XmlDocument();
xslDoc.LoadXml(xsl.ToString());
var settings = new XsltSettings(true, true);
var xlsTrans = new XslCompiledTransform();
xlsTrans.Load(xslDoc, settings, new XmlUrlResolver());
writer = new StringWriter();
if (messageIn.DocumentElement != null)
{
xlsTrans.Transform(new XmlNodeReader(messageIn.DocumentElement), xslArgList, writer);
}
writer.Flush();
try
{
// Return the msg out
msgOut.LoadXml(writer.ToString());
}
catch (Exception)
{
// Log the error here with useful information! If the map fails (e.g., the wrong
// map is configured in the Service Mediation policy) the Load may fail with an unhelpful
// 'Root not missing' error. We need to log an additional error here that records what
// map was being applied.
var inMessageType = messageIn.DocumentElement == null
? "<source message is empty>"
: string.Format(
"{0}#{1}",
messageIn.DocumentElement.NamespaceURI,
messageIn.DocumentElement.LocalName);
var message = string.Format(
"A transformation failed for map {0} and message of type {1}. Is the correct map configured in the ESB service mediation policy?",
mapFullName,
inMessageType);
EventLog.WriteEntry("Application", message, EventLogEntryType.Error, 3);
throw;
}
transformResults = new TransformResults(messageIn, msgOut, xslDoc, xslArgList, sourceSchemas, targetSchemas, (from schemaName in targetSchemas select SchemaStrongNameCache.GetSchemaStrongName(map.GetType(), schemaName)).ToList());
}
finally
{
if (writer != null)
{
writer.Close();
}
}
return(transformResults);
}
/// <summary>
/// Always use UTF-8 for encoding, else you will screw it up.
/// </summary>
/// <param name="xmlData"></param>
/// <param name="transform"></param>
/// <param name="args"></param>
/// <returns></returns>
private string WriteTransformedXmlDataToString2(string xmlData, XslCompiledTransform transform, XsltArgumentList args)
{
MemoryStream ms = new MemoryStream();
XmlTextReader reader = new XmlTextReader(new StringReader(xmlData));
XmlTextWriter writer = new XmlTextWriter(ms, Encoding.ASCII);
transform.Transform(reader, args, writer);
// Set the position to 0, to read the memory stream.
ms.Position = 0;
StreamReader sr = new StreamReader(ms);
return sr.ReadToEnd();
}
public static RetornoOperacion SellaCadenaOriginal3_3(Stream flujoCFD, string archivo_xslt, string archivo_xslt_alternativo, out string cadena_original)
{
//Declarando Objeto de Retorno
RetornoOperacion result = new RetornoOperacion("Transformación exitosa.", true);
cadena_original = "";
bool enLinea = true;
//Instanciamos un nuevo objecto de compilacion xslt
var xslt = new XslCompiledTransform();
//Intentando generar Cadena Original
try
{
//Cargamos nuestro archivo xslt de la ruta indicada
xslt.Load(archivo_xslt);
}
catch (Exception ex)
{
//Estableciendo error con la versión en linea
enLinea = false;
try
{
//Cargamos nuestro archivo local .xslt de la ruta indicada
xslt.Load(archivo_xslt_alternativo);
}
catch (Exception e)
{
result = new RetornoOperacion(e.Message + "<br/>" + "Error con la transformación local, la cadena original no pudo ser generada.");
}
}
//Validanco Operación Exitosa
if (result.OperacionExitosa)
{
try
{
//Instanciando Navegador
XPathDocument d = new XPathDocument(flujoCFD);
StringWriter stringWrite = new System.IO.StringWriter();
//Transformando a Cadena Original
xslt.Transform(d, null, stringWrite);
//Estableciendo valor de retorno
cadena_original = stringWrite.ToString();
//Terminando Escritura
stringWrite.Close();
}
catch (Exception ex)
{
//Registrando error
result = new RetornoOperacion(ex.Message);
}
//Si NO se generó conn la versión en linea
if (!enLinea)
{
//Actualizando mensaje de resultado
result = new RetornoOperacion("Error con la transformación en linea, se generó la cadena original con una versión local.", true);
}
}
//Devolviendo Resultado Obtenido
return(result);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
// The page is being loaded and accessed for the first time.
// Retrieve user input from the form.
if (Request.QueryString["s"] == null)
{
// Set the default stock symbol to YHOO.
m_symbol = "YHOO";
}
else
{
// Get the user's input.
m_symbol = Request.QueryString["s"].ToString().ToUpper();
}
// Update the textbox value.
txtSymbol.Value = m_symbol;
// This DIV that contains text and DIVs that displays stock quotes and chart from Yahoo.
// Set the innerHTML property to replaces the existing content of the DIV.
divService.InnerHtml = "<br />";
if (m_symbol.Trim() != "")
{
try
{
// Return the stock quote data in XML format.
String arg = GetQuote(m_symbol.Trim());
if (arg == null)
{
return;
}
// Read XML.
// Declare an XmlDocument object to represents an XML document.
XmlDocument xd = new XmlDocument();
// Loads the XML data from a stream.
xd.LoadXml(arg);
// Read XSLT
// Declare an XslCompiledTransform object to transform XML data using an XSLT style sheet.
XslCompiledTransform xslt = new XslCompiledTransform();
// Use the Load method to load the Xsl transform object.
xslt.Load(Server.MapPath("stock.xsl"));
// Transform the XML document into HTML.
StringWriter fs = new StringWriter();
xslt.Transform(xd.CreateNavigator(), null, fs);
string result = fs.ToString();
// Replace the characters ">" and "<" back to "<" and ">".
divService.InnerHtml = "<br />" + result.Replace("<", "<").Replace(">", ">") + "<br />";
// Display stock charts.
String[] symbols = m_symbol.Replace(",", " ").Split(' ');
// Loop through each stock
for (int i = 0; i < symbols.Length; ++i)
{
if (symbols[i].Trim() == "")
{
continue;
}
int index = divService.InnerHtml.ToLower().IndexOf(symbols[i].Trim().ToLower() + " is invalid.");
// If index = -1, the stock symbol is valid.
if (index == -1)
{
// Use a random number to defeat cache.
Random random = new Random();
divService.InnerHtml += "<img id='imgChart_" + i.ToString() + "' src='http://ichart.finance.yahoo.com/b?s=" + symbols[i].Trim().ToUpper() + "& " + random.Next() + "' border=0><br />";
// 1 days
divService.InnerHtml += "<a style='font-family: Arial, Helvetica, sans-serif; font-size: 14px; color: Blue;' href='javascript:changeChart(0," + i.ToString() + ", \"" + symbols[i].ToLower() + "\");'><span id='div1d_" + i.ToString() + "'><b>1d</b></span></a> ";
// 5 days
divService.InnerHtml += "<a style='font-family: Arial, Helvetica, sans-serif; font-size: 14px; color: Blue;' href='javascript:changeChart(1," + i.ToString() + ", \"" + symbols[i].ToLower() + "\");'><span id='div5d_" + i.ToString() + "'>5d</span></a> ";
// 3 months
divService.InnerHtml += "<a style='font-family: Arial, Helvetica, sans-serif; font-size: 14px; color: Blue;' href='javascript:changeChart(2," + i.ToString() + ", \"" + symbols[i].ToLower() + "\");'><span id='div3m_" + i.ToString() + "'>3m</span></a> ";
// 6 months
divService.InnerHtml += "<a style='font-family: Arial, Helvetica, sans-serif; font-size: 14px; color: Blue;' href='javascript:changeChart(3," + i.ToString() + ", \"" + symbols[i].ToLower() + "\");'><span id='div6m_" + i.ToString() + "'>6m</span></a> ";
// 1 yeas
divService.InnerHtml += "<a style='font-family: Arial, Helvetica, sans-serif; font-size: 14px; color: Blue;' href='javascript:changeChart(4," + i.ToString() + ", \"" + symbols[i].ToLower() + "\");'><span id='div1y_" + i.ToString() + "'>1y</span></a> ";
// 2 years
divService.InnerHtml += "<a style='font-family: Arial, Helvetica, sans-serif; font-size: 14px; color: Blue;' href='javascript:changeChart(5," + i.ToString() + ", \"" + symbols[i].ToLower() + "\");'><span id='div2y_" + i.ToString() + "'>2y</span></a> ";
// 5 years
divService.InnerHtml += "<a style='font-family: Arial, Helvetica, sans-serif; font-size: 14px; color: Blue;' href='javascript:changeChart(6," + i.ToString() + ", \"" + symbols[i].ToLower() + "\");'><span id='div5y_" + i.ToString() + "'>5y</span></a> ";
// Max
divService.InnerHtml += "<a style='font-family: Arial, Helvetica, sans-serif; font-size: 14px; color: Blue;' href='javascript:changeChart(7," + i.ToString() + ", \"" + symbols[i].ToLower() + "\");'><span id='divMax_" + i.ToString() + "'>Max</span></a><br><br /><br /> ";
}
}
}
catch
{
// Handle exceptions
}
}
}
}
static void Main(string[] args)
{
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load("../../students.xsl");
xslt.Transform("../../students.xml", "../../students.html");
}
/// <summary>
/// Run the generated XML file through the XSL transformation engine to create the file output.
/// </summary>
private void AsyncGenerateOutput(object sender, DoWorkEventArgs e)
{
_blnQueueOutputGeneratorRun = false;
string strXslPath = Path.Combine(Application.StartupPath, "sheets", _strSelectedSheet + ".xsl");
if (!File.Exists(strXslPath))
{
string strReturn = $"File not found when attempting to load {_strSelectedSheet}{Environment.NewLine}";
Log.Enter(strReturn);
MessageBox.Show(strReturn);
return;
}
#if DEBUG
XslCompiledTransform objXslTransform = new XslCompiledTransform(true);
#else
XslCompiledTransform objXslTransform = new XslCompiledTransform();
#endif
try
{
objXslTransform.Load(strXslPath);
}
catch (Exception ex)
{
string strReturn = $"Error attempting to load {_strSelectedSheet}{Environment.NewLine}";
Log.Enter(strReturn);
Log.Error("ERROR Message = " + ex.Message);
strReturn += ex.Message;
MessageBox.Show(strReturn);
return;
}
if (_workerOutputGenerator.CancellationPending)
{
e.Cancel = true;
return;
}
MemoryStream objStream = new MemoryStream();
XmlTextWriter objWriter = new XmlTextWriter(objStream, Encoding.UTF8);
objXslTransform.Transform(_objCharacterXml, objWriter);
if (_workerOutputGenerator.CancellationPending)
{
e.Cancel = true;
return;
}
objStream.Position = 0;
// This reads from a static file, outputs to an HTML file, then has the browser read from that file. For debugging purposes.
//objXSLTransform.Transform("D:\\temp\\print.xml", "D:\\temp\\output.htm");
//webBrowser1.Navigate("D:\\temp\\output.htm");
if (!GlobalOptions.PrintToFileFirst)
{
// Populate the browser using the DocumentStream.
webBrowser1.DocumentStream = objStream;
}
else
{
// The DocumentStream method fails when using Wine, so we'll instead dump everything out a temporary HTML file, have the WebBrowser load that, then delete the temporary file.
// Read in the resulting code and pass it to the browser.
StreamReader objReader = new StreamReader(objStream, Encoding.UTF8, true);
string strOutput = objReader.ReadToEnd();
File.WriteAllText(_strName, strOutput);
string curDir = Directory.GetCurrentDirectory();
webBrowser1.Url = new Uri(string.Format("file:///{0}/" + _strName, curDir));
}
}
static void Main()
{
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load("../../catalog.xsl");
xslt.Transform("../../catalog.xml", "../../catalog.html");
}
/// <summary>
/// Process Input file with xslt and produce result with same name as input but extension changed.
/// </summary>
/// <param name="inputFile">input file</param>
/// <param name="xsltFile">xslt file name. It is assumed to be in Dictionary Express folder</param>
/// <param name="ext">new extension</param>
/// <param name="myParams">pass a dictionary of parameters and values</param>
/// <returns>results or error message</returns>
private static string XsltProcess(string inputFile, string xsltFile, string ext, Dictionary <string, string> myParams)
{
if (!File.Exists(inputFile))
{
return(string.Empty);
}
if (!File.Exists(xsltFile))
{
return(inputFile);
}
if (string.IsNullOrEmpty(ext))
{
ext = ".xhtml";
}
try
{
string path = GetPSApplicationPath();
string outputPath = Path.GetDirectoryName(inputFile);
string result = PathCombine(outputPath, Path.GetFileNameWithoutExtension(inputFile) + ext);
if (File.Exists(result))
{
File.Delete(result);
}
string xsltPath = PathCombine(path, xsltFile);
if (!File.Exists(xsltPath))
{
xsltPath = Common.PathCombine(Path.GetDirectoryName(Common.AssemblyPath), xsltFile);
}
//Create the XslCompiledTransform and load the stylesheet.
var xsltReader = XmlReader.Create(xsltPath);
XmlNamespaceManager namespaceManager = new XmlNamespaceManager(xsltReader.NameTable);
namespaceManager.AddNamespace("x", "http://www.w3.org/1999/xhtml");
namespaceManager.AddNamespace("fn", "http://www.w3.org/2005/xpath-functions");
var xslt = new XslCompiledTransform();
var xsltTransformSettings = new XsltSettings {
EnableDocumentFunction = true
};
xslt.Load(xsltReader, xsltTransformSettings, null);
xsltReader.Close();
//Create an XsltArgumentList.
var xslArg = new XsltArgumentList();
if (myParams != null)
{
foreach (string param in myParams.Keys)
{
xslArg.AddParam(param, "", myParams[param]);
}
}
//Transform the file. and writing to temporary File
var setting = new XmlReaderSettings {
DtdProcessing = DtdProcessing.Parse, XmlResolver = null
};
XmlReader reader = XmlReader.Create(inputFile, setting);
var writerSettings = new XmlWriterSettings();
if (!IncludeUtf8BomIdentifier || !ext.ToLower().Contains("xhtml"))
{
writerSettings.ConformanceLevel = ConformanceLevel.Fragment;
}
if (IncludeUtf8BomIdentifier)
{
writerSettings.Encoding = Encoding.UTF8;
}
else
{
writerSettings.Encoding = new UTF8Encoding(IncludeUtf8BomIdentifier);
IncludeUtf8BomIdentifier = true; // reset to true for next time if it has been changed
}
if (XsltFormat == Formatting.Indented)
{
writerSettings.Indent = true;
XsltFormat = Formatting.None; // reset to None for next time if it has been changed
}
var writer = XmlWriter.Create(result, writerSettings);
if (ext.ToLower().Contains("xhtml"))
{
writer.WriteStartDocument();
}
xslt.Transform(reader, xslArg, writer);
writer.Close();
reader.Close();
return(result);
}
catch (FileNotFoundException ex)
{
return(ex.Message);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return(ex.Message);
}
}
private string Transform(string xml, string xsl, XsltArgumentList argsList)
{
XDocument selectedXml = XDocument.Parse(xml);
XslCompiledTransform xmlTransform = new XslCompiledTransform();
StringBuilder htmlOutput = new StringBuilder();
XmlWriter writer = XmlWriter.Create(htmlOutput);
xmlTransform.Load(xsl);
xmlTransform.Transform(selectedXml.CreateReader(), argsList, writer);
return htmlOutput.ToString();
}
/// <summary>
/// Generate the order receipt using XSL Transformation
/// </summary>
public void GenerateReceipt()
{
string templatePath = Server.MapPath(ZNodeConfigManager.EnvironmentConfig.ConfigPath + "Receipt.xsl");
XmlDocument xmlDoc = new XmlDocument();
XmlElement rootElement = GetElement(xmlDoc, "Order", "");
rootElement.AppendChild(GetElement(xmlDoc, "SiteName", ZNodeConfigManager.SiteConfig.CompanyName));
rootElement.AppendChild(GetElement(xmlDoc, "AccountId", _Order.AccountID.ToString()));
rootElement.AppendChild(GetElement(xmlDoc, "ReceiptText", ZNodeConfigManager.MessageConfig.GetMessage("OrderReceiptConfirmationIntroText")));
rootElement.AppendChild(GetElement(xmlDoc, "CustomerServiceEmail", ZNodeConfigManager.SiteConfig.CustomerServiceEmail));
rootElement.AppendChild(GetElement(xmlDoc, "CustomerServicePhoneNumber", ZNodeConfigManager.SiteConfig.CustomerServicePhoneNumber));
rootElement.AppendChild(GetElement(xmlDoc, "FeedBack", FeedBackUrl));
if (_Order.CardTransactionID != null)
{
rootElement.AppendChild(GetElement(xmlDoc, "TransactionID", _Order.CardTransactionID));
}
rootElement.AppendChild(GetElement(xmlDoc, "PromotionCode", _Order.CouponCode));
rootElement.AppendChild(GetElement(xmlDoc, "PONumber", _Order.PurchaseOrderNumber));
rootElement.AppendChild(GetElement(xmlDoc, "OrderId", _Order.OrderID.ToString()));
rootElement.AppendChild(GetElement(xmlDoc, "OrderDate", _Order.OrderDate.ToString()));
rootElement.AppendChild(GetElement(xmlDoc, "ShippingName", _shoppingCart.Shipping.ShippingName));
rootElement.AppendChild(GetElement(xmlDoc, "PaymentName", _shoppingCart.Payment.PaymentName));
rootElement.AppendChild(GetElement(xmlDoc, "ShippingAddressCompanyName", _Order.ShippingAddress.CompanyName));
rootElement.AppendChild(GetElement(xmlDoc, "ShippingAddressFirstName", _Order.ShippingAddress.FirstName));
rootElement.AppendChild(GetElement(xmlDoc, "ShippingAddressLastName", _Order.ShippingAddress.LastName));
rootElement.AppendChild(GetElement(xmlDoc, "ShippingAddressStreet1", _Order.ShippingAddress.Street1));
rootElement.AppendChild(GetElement(xmlDoc, "ShippingAddressStreet2", _Order.ShippingAddress.Street2));
rootElement.AppendChild(GetElement(xmlDoc, "ShippingAddressCity", _Order.ShippingAddress.City));
rootElement.AppendChild(GetElement(xmlDoc, "ShippingAddressStateCode", _Order.ShippingAddress.StateCode));
rootElement.AppendChild(GetElement(xmlDoc, "ShippingAddressPostalCode", _Order.ShippingAddress.PostalCode));
rootElement.AppendChild(GetElement(xmlDoc, "ShippingAddressCountryCode", _Order.ShippingAddress.CountryCode));
rootElement.AppendChild(GetElement(xmlDoc, "ShippingAddressPhoneNumber", _Order.ShippingAddress.PhoneNumber));
rootElement.AppendChild(GetElement(xmlDoc, "BillingAddressCompanyName", _Order.BillingAddress.CompanyName));
rootElement.AppendChild(GetElement(xmlDoc, "BillingAddressFirstName", _Order.BillingAddress.FirstName));
rootElement.AppendChild(GetElement(xmlDoc, "BillingAddressLastName", _Order.BillingAddress.LastName));
rootElement.AppendChild(GetElement(xmlDoc, "BillingAddressStreet1", _Order.BillingAddress.Street1));
rootElement.AppendChild(GetElement(xmlDoc, "BillingAddressStreet2", _Order.BillingAddress.Street2));
rootElement.AppendChild(GetElement(xmlDoc, "BillingAddressCity", _Order.BillingAddress.City));
rootElement.AppendChild(GetElement(xmlDoc, "BillingAddressStateCode", _Order.BillingAddress.StateCode));
rootElement.AppendChild(GetElement(xmlDoc, "BillingAddressPostalCode", _Order.BillingAddress.PostalCode));
rootElement.AppendChild(GetElement(xmlDoc, "BillingAddressCountryCode", _Order.BillingAddress.CountryCode));
rootElement.AppendChild(GetElement(xmlDoc, "BillingAddressPhoneNumber", _Order.BillingAddress.PhoneNumber));
XmlElement items = xmlDoc.CreateElement("Items");
foreach (ZNodeShoppingCartItem shoppingCartItem in _shoppingCart.ShoppingCartItems)
{
XmlElement item = xmlDoc.CreateElement("Item");
item.AppendChild(GetElement(xmlDoc, "Quantity", shoppingCartItem.Quantity.ToString()));
ZNodeGenericCollection<ZNodeDigitalAsset> assetCollection = shoppingCartItem.Product.ZNodeDigitalAssetCollection;
System.Text.StringBuilder sb = new System.Text.StringBuilder();
sb.Append(shoppingCartItem.Product.Name + "<br />");
if (assetCollection.Count > 0)
{
sb.Append("DownloadLink : <a href='" + shoppingCartItem.Product.DownloadLink + "' target='_blank'>" + shoppingCartItem.Product.DownloadLink + "</a><br />");
foreach (ZNodeDigitalAsset digitalAsset in assetCollection)
{
sb.Append(digitalAsset.DigitalAsset + "<br />");
}
}
item.AppendChild(GetElement(xmlDoc, "Name", sb.ToString()));
item.AppendChild(GetElement(xmlDoc, "SKU", shoppingCartItem.Product.SKU));
item.AppendChild(GetElement(xmlDoc, "Description", shoppingCartItem.Product.ShoppingCartDescription));
item.AppendChild(GetElement(xmlDoc, "Note", ""));
item.AppendChild(GetElement(xmlDoc, "Price", shoppingCartItem.UnitPrice.ToString("c") + ZNodeCurrencyManager.GetCurrencySuffix()));
item.AppendChild(GetElement(xmlDoc, "Extended", shoppingCartItem.ExtendedPrice.ToString("c") + ZNodeCurrencyManager.GetCurrencySuffix()));
items.AppendChild(item);
}
rootElement.AppendChild(GetElement(xmlDoc, "TaxCostValue", _Order.TaxCost.ToString()));
rootElement.AppendChild(GetElement(xmlDoc, "SalesTaxValue", _Order.SalesTax.ToString()));
rootElement.AppendChild(GetElement(xmlDoc, "VATCostValue", _Order.VAT.ToString()));
rootElement.AppendChild(GetElement(xmlDoc, "HSTCostValue", _Order.HST.ToString()));
rootElement.AppendChild(GetElement(xmlDoc, "PSTCostValue", _Order.PST.ToString()));
rootElement.AppendChild(GetElement(xmlDoc, "GSTCostValue", _Order.GST.ToString()));
rootElement.AppendChild(GetElement(xmlDoc, "SubTotal", _Order.SubTotal.ToString("c") + ZNodeCurrencyManager.GetCurrencySuffix()));
rootElement.AppendChild(GetElement(xmlDoc, "TaxCost", _Order.TaxCost.ToString("c") + ZNodeCurrencyManager.GetCurrencySuffix()));
rootElement.AppendChild(GetElement(xmlDoc, "SalesTax", _Order.SalesTax.ToString("c") + ZNodeCurrencyManager.GetCurrencySuffix()));
rootElement.AppendChild(GetElement(xmlDoc, "VAT", _Order.VAT.ToString("c") + ZNodeCurrencyManager.GetCurrencySuffix()));
rootElement.AppendChild(GetElement(xmlDoc, "HST", _Order.HST.ToString("c") + ZNodeCurrencyManager.GetCurrencySuffix()));
rootElement.AppendChild(GetElement(xmlDoc, "PST", _Order.PST.ToString("c") + ZNodeCurrencyManager.GetCurrencySuffix()));
rootElement.AppendChild(GetElement(xmlDoc, "GST", _Order.GST.ToString("c") + ZNodeCurrencyManager.GetCurrencySuffix()));
//
rootElement.AppendChild(GetElement(xmlDoc, "DiscountAmount", "-" + _Order.DiscountAmount.ToString("c") + ZNodeCurrencyManager.GetCurrencySuffix()));
rootElement.AppendChild(GetElement(xmlDoc, "ShippingName", _shoppingCart.Shipping.ShippingName));
rootElement.AppendChild(GetElement(xmlDoc, "ShippingCost", _Order.ShippingCost.ToString("c") + ZNodeCurrencyManager.GetCurrencySuffix()));
rootElement.AppendChild(GetElement(xmlDoc, "TotalCost", _Order.Total.ToString("c") + ZNodeCurrencyManager.GetCurrencySuffix()));
rootElement.AppendChild(GetElement(xmlDoc, "AdditionalInstructions", _Order.AdditionalInstructions));
rootElement.AppendChild(items);
xmlDoc.AppendChild(rootElement);
// Use a memorystream to store the result into the memory
MemoryStream ms = new MemoryStream();
XslCompiledTransform xsl = new XslCompiledTransform();
xsl.Load(templatePath);
xsl.Transform(xmlDoc, null, ms);
// Move to the begining
ms.Seek(0, SeekOrigin.Begin);
// Pass the memorystream to a streamreader
StreamReader sr = new StreamReader(ms);
_receiptTemplate = sr.ReadToEnd();
}
public void renderLoginControls()
{
try
{
string XmlPath = Server.MapPath("xml/UserLogin.xml");
string XsltPath = Server.MapPath("xslt/UserLogin.xslt");
XPathDocument xdoc = new XPathDocument(XmlPath);
XslCompiledTransform transform = new XslCompiledTransform();
transform.Load(XsltPath);
StringWriter sw = new StringWriter();
//Transform
transform.Transform(xdoc, null, sw);
string result = sw.ToString();
//Remove Namespace
result = result.Replace("xmlns:asp=\"remove\"", "");
result = result.Replace("xmlns:cc1=\"remove\"", "");
//Parse Control
Control ctrl = Page.ParseControl(result);
phLogin.Controls.Add(ctrl);
}
catch (Exception ex)
{
objNLog.Error("Error : " + ex.Message);
}
}
