///// <summary> ///// Creates an excel file containing data provided in the dataparts. ///// Each IDatapart will match with an ExportPart of the same PartId ///// and will use this information to output the data in the desired format. ///// </summary> ///// <param name="open">true to open, false to not</param> ///// <param name="title">The title.</param> ///// <param name="dataParts">The data parts to output</param> ///// <param name="metadata">The metadata.</param> ///// <param name="exportParameters">Optional export parameters.</param> ///// <returns>The full path of the created file</returns> //public string ExportToExcel(bool open, string title, IEnumerable<IDataPart> dataParts, ExportMetadata metadata, ExcelTemplatePackage templatePackage, ExportParameters exportParameters = null) //{ // if (string.IsNullOrEmpty(title)) // { // throw new ArgumentNullException("targetFilePath"); // } // if (dataParts == null) // { // throw new ArgumentNullException("dataParts"); // } // if (metadata == null) // { // throw new ArgumentNullException("metadata"); // } // if (templatePackage == null) // { // throw new ArgumentNullException("templatePackage"); // } // // Adds the parameters as a data part (creates a hidden sheet) // dataParts = AddDebugPart(dataParts, metadata, exportParameters); // // build our sets of DataParts, ExportParts, ExportTemplates // List<ExportTripleSet> sets = this.BuildSets(dataParts, metadata, templatePackage); // if (sets.Count == 0) // { // throw new ExportException("Nothing to export, no matching DataParts, ExportParts, ExportTemplates found"); // } // var stream = this.ExcelExportInternal(exportParameters, metadata, sets, dataParts, templatePackage); // if (!title.EndsWith(".xls") && !title.EndsWith(".xlsx")) // { // title = string.Concat(title, ".xlsx"); // } // return SaveAndOpen(open, title, stream); //} /// <summary> /// Exports to excel memory stream. /// </summary> /// <param name="dataParts">The data parts.</param> /// <param name="metadata">The metadata.</param> /// <param name="templatePackage">The template package.</param> /// <param name="exportParameters">The export parameters.</param> /// <returns></returns> public ExportToMemoryStreamResult ExportToExcelMemoryStream( IEnumerable <IDataPart> dataParts, Book metadata, ExcelTemplatePackage resourcePackage, ExportParameters exportParameters = null) { Guard.IsNotNull(dataParts, "dataParts"); Guard.IsNotNull(metadata, "metadata"); Guard.IsNotNull(resourcePackage, "resourcePackage"); var result = new ExportToMemoryStreamResult(); dataParts = AddDebugPart(dataParts, metadata, exportParameters); // build our sets of DataParts, ExportParts, ExportTemplates List <ExportTripleSet> sets = this.BuildSets(dataParts, metadata, resourcePackage); if (sets.Count == 0) { throw new ExportException("Nothing to export, no matching DataParts, ExportParts, ExportTemplates found"); } try { result.MemoryStream = this.ExcelExportInternal(exportParameters, metadata, sets, dataParts, resourcePackage); } catch (Exception ex) { result.Error = ex; } return(result); }
/// <summary> /// The generate export metadata report. /// </summary> private MemoryStreamResult GenerateExportMetadataBasedReport() { this.logger.Log(LogType.Trace, this.GetAssemblyName(), "{0}.GenerateExportMetadataReport", this.GetType().Name); var resourcesPackage = ExcelTemplatePackage.Open(Path.Combine(this.sourceFolder, this.templatePackageName)); var exportMetadata = ExportMetadataPackage.Open(Path.Combine(this.sourceFolder, this.metadataPackageName)).ExportMetadata; var generator = new ExportGenerator(); var exportParams = new ExportParameters(); ExportToMemoryStreamResult result = generator.ExportToExcelMemoryStream(this.dataParts, exportMetadata, resourcesPackage, exportParams); if (result.Error != null) { this.logger.Log(LogType.Fatal, this.GetAssemblyName(), "{0}.GenerateExportMetadataReport", result.Error); } return(new MemoryStreamResult { MemoryStream = result.MemoryStream, Status = result.Error == null ? MemoryStreamResultStatus.Success : MemoryStreamResultStatus.Failure, ErrorMessage = result.Error == null ? null : result.Error.Message, }); }
///// <summary> ///// Saves the memory stream to my documents with the provided title ///// </summary> ///// <param name="title">The title.</param> ///// <param name="stream">The stream.</param> ///// <returns> ///// The full path of the saved file ///// </returns> //public static string Save(string title, MemoryStream stream) //{ // string filePath = FileHelper.GetMyDocumentFilePath(title); // using (FileStream fileStream = File.OpenWrite(filePath)) // { // stream.WriteTo(fileStream); // } // return filePath; //} ///// <summary> ///// Saves the stream to the my documents with the title ///// Optionally opends ///// </summary> ///// <param name="open">if set to <c>true</c> [open].</param> ///// <param name="title">The title.</param> ///// <param name="stream">The stream.</param> ///// <returns> ///// The full path of the saved file ///// </returns> //public static string SaveAndOpen(bool open, string title, MemoryStream stream) //{ // // call save and open // string outputFile = Save(title, stream); // if (open) // { // ThreadPool.QueueUserWorkItem( // (obj) => // { // Process.Start(outputFile); // }); // } // return outputFile; //} #region Build of export sets /// <summary> /// Creates a list of export sets matching parts based on the provided data. /// For each data part try and find a matching export part. /// If any mandatory export parts havent been provided with data an exception will be thrown. /// </summary> /// <param name="dataParts">The data parts.</param> /// <param name="exportMetadata">The export metadata.</param> /// <param name="templatePackage">The template package.</param> /// <returns></returns> /// <exception cref="MetadataException"></exception> private List <ExportTripleSet> BuildSets( IEnumerable <IDataPart> dataParts, Book exportMetadata, ExcelTemplatePackage templatePackage) { // pair up the data with the export part and keep them for use later var sets = new List <ExportTripleSet>(); // for each data part get the matching export part foreach (var dataPart in dataParts) { if (dataPart == null) { continue; } // return the ExportPart(s) that matches with the provided data part foreach (var exportPart in SafePartMatch(dataPart, exportMetadata.Parts)) { // return a new instance of the template var template = templatePackage.GetTemplateByTemplateId(exportPart.TemplateId); // and add the 3 items to the set sets.Add(new ExportTripleSet(dataPart, exportPart, template)); } } // get a list of mandatory parts var mandatoryExportParts = from p in exportMetadata.Parts where p.IsMandatory select p; StringBuilder errors = new StringBuilder(); // and for each of these check that they've been added to the set foreach (var mandatory in mandatoryExportParts) { bool match = (from s in sets where s.Part == mandatory select s).Any(); // if we cant find one them add to our list of errors if (!match) { errors.Append("No DataPart supplied for mandatory export part <"); errors.Append(mandatory.PartId); errors.Append(">"); errors.Append(Environment.NewLine); } } // then throw any missing mandatorys as a metadata exception if (errors.Length > 0) { throw new MetadataException(errors.ToString()); } return(sets); }
/// <summary> /// Creates a fully populated <see cref="ResourceStore" /> which contains all resources defined in a <see cref="TemplateCollection" />. /// This is for backward compatibility during processing of a <see cref="TemplateCollection" />. /// </summary> /// <param name="templateCollection">The template collection.</param> /// <param name="templatePackage">The template package.</param> /// <returns> /// A fully populated <see cref="ResourceStore" /> /// </returns> internal static ResourceStore Create(TemplateCollection templateCollection, ExcelTemplatePackage templatePackage) { if (templateCollection == null || string.IsNullOrEmpty(templateCollection.XamlString)) { return(null); } ResourceStore resourceStore = new ResourceStore(); var document = XDocument.Parse(templateCollection.XamlString); // Add in the defined Styles foreach (var resource in templateCollection.StyleResources) { resourceStore.Add(resource.Key, ResourceTypeNames.StyleBase, resource, null); } // Add in CellStyleSelectors foreach (var resource in templateCollection.CellStyleSelectors) { resourceStore.Add(resource.Key, ResourceTypeNames.CellStyleSelector, resource, null); } // Loop over each all elements, adding any that are defined in the Maps collection or identified as being Template resources foreach (var element in document.Root.Elements()) { if (element.NodeType != XmlNodeType.Element || element.Name == null) { continue; } if (element.Name.LocalName.CompareTo("TemplateCollection.Maps") == 0) { foreach (var mapElement in element.Elements()) { AddElementToStore(templateCollection, resourceStore, mapElement); } } else if (element.Name.LocalName.CompareTo("Template") == 0) { var id = element.Attribute("TemplateId").Value; resourceStore.Add(id, element.Name.LocalName, element.ToString(), templateCollection.TemplateFileName, null); } } // Add the TemplateFile as a designer file, which can be used by maps as a resource if (!string.IsNullOrEmpty(templateCollection.TemplateFileName)) { var data = templatePackage.TemplateResourceStore.templateDocumentDictionary[templateCollection.TemplateFileName].Data; resourceStore.AddDesignerFileData(templateCollection.TemplateFileName, data); } // Populate chart and shape models from the supplied resource designer files and defined templates, // such as ChartTemplate and ShapeTempaltes. resourceStore.PopulateModels(); return(resourceStore); }
/// <summary> /// The pack source templates folder. /// </summary> /// <param name="subFolderName">The sub folder name.</param> /// <returns>The zipped file name</returns> private string PackSourceTemplatesFolder(string subFolderName) { this.logger.Log(LogType.Trace, this.GetAssemblyName(), "{0}.PackSourceTemplatesFolder - Packing {1}", this.GetType().Name, subFolderName); string directory = Path.Combine(this.sourceFolder, subFolderName); string package = this.isExcelDocumentMetaBased ? ResourcePackage.Pack(directory) : ExcelTemplatePackage.Pack(directory); // Extract package name from returned return(Path.GetFileName(package)); }
/// <summary> /// Opens the specified file name. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="errors">The errors.</param> /// <returns></returns> public static ExcelTemplatePackage Open(string fileName, out string errors) { // avoid contention whilst opening file, should be v quick anyway lock (padLock) { try { errors = null; writeOutput = false; if (string.IsNullOrEmpty(fileName)) { throw new ArgumentNullException("fileName"); } var fi = new FileInfo(fileName); if (!fi.Exists) { throw new MetadataException(string.Format("File not found <{0}>", fileName)); } Output(string.Format("Starting open of package <{0}>", fileName)); ExcelTemplatePackage package = new ExcelTemplatePackage(); List <PackagePart> metadataParts = new List <PackagePart>(); List <PackagePart> fileParts = new List <PackagePart>(); using (var zip = ZipPackage.Open(fileName, FileMode.Open, FileAccess.Read)) { Output("Zip opened"); foreach (var part in zip.GetParts()) { string uriString = part.Uri.OriginalString; if (uriString.StartsWith(string.Concat(UriDelim, MetadataPathPart))) { metadataParts.Add(part); Output(string.Format("Found Metadata part: Uri <{0}>", uriString)); } else if (uriString.StartsWith(string.Concat(UriDelim, FilesPathPart))) { fileParts.Add(part); Output(string.Format("Found TemplateFile part: Uri <{0}>", uriString)); } } // read all the templates files into our internal store foreach (var m in metadataParts) { long length = m.GetStream().Length; byte[] data = new byte[length]; m.GetStream().Read(data, 0, (int)length); Output(string.Format("Loading Metadata part: Uri <{0}> Size {1}", m.Uri.OriginalString, length)); bool hasBomb = false; if (data.Length > 2 && data[0] == 0xEF && data[1] == 0xBB && data[2] == 0xBF) { hasBomb = true; Output("Stripping Byte Order Mark"); } string resourceString = System.Text.UTF8Encoding.UTF8.GetString(hasBomb ? data.Skip(3).ToArray() : data); string error = null; if (!package.TryLoadResourceString(m.Uri.OriginalString, resourceString, out error)) { if (string.IsNullOrEmpty(errors)) { errors = error; } else { errors += error; } errors += Environment.NewLine; } } foreach (var f in fileParts) { string name = f.Uri.OriginalString.Replace(string.Concat(UriDelim, FilesPathPart, UriDelim), null); long length = f.GetStream().Length; byte[] data = new byte[length]; f.GetStream().Read(data, 0, (int)length); Output(string.Format("Loading TemplateFile part: Uri <{0}> Size {1}", f.Uri.OriginalString, length)); package.LoadTemplateFile(name, data); } } package.ValidateInternal(); return(package); } catch (Exception ex) { Output(ex.ToString()); throw; } finally { writeOutput = false; } } }
///// <summary> ///// Creates an excel file containing data provided in the dataparts. ///// Each IDatapart will match with an ExportPart of the same PartId ///// and will use this information to output the data in the desired format. ///// </summary> ///// <param name="open">true to open, false to not</param> ///// <param name="title">The title.</param> ///// <param name="dataParts">The data parts to output</param> ///// <param name="metadata">The metadata.</param> ///// <param name="exportParameters">Optional export parameters.</param> ///// <returns>The full path of the created file</returns> //public string ExportToExcel(bool open, string title, IEnumerable<IDataPart> dataParts, ExportMetadata metadata, ExcelTemplatePackage templatePackage, ExportParameters exportParameters = null) //{ // if (string.IsNullOrEmpty(title)) // { // throw new ArgumentNullException("targetFilePath"); // } // if (dataParts == null) // { // throw new ArgumentNullException("dataParts"); // } // if (metadata == null) // { // throw new ArgumentNullException("metadata"); // } // if (templatePackage == null) // { // throw new ArgumentNullException("templatePackage"); // } // // Adds the parameters as a data part (creates a hidden sheet) // dataParts = AddDebugPart(dataParts, metadata, exportParameters); // // build our sets of DataParts, ExportParts, ExportTemplates // List<ExportTripleSet> sets = this.BuildSets(dataParts, metadata, templatePackage); // if (sets.Count == 0) // { // throw new ExportException("Nothing to export, no matching DataParts, ExportParts, ExportTemplates found"); // } // var stream = this.ExcelExportInternal(exportParameters, metadata, sets, dataParts, templatePackage); // if (!title.EndsWith(".xls") && !title.EndsWith(".xlsx")) // { // title = string.Concat(title, ".xlsx"); // } // return SaveAndOpen(open, title, stream); //} /// <summary> /// Exports to excel memory stream. /// </summary> /// <param name="dataParts">The data parts.</param> /// <param name="metadata">The metadata.</param> /// <param name="templatePackage">The template package.</param> /// <param name="exportParameters">The export parameters.</param> /// <returns></returns> public ExportToMemoryStreamResult ExportToExcelMemoryStream(IEnumerable <IDataPart> dataParts, ExportMetadata metadata, ExcelTemplatePackage templatePackage, ExportParameters exportParameters = null) { var result = new ExportToMemoryStreamResult(); if (dataParts == null) { throw new ArgumentNullException("dataParts"); } if (metadata == null) { throw new ArgumentNullException("metadata"); } if (templatePackage == null) { throw new ArgumentNullException("templatePackage"); } dataParts = AddDebugPart(dataParts, metadata, exportParameters); // build our sets of DataParts, ExportParts, ExportTemplates List <ExportTripleSet> sets = this.BuildSets(dataParts, metadata, templatePackage); if (sets.Count == 0) { throw new ExportException("Nothing to export, no matching DataParts, ExportParts, ExportTemplates found"); } try { result.MemoryStream = this.ExcelExportInternal(exportParameters, metadata, sets, dataParts, templatePackage); } catch (Exception ex) { result.Error = ex; } return(result); }