public static string Transform(string xmlPath, XmlWriterSettings xSettings, XsltArgumentList argList)
{
string html = string.Empty;
string transformFile = RulesEngineUtils.GetResourcePath(RulesEngineUtils.ReportBuilderFolder.Resources, RulesEngineUtils.TransformFile);
XslCompiledTransform transform = new XslCompiledTransform();
transform.Load(transformFile);
using (XmlReader xmlReader = XmlReader.Create(xmlPath))
{
using (MemoryStream ms = new MemoryStream())
{
try
{
using (XmlWriter xWriter = new RivetXmlWriter(ms, xSettings))
{
transform.Transform(xmlReader, argList, xWriter);
}
html = xSettings.Encoding.GetString(ms.ToArray());
return(html);
}
catch (Exception ex)
{
html = "<h2>Error <small>generating preview</small></h2>" +
"<pre>" + ex.Message + "</pre>";
}
}
}
return(html);
}
private void ValidateEquityStructure(string equityMembersXml, out XmlDocument membersXDoc)
{
membersXDoc = new XmlDocument();
bool hasBeginningBalance = ReportUtils.Exists(this.Rows, row => row.IsBeginningBalance);
if (!hasBeginningBalance)
{
throw new IncompleteEquityException(IncompleteEquityException.ErrorType.MissingBeginningBalance);
}
bool hasEndingBalance = ReportUtils.Exists(this.Rows, row => row.IsEndingBalance);
if (!hasEndingBalance)
{
throw new IncompleteEquityException(IncompleteEquityException.ErrorType.MissingEndingBalance);
}
string equityMembersXmlPath = RulesEngineUtils.GetResourcePath(RulesEngineUtils.ReportBuilderFolder.Rules, equityMembersXml);
if (!File.Exists(equityMembersXmlPath))
{
throw new IncompleteEquityException(IncompleteEquityException.ErrorType.MissingMembersFile);
}
try
{
membersXDoc.Load(equityMembersXmlPath);
}
catch
{
throw new IncompleteEquityException(IncompleteEquityException.ErrorType.MembersFileFormat);
}
}
static FilingProcessor()
{
bin = AppDomain.CurrentDomain.BaseDirectory;
cd = Environment.CurrentDirectory;
RulesEngineUtils.SetBaseResourcePath(bin);
XRB.ReportBuilder.SetSynchronizedResources(true);
}
public bool HTML(InstanceReport report, string readFrom, string saveAs)
{
bool retval = true;
try
{
string transformFile = RulesEngineUtils.GetResourcePath(RulesEngineUtils.ReportBuilderFolder.Resources, RulesEngineUtils.TransformFile);
if (!File.Exists(transformFile))
{
Trace.TraceError("Error: Transform File '" + RulesEngineUtils.TransformFile + "' not found at:\n\t" + transformFile + "\nHtml Conversion aborted.");
return(false);
}
XslCompiledTransform transform = new XslCompiledTransform();
transform.Load(transformFile);
XsltArgumentList argList = new XsltArgumentList();
argList.AddParam("asPage", string.Empty, "true");
using (FileStream fs = new FileStream(saveAs, FileMode.Create, FileAccess.Write))
{
transform.Transform(readFrom, argList, fs);
}
string reportDirectory = Path.GetDirectoryName(saveAs);
string styleSheetTo = Path.Combine(reportDirectory, RulesEngineUtils.StylesheetFile);
string stylesheetFrom = RulesEngineUtils.GetResourcePath(RulesEngineUtils.ReportBuilderFolder.Resources, RulesEngineUtils.StylesheetFile);
FileUtilities.Copy(stylesheetFrom, styleSheetTo);
string javascriptTo = Path.Combine(reportDirectory, RulesEngineUtils.JavascriptFile);
string javascriptFrom = RulesEngineUtils.GetResourcePath(RulesEngineUtils.ReportBuilderFolder.Resources, RulesEngineUtils.JavascriptFile);
FileUtilities.Copy(javascriptFrom, javascriptTo);
return(true);
}
catch (IOException ex)
{
RLogger.Error(string.Format("An error occured writing the HTML file {0}. Error: {1}", report.ReportName, ex.Message));
retval = false;
}
catch (System.Security.SecurityException ex)
{
RLogger.Error(string.Format("An error occured writing the HTML file {0}. Error: {1}", report.ReportName, ex.Message));
retval = false;
}
catch (ArgumentNullException ex)
{
RLogger.Error(string.Format("An error occured writing the HTML file {0}. Error: {1}", report.ReportName, ex.Message));
retval = false;
}
return(retval);
}
public bool BuildReports(string instanceFolder, string instanceName, string taxonomyName, out FilingSummary filingSummary, out string error)
{
Console.WriteLine("=================================================");
Console.WriteLine(" BUILD " + instanceFolder + "...");
Console.WriteLine("=================================================");
this.processingTime = TimeSpan.Zero;
DateTime startTime = DateTime.Now;
string instance = PathCombine(instanceFolder, instanceName + ".xml");
string taxonomy = PathCombine(instanceFolder, taxonomyName + ".xsd");
string reportDir = PathCombine(instanceFolder, "Reports");
string filingSummaryPath = PathCombine(reportDir, "FilingSummary.xml");
CleanAndPrepareFolder(reportDir);
XRB.ReportBuilder myReportBuilder = new XRB.ReportBuilder();
myReportBuilder.ReportFormat = OutputFormat;
myReportBuilder.HtmlReportFormat = HtmlFormat;
myReportBuilder.RemoteFileCachePolicy = CachePolicy;
myReportBuilder.OnBuildReportsProcessing += this.FireBuildReportsProcessing;
myReportBuilder.OnBuildReportsProcessed += this.FireBuildReportsProcessed;
if (string.IsNullOrEmpty(ResourcePath))
{
RulesEngineUtils.SetBaseResourcePath(null);
}
else
{
RulesEngineUtils.SetBaseResourcePath(ResourcePath);
}
bool status = myReportBuilder.BuildReports(instance, taxonomy, filingSummaryPath, reportDir, out filingSummary, out error);
this.myFilingSummary = status ? filingSummary : null;
myReportBuilder.OnBuildReportsProcessing -= this.FireBuildReportsProcessing;
myReportBuilder.OnBuildReportsProcessed -= this.FireBuildReportsProcessed;
DateTime endTime = DateTime.Now;
this.processingTime = (endTime - startTime);
return(status);
}
public static void CopyResourcesToPath(string copyPath)
{
string[] resources = new string[]
{
RulesEngineUtils.TransformFile,
RulesEngineUtils.StylesheetFile,
RulesEngineUtils.JavascriptFile
};
string xsltPath = string.Empty;
foreach (string resource in resources)
{
string from = RulesEngineUtils.GetResourcePath(RulesEngineUtils.ReportBuilderFolder.Resources, resource);
string to = Path.Combine(copyPath, resource);
FileUtilities.Copy(from, to);
}
}
public static string Transform(string xmlPath, XsltArgumentList argList)
{
string html = null;
try
{
string transformFile = RulesEngineUtils.GetResourcePath(RulesEngineUtils.ReportBuilderFolder.Resources, "InstanceReport.xslt");
XslCompiledTransform transform = new XslCompiledTransform();
transform.Load(transformFile);
using (MemoryStream ms = new MemoryStream())
{
XmlWriterSettings xSettings = new XmlWriterSettings();
xSettings.ConformanceLevel = ConformanceLevel.Fragment;
xSettings.Encoding = Encoding.ASCII;
xSettings.Indent = true;
xSettings.OmitXmlDeclaration = true;
//we REALLY need to set this to HTML
xSettings.GetType().GetProperty("OutputMethod").SetValue(xSettings, XmlOutputMethod.Html, null);
using (XmlWriter xWriter = XmlWriter.Create(ms, xSettings))
{
transform.Transform(xmlPath, argList, xWriter);
}
ms.Flush();
html = Encoding.ASCII.GetString(ms.ToArray());
}
}
catch (Exception ex)
{
html = "<h2>Error <small>generating preview</small></h2>" +
"<pre>" + ex.Message + "</pre>";
}
return(html);
}
protected bool BuildReports(FilingInfo filing, string reportsFolder, out string error)
{
error = null;
bool foundFiles = true;
string errorMsg = string.Empty;
string filingPath = Path.Combine(filing.ParentFolder, filing.AccessionNumber);
string filingReportsPath = Path.Combine(filingPath, "Reports");
string filingErrorFile = Path.Combine(filingReportsPath, ERROR_FILE_NAME);
string instancePath = filing.GetInstanceDocPath();
string taxonomyPath = filing.GetTaxonomyPath();
if (string.IsNullOrEmpty(instancePath) ||
!File.Exists(instancePath))
{
errorMsg = string.Format("Can not find instance document for filing: {0}", filing.AccessionNumber);
FilingProcessorManager.TheMgr.WriteLogEntry(errorMsg, EventLogEntryType.Error);
foundFiles = false;
}
else if (string.IsNullOrEmpty(taxonomyPath) ||
!File.Exists(taxonomyPath))
{
errorMsg = string.Format("Can not find taxonomy file for filing: {0}", filing.AccessionNumber);
FilingProcessorManager.TheMgr.WriteLogEntry(errorMsg, EventLogEntryType.Error);
foundFiles = false;
}
bool buildSucceeded = false;
if (foundFiles)
{
string baseResourcePath = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
FilingProcessorManager.TheMgr.WriteLogEntry(string.Format("Setting base path for Rules Engine. Path: {0}", baseResourcePath), EventLogEntryType.Information);
RulesEngineUtils.SetBaseResourcePath(baseResourcePath);
ReportBuilder.SetSynchronizedResources(true);
FilingProcessorManager.TheMgr.WriteLogEntry("Selected rule file: '" + FinancialRuleFile + "' for instance document: '" + Path.GetFileName(instancePath) + "'", EventLogEntryType.Information);
ReportBuilder rb = new ReportBuilder(FinancialRuleFile, ReportFormat, HtmlReportFormat);
rb.CurrencyMappingFile = CurrencyMappingFile;
rb.RemoteFileCachePolicy = RemoteFileCachePolicy;
//if( XmlCatalog != null )
// rb.XmlCatalog = XmlCatalog;
//Reports will be saves under the Filing's Processing folder then copied out to the actual reports folder,
//this will allow us to only copy complete sets of R files to the Reports Folder.
string filingSummaryFile = string.Format("{0}{1}{2}", filingReportsPath, Path.DirectorySeparatorChar, FilingSummary.FilingSummaryXmlName);
//Make sure there is a clean folder where the reports will be written to.
if (Directory.Exists(filingReportsPath))
{
Directory.Delete(filingReportsPath, true);
}
Directory.CreateDirectory(filingReportsPath);
FilingSummary summary = null;
buildSucceeded = rb.BuildReports(instancePath, taxonomyPath, filingSummaryFile, filingReportsPath, out summary, out error);
if (!buildSucceeded)
{
errorMsg = string.Format("Call to BuildReports failed for Filing {0}: {1}", filing.AccessionNumber, error);
FilingProcessorManager.TheMgr.WriteLogEntry(errorMsg, EventLogEntryType.Error);
if (!Directory.Exists(filingReportsPath))
{
Directory.CreateDirectory(filingReportsPath);
}
File.WriteAllText(filingErrorFile, errorMsg);
}
}
else
{
if (!Directory.Exists(filingReportsPath))
{
Directory.CreateDirectory(filingReportsPath);
}
File.WriteAllText(filingErrorFile, errorMsg);
}
try
{
string errorFileName = filing.AccessionNumber + "_" + Path.GetFileName(filingErrorFile);
string reportErrorFile = Path.Combine(reportsFolder, errorFileName);
string reportZipFile = Path.Combine(reportsFolder, filing.AccessionNumber + ".zip");
if (File.Exists(reportErrorFile))
{
FileUtilities.DeleteFile(new FileInfo(reportErrorFile), true);
}
if (File.Exists(reportZipFile))
{
FileUtilities.DeleteFile(new FileInfo(reportZipFile), true);
}
if (buildSucceeded)
{
string[] filePathsToZip = Directory.GetFiles(filingReportsPath);
string[] filesToZip = new string[filePathsToZip.Length];
for (int i = 0; i < filesToZip.Length; i++)
{
filesToZip[i] = Path.GetFileName(filePathsToZip[i]);
}
string zipFile = Path.Combine(filingReportsPath, filing.AccessionNumber + ".zip");
if (ZipUtilities.TryZipAndCompressFiles(zipFile, filingReportsPath, filesToZip))
{
File.Copy(zipFile, reportZipFile);
}
}
else
{
File.Copy(filingErrorFile, reportErrorFile);
}
if (DeleteProcessedFilings)
{
DirectoryInfo di = new DirectoryInfo(filingPath);
FileUtilities.DeleteDirectory(di, true, true);
di = new DirectoryInfo(filing.ParentFolder);
if (di.GetDirectories().Length == 0 && di.GetFiles().Length == 0)
{
FileUtilities.DeleteDirectory(di, true, true);
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
if (buildSucceeded)
{
FilingProcessorManager.TheMgr.IncrementCompletedCount();
}
return(buildSucceeded);
}
/// <summary>
///
/// </summary>
/// <param name="reportDirectory">The folder containing all reports (R1.xml, etc)</param>
/// <param name="xsltPath">The path to InstanceReport_XmlWorkbook.xslt</param>
/// <param name="cssPath">The path to report.css</param>
/// <returns></returns>
public static SingleFileWorkbook GenerateExcelWorkbook(FilingSummary myFilingSummary, string reportDirectory)
{
string cssPath = RulesEngineUtils.GetResourcePath(RulesEngineUtils.ReportBuilderFolder.Resources, RulesEngineUtils.StylesheetFile);
string xsltPath = RulesEngineUtils.GetResourcePath(RulesEngineUtils.ReportBuilderFolder.Resources, RulesEngineUtils.TransformWorkbookFile);
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load(xsltPath);
SingleFileWorkbook sfwb = new SingleFileWorkbook();
Dictionary <string, int> sheetNames = new Dictionary <string, int>();
//Process the R files. Each R File will be transformed into a worksheet in the workbook
int idx = 0;
foreach (ReportHeader reportHeader in myFilingSummary.MyReports)
{
if (reportHeader.ReportType == ReportHeaderType.Book)
{
continue;
}
string reportPath = Path.Combine(reportDirectory, reportHeader.XmlFileName);
if (!File.Exists(reportPath))
{
Trace.TraceError(
"Error: An error occurred while creating the Excel Workbook.\n" +
"Sheet '" + reportHeader.ShortName + "' could not be loaded.\n" +
"Reason:\n\tFile not found."
);
continue;
}
try
{
idx++;
string tmpPath = Path.GetTempFileName();
if (File.Exists(tmpPath + ".html"))
{
FileInfo fi = new FileInfo(tmpPath + ".html");
FileUtilities.DeleteFile(fi, true);
}
File.Move(tmpPath, tmpPath + ".html");
tmpPath += ".html";
xslt.Transform(reportPath, tmpPath);
SingleFileAttachment sfa = sfwb.AddAttachment(tmpPath);
sfa.UseName = "Sheet" + idx.ToString("00") + ".html";
sfa.Name = NameSheet(reportHeader.ShortName, sheetNames);
sheetNames[sfa.Name] = 1;
}
catch (Exception ex)
{
Trace.TraceWarning(
"Warning: An error occurred while creating the Excel Workbook.\n" +
"Sheet '" + reportHeader.ShortName + "' may be missing.\n" +
"Reason:\n\t" + ex.Message
);
}
}
string[] charts = Directory.GetFiles(reportDirectory, "*.jpg");
foreach (string chart in charts)
{
try
{
SingleFileAttachment sfa = sfwb.AddAttachment(chart);
}
catch (Exception ex)
{
Trace.TraceWarning(
"Warning: An error occurred while creating the Excel Workbook.\n" +
"This attachment could not be embedded:\n\t" + Path.GetFileName(chart) +
"\nReason:\n\t" + ex.Message
);
}
}
return(sfwb);
}
