XlsxWriter.cs

/*
 * NanoXLSX is a small .NET library to generate and read XLSX (Microsoft Excel 2007 or newer) files in an easy and native way
 * Copyright Raphael Stoeckli © 2025
 * This library is licensed under the MIT License.
 * You find a copy of the license in project folder or on: http://opensource.org/licenses/MIT
 */
 
using NanoXLSX.Exceptions;
using NanoXLSX.Interfaces.Writer;
using NanoXLSX.Internal.Structures;
using NanoXLSX.Registry;
using NanoXLSX.Styles;
using NanoXLSX.Utils;
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Packaging;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using IOException = NanoXLSX.Exceptions.IOException;
using PackagePartType = NanoXLSX.Internal.Structures.PackagePartDefinition.PackagePartType;
using XmlElement = NanoXLSX.Utils.Xml.XmlElement;
 
namespace NanoXLSX.Internal.Writers
{
    internal class XlsxWriter : IBaseWriter
    {
 
        #region staticFields
        private static readonly DocumentPath WORKBOOK = new DocumentPath("workbook.xml", "xl/");
        private static readonly DocumentPath STYLES = new DocumentPath("styles.xml", "xl/");
        private static readonly DocumentPath APP_PROPERTIES = new DocumentPath("app.xml", "docProps/");
        private static readonly DocumentPath CORE_PROPERTIES = new DocumentPath("core.xml", "docProps/");
        private static readonly DocumentPath SHARED_STRINGS = new DocumentPath("sharedStrings.xml", "xl/");
        private static readonly DocumentPath THEME = new DocumentPath("theme1.xml", "xl/theme/");
        #endregion
 
        #region privateFields
        private int rootPackageIndex = 1;
        private int xlPackageIndex = 1;
 
        private readonly List<PackagePartDefinition> packagePartDefinitions = new List<PackagePartDefinition>();
 
        private readonly Dictionary<string, Dictionary<string, PackagePart>> packageParts = new Dictionary<string, Dictionary<string, PackagePart>>();
        private readonly Dictionary<int, DocumentPath> worksheetPaths = new Dictionary<int, DocumentPath>();
        private Package package = null;
 
        #endregion
 
        #region properties
        public Workbook Workbook { get; }

        public StyleManager Styles { get; private set; }

        public ISharedStringWriter SharedStringWriter { get; set; }
 
        #endregion
 
        #region constructors
        public XlsxWriter(Workbook workbook)
        {
            this.Workbook = workbook;
        }
        #endregion
 
        #region documentCreation_methods

        public void Save()
        {
            try
            {
                FileStream fs = new FileStream(Workbook.Filename, FileMode.Create);
                SaveAsStream(fs);
 
            }
            catch (Exception e)
            {
                throw new IOException("An error occurred while saving. See inner exception for details: " + e.Message, e);
            }
        }

        public async Task SaveAsync()
        {
            await Task.Run(() => { Save(); });
        }

        private void RegisterCommonPackageParts()
        {
            // Workbook should always be the lowest index
            RegisterPackagePart(PackagePartType.Root, PackagePartDefinition.WORKBOOK_PACKAGE_PART_INDEX, WORKBOOK, @"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml", @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument");
            if (this.Workbook.WorkbookMetadata != null)
            {
                int index = PackagePartDefinition.METADATA_PACKAGE_PART_START_INDEX;
                RegisterPackagePart(PackagePartType.Root, index, CORE_PROPERTIES, @"application/vnd.openxmlformats-package.core-properties+xml", @"http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties");
                RegisterPackagePart(PackagePartType.Root, index + 1000, APP_PROPERTIES, @"application/vnd.openxmlformats-officedocument.extended-properties+xml", @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties");
            }
            int worksheetOrderNumber = PackagePartDefinition.WORKSHEET_PACKAGE_PART_START_INDEX;
            if (this.Workbook.Worksheets.Count == 0)
            {
                RegisterPackagePart(PackagePartType.Worksheet, worksheetOrderNumber, "sheet1.xml", "xl/worksheets", @"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml", @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet");
            }
            else
            {
                for (int i = 0; i < this.Workbook.Worksheets.Count; i++)
                {
                    string fileName = "sheet" + ParserUtils.ToString(i + 1) + ".xml";
                    RegisterPackagePart(PackagePartType.Worksheet, worksheetOrderNumber, fileName, "xl/worksheets", @"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml", @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet");
                    worksheetOrderNumber++;
                }
            }
            int postWorksheetOrderNumber = PackagePartDefinition.POST_WORSHEET_PACKAGE_PART_START_INDEX;
            if (Workbook.WorkbookTheme != null)
            {
                RegisterPackagePart(PackagePartType.Other, postWorksheetOrderNumber, THEME, @"application/vnd.openxmlformats-officedocument.theme+xml", @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme");
                postWorksheetOrderNumber += 1000;
            }
            RegisterPackagePart(PackagePartType.Other, postWorksheetOrderNumber, STYLES, @"application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml", @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles");
            postWorksheetOrderNumber += 1000;
            RegisterPackagePart(PackagePartType.Other, postWorksheetOrderNumber, SHARED_STRINGS, @"application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml", @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings");
            // TODO: add themeIndex once if media is embedded
        }

        private void PreparePackage()
        {
            List<PackagePartDefinition> definitions = PackagePartDefinition.Sort(this.packagePartDefinitions);
            PackagePartDefinition workbookDefinition = definitions.First(p => p.OrderNumber == PackagePartDefinition.WORKBOOK_PACKAGE_PART_INDEX);
            PackagePart workbookPart = CreateRootPackagePart(workbookDefinition.Path, workbookDefinition.ContentType, workbookDefinition.RelationshipType);
            foreach (PackagePartDefinition definition in definitions)
            {
                if (definition.OrderNumber == PackagePartDefinition.WORKBOOK_PACKAGE_PART_INDEX)
                {
                    continue;
                }
                if (definition.PartType == PackagePartType.Root)
                {
                    CreateRootPackagePart(definition.Path, definition.ContentType, definition.RelationshipType);
                }
                else
                {
                    CreateXlPackagePart(workbookPart, definition.Path, definition.ContentType, definition.RelationshipType);
                    if (definition.PartType == PackagePartType.Worksheet)
                    {
                        worksheetPaths.Add(definition.GetWorksheetIndex(), definition.Path);
                    }
                }
            }
        }

        internal PackagePart CreateRootPackagePart(DocumentPath documentPath, string contentType, string relationshipType)
        {
            Uri uri = new Uri(documentPath.GetFullPath(), UriKind.Relative);
            PackagePart part = this.package.CreatePart(uri, contentType, CompressionOption.Normal);
            if (!packageParts.ContainsKey(documentPath.Path))
            {
                packageParts.Add(documentPath.Path, new Dictionary<string, PackagePart>());
            }
            packageParts[documentPath.Path].Add(documentPath.Filename, part);
            this.package.CreateRelationship(uri, TargetMode.Internal, relationshipType, "rId" + ParserUtils.ToString(rootPackageIndex));
            rootPackageIndex++;
            return part;
        }

        internal void CreateXlPackagePart(PackagePart parentPart, DocumentPath documentPath, string contentType, string relationshipType)
        {
            Uri uri = new Uri(documentPath.GetFullPath(), UriKind.Relative);
            PackagePart part = this.package.CreatePart(uri, contentType, CompressionOption.Normal);
            if (!packageParts.ContainsKey(documentPath.Path))
            {
                packageParts.Add(documentPath.Path, new Dictionary<string, PackagePart>());
            }
            packageParts[documentPath.Path].Add(documentPath.Filename, part);
            parentPart.CreateRelationship(uri, TargetMode.Internal, relationshipType, "rId" + ParserUtils.ToString(xlPackageIndex));
            xlPackageIndex++;
        }

        internal void RegisterPackagePart(PackagePartDefinition.PackagePartType type, int orderNumber, string fileNameInPackage, string pathInPackage, string contentType, string relationshipType)
        {
            this.packagePartDefinitions.Add(new PackagePartDefinition(type, orderNumber, fileNameInPackage, pathInPackage, contentType, relationshipType));
        }

        internal void RegisterPackagePart(PackagePartType type, int orderNumber, DocumentPath documentPath, string contentType, string relationshipType)
        {
            this.packagePartDefinitions.Add(new PackagePartDefinition(type, orderNumber, documentPath, contentType, relationshipType));
        }

        public void SaveAsStream(Stream stream, bool leaveOpen = false)
        {
            Workbook.ResolveMergedCells();
            this.Styles = StyleManager.GetManagedStyles(Workbook);
            try
            {
                HandlePackageRegistryQueuePlugIns();
                HandleQueuePlugIns(PlugInUUID.WriterPrependingQueue);
 
                RegisterCommonPackageParts();
                using (Package xlsxPackage = Package.Open(stream, FileMode.Create))
                {
                    this.package = xlsxPackage;
                    PreparePackage();
                    PackagePart part;
 
                    // Workbook
                    IPlugInWriter workbookWriter = PlugInLoader.GetPlugIn<IPlugInWriter>(PlugInUUID.WorkbookWriter, new WorkbookWriter());
                    workbookWriter.Init(this);
                    workbookWriter.Execute();
                    part = packageParts[WORKBOOK.Path][WORKBOOK.Filename];
                    AppendXmlToPackagePart(workbookWriter.XmlElement, part);
 
                    // Style
                    IPlugInWriter styleWriter = PlugInLoader.GetPlugIn<IPlugInWriter>(PlugInUUID.StyleWriter, new StyleWriter());
                    styleWriter.Init(this);
                    styleWriter.Execute();
                    part = packageParts[STYLES.Path][STYLES.Filename];
                    AppendXmlToPackagePart(styleWriter.XmlElement, part);
 
                    // Shared strings - preparation
                    SharedStringWriter = PlugInLoader.GetPlugIn<ISharedStringWriter>(PlugInUUID.SharedStringsWriter, new SharedStringWriter());
                    SharedStringWriter.Init(this);
                    // Worksheets
                    IWorksheetWriter worksheetWriter = PlugInLoader.GetPlugIn<IWorksheetWriter>(PlugInUUID.WorksheetWriter, new WorksheetWriter());
                    worksheetWriter.Init(this);
                    if (Workbook.Worksheets.Count > 0)
                    {
                        for (int i = 0; i < Workbook.Worksheets.Count; i++)
                        {
                            Worksheet item = Workbook.Worksheets[i];
                            part = packageParts[worksheetPaths[i].Path][worksheetPaths[i].Filename];
                            worksheetWriter.CurrentWorksheet = item;
                            worksheetWriter.Execute();
                            AppendXmlToPackagePart(worksheetWriter.XmlElement, part);
                        }
                    }
                    else
                    {
                        part = packageParts[worksheetPaths[0].Path][worksheetPaths[0].Filename];
                        worksheetWriter.CurrentWorksheet = new Worksheet("sheet1");
                        worksheetWriter.Execute();
                        AppendXmlToPackagePart(worksheetWriter.XmlElement, part);
                    }
 
                    // Shared strings - write after collection of strings
                    part = packageParts[SHARED_STRINGS.Path][SHARED_STRINGS.Filename];
                    SharedStringWriter.Execute();
                    AppendXmlToPackagePart(SharedStringWriter.XmlElement, part);
 
                    // Metadata
                    if (this.Workbook.WorkbookMetadata != null)
                    {
                        IPlugInWriter metadataAppWriter = PlugInLoader.GetPlugIn<IPlugInWriter>(PlugInUUID.MetadataAppWriter, new MetadataAppWriter());
                        metadataAppWriter.Init(this);
                        metadataAppWriter.Execute();
                        part = packageParts[APP_PROPERTIES.Path][APP_PROPERTIES.Filename];
                        AppendXmlToPackagePart(metadataAppWriter.XmlElement, part);
                        IPlugInWriter metadataCoreWriter = PlugInLoader.GetPlugIn<IPlugInWriter>(PlugInUUID.MetadataCoreWriter, new MetadataCoreWriter());
                        metadataCoreWriter.Init(this);
                        metadataCoreWriter.Execute();
                        part = packageParts[CORE_PROPERTIES.Path][CORE_PROPERTIES.Filename];
                        AppendXmlToPackagePart(metadataCoreWriter.XmlElement, part);
                    }
 
                    // Theme
                    if (Workbook.WorkbookTheme != null)
                    {
                        IPlugInWriter themeWriter = PlugInLoader.GetPlugIn<IPlugInWriter>(PlugInUUID.ThemeWriter, new ThemeWriter());
                        themeWriter.Init(this);
                        themeWriter.Execute();
                        part = packageParts[THEME.Path][THEME.Filename];
                        AppendXmlToPackagePart(themeWriter.XmlElement, part);
                    }
 
                    HandleQueuePlugIns(PlugInUUID.WriterAppendingQueue);
 
                    this.package.Flush();
                    this.package.Close();
                    if (!leaveOpen)
                    {
                        stream.Close();
                    }
 
                }
            }
            catch (Exception e)
            {
                throw new IOException("An error occurred while saving. See inner exception for details: " + e.Message, e);
            }
        }

        public async Task SaveAsStreamAsync(Stream stream, bool leaveOpen = false)
        {
            await Task.Run(() => { SaveAsStream(stream, leaveOpen); });
        }
        #endregion

        private void HandleQueuePlugIns(string queueUuid)
        {
            IPlugInWriter queueWriter;
            string lastUuid = null;
            do
            {
                queueWriter = PlugInLoader.GetNextQueuePlugIn<IPlugInWriter>(queueUuid, lastUuid, out string currentUuid);
                if (queueWriter != null)
                {
                    queueWriter.Init(this);
                    queueWriter.Execute();
                    if (queueWriter is IPlugInPackageWriter packageWriter)
                    {
                        if (!string.IsNullOrEmpty(packageWriter.PackagePartPath) && !string.IsNullOrEmpty(packageWriter.PackagePartFileName))
                        {
                            if (packageParts.ContainsKey(packageWriter.PackagePartPath) && packageParts[packageWriter.PackagePartPath].ContainsKey(packageWriter.PackagePartFileName))
                            {
                                PackagePart pp = packageParts[packageWriter.PackagePartPath][packageWriter.PackagePartFileName];
                                AppendXmlToPackagePart(packageWriter.XmlElement, pp);
                            }
                        }
                    }
                    lastUuid = currentUuid;
                }
                else
                {
                    lastUuid = null;
                }
 
            } while (queueWriter != null);
        }

        private void HandlePackageRegistryQueuePlugIns()
        {
            IPlugInPackageWriter queueWriter;
            string lastUuid = null;
            do
            {
                queueWriter = PlugInLoader.GetNextQueuePlugIn<IPlugInPackageWriter>(PlugInUUID.WriterPackageRegistryQueue, lastUuid, out string currentUuid);
                if (queueWriter != null)
                {
                    queueWriter.Execute(); // Execute anything that could be defined
                    PackagePartType packagePartType;
                    if (queueWriter.IsRootPackagePart)
                    {
                        packagePartType = PackagePartType.Root;
                    }
                    else
                    {
                        packagePartType = PackagePartType.Other;
                    }
                    RegisterPackagePart(packagePartType, queueWriter.OrderNumber, new DocumentPath(queueWriter.PackagePartFileName, queueWriter.PackagePartPath), queueWriter.ContentType, queueWriter.RelationshipType);
                    lastUuid = currentUuid;
                }
                else
                {
                    lastUuid = null;
                }
 
            } while (queueWriter != null);
        }

        private void AppendXmlToPackagePart(XmlElement rootElement, PackagePart pp)
        {
            XmlDocument doc = rootElement.TransformToDocument(); // This creates a System.Xml.XmlDocument from a custom XmlElement instance
            using (MemoryStream ms = new MemoryStream())
            {
                XmlWriterSettings settings = new XmlWriterSettings
                {
                    Encoding = new UTF8Encoding(false), // No BOM
                    Indent = true,
                    OmitXmlDeclaration = false // Include <?xml version="1.0" encoding="utf-8"?>
                };
 
                using (XmlWriter writer = XmlWriter.Create(ms, settings))
                {
                    writer.WriteProcessingInstruction("xml", "version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"");
                    doc.WriteTo(writer);
                    writer.Flush();
                }
 
                AddStreamToPackagePart(ms, pp);
            }
        }

        internal void AddStreamToPackagePart(MemoryStream stream, PackagePart pp)
        {
            stream.Position = 0;
            stream.CopyTo(pp.GetStream());
            stream.Flush();
        }
 
    }
}