Internal/Readers/WorkbookReader.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 © 2026
 * 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 System;
using System.IO;
using System.Xml;
using NanoXLSX.Exceptions;
using NanoXLSX.Interfaces;
using NanoXLSX.Interfaces.Reader;
using NanoXLSX.Registry;
using NanoXLSX.Registry.Attributes;
using NanoXLSX.Utils;
using NanoXLSX.Utils.Xml;
using static NanoXLSX.Enums.Password;
using IOException = NanoXLSX.Exceptions.IOException;
 
namespace NanoXLSX.Internal.Readers
{
    [NanoXlsxPlugIn(PlugInUUID = PlugInUUID.WorkbookReader)]
    public partial class WorkbookReader : IDocumentReader
    {
        private Stream stream;
        private IPasswordReader passwordReader;
        // private ReaderOptions readerOptions;
 
        #region properties
        public virtual string DocumentType { get { return @"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"; } }

        public Workbook Workbook { get; set; }
        public IOptions Options { get; set; }
        public Action<Stream, Workbook, string, IOptions, int?> InlinePluginHandler { get; set; }
        #endregion
 
        #region constructors
        internal WorkbookReader()
        {
        }
        #endregion
 
        #region methods
        public void Init(Stream stream, Workbook workbook, IOptions readerOptions, Action<Stream, Workbook, string, IOptions, int?> inlinePluginHandler)
        {
            this.stream = stream;
            this.Workbook = workbook;
            this.Options = readerOptions;
            this.InlinePluginHandler = inlinePluginHandler;
            this.passwordReader = PlugInLoader.GetPlugIn<IPasswordReader>(PlugInUUID.PasswordReader, new LegacyPasswordReader());
            this.passwordReader.Init(PasswordType.WorkbookProtection, (ReaderOptions)readerOptions);
        }

        public void Execute()
        {
            try
            {
                using (stream) // Close after processing
                {
                    using (XmlReader reader = XmlReader.Create(stream, XmlStreamUtils.CreateSettings()))
                    {
                        while (reader.Read())
                        {
                            if (reader.NodeType != XmlNodeType.Element)
                            {
                                continue;
                            }
                            if (XmlStreamUtils.IsElement(reader, "sheets"))
                            {
                                GetWorksheetInformation(reader);
                            }
                            else if (XmlStreamUtils.IsElement(reader, "bookViews"))
                            {
                                GetViewInformation(reader);
                            }
                            else if (XmlStreamUtils.IsElement(reader, "workbookProtection"))
                            {
                                GetProtectionInformation(reader);
                            }
                            else if (XmlStreamUtils.IsElement(reader, "definedNames"))
                            {
                                GetDefinedNamesInformation(reader);
                            }
                        }
                        InlinePluginHandler?.Invoke(stream, Workbook, PlugInUUID.WorkbookInlineReader, Options, null);
                    }
                }
            }
            catch (NotSupportedContentException)
            {
                throw; // rethrow
            }
            catch (Exception ex)
            {
                throw new IOException("The XML entry could not be read from the input stream. Please see the inner exception:", ex);
            }
        }

        private void GetProtectionInformation(XmlReader reader)
        {
            bool lockStructure = false;
            bool lockWindows = false;
            string attribute = reader.GetAttribute("lockWindows");
            if (attribute != null)
            {
                lockWindows = ParserUtils.ParseBinaryBool(attribute) == 1;
            }
            attribute = reader.GetAttribute("lockStructure");
            if (attribute != null)
            {
                lockStructure = ParserUtils.ParseBinaryBool(attribute) == 1;
            }
            Workbook.SetWorkbookProtection(true, lockWindows, lockStructure, null);
            string outerXml;
            using (XmlReader subtree = reader.ReadSubtree())
            {
                subtree.MoveToContent();
                outerXml = subtree.ReadOuterXml();
            }
            XmlDocument miniDoc = new XmlDocument { XmlResolver = null };
            miniDoc.LoadXml(outerXml);
            passwordReader.ReadXmlAttributes(miniDoc.DocumentElement);
            if (passwordReader.PasswordIsSet())
            {
                Workbook.WorkbookProtectionPassword.CopyFrom(passwordReader);
            }
        }

        private void GetDefinedNamesInformation(XmlReader reader)
        {
            int index = 0;
            using (XmlReader subtree = reader.ReadSubtree())
            {
                subtree.Read(); // consume the definedNames open tag
                while (subtree.Read())
                {
                    if (!XmlStreamUtils.IsElement(subtree, "definedName"))
                    {
                        continue;
                    }
                    DefinedNameDefinition definition = new DefinedNameDefinition
                    {
                        Name = subtree.GetAttribute("name"),
                        Comment = subtree.GetAttribute("comment")
                    };
                    string localSheetId = subtree.GetAttribute("localSheetId");
                    if (!string.IsNullOrEmpty(localSheetId))
                    {
                        definition.LocalSheetId = ParserUtils.ParseInt(localSheetId);
                    }
                    definition.Reference = ReadDefinedNameReference(subtree);
                    Workbook.AuxiliaryData.SetData(PlugInUUID.WorkbookReader, PlugInUUID.DefinedNameEntity, index, definition);
                    index++;
                }
            }
        }

        internal static string ReadDefinedNameReference(XmlReader reader)
        {
            if (reader.IsEmptyElement)
            {
                return string.Empty;
            }
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.EndElement)
                {
                    break;
                }
                if (reader.NodeType == XmlNodeType.Text || reader.NodeType == XmlNodeType.CDATA || reader.NodeType == XmlNodeType.SignificantWhitespace)
                {
                    sb.Append(reader.Value);
                }
            }
            return sb.ToString();
        }

        private void GetViewInformation(XmlReader reader)
        {
            using (XmlReader subtree = reader.ReadSubtree())
            {
                subtree.Read(); // consume the bookViews open tag
                while (subtree.Read())
                {
                    if (!XmlStreamUtils.IsElement(subtree, "workbookView"))
                    {
                        continue;
                    }
                    string attribute = subtree.GetAttribute("visibility");
                    if (attribute != null && ParserUtils.ToLower(attribute) == "hidden")
                    {
                        Workbook.Hidden = true;
                    }
                    attribute = subtree.GetAttribute("activeTab");
                    if (!string.IsNullOrEmpty(attribute))
                    {
                        Workbook.AuxiliaryData.SetData(PlugInUUID.WorkbookReader, PlugInUUID.SelectedWorksheetEntity, ParserUtils.ParseInt(attribute));
                    }
                }
            }
        }

        private void GetWorksheetInformation(XmlReader reader)
        {
            int visibleWorksheetOrder = 0;
            using (XmlReader subtree = reader.ReadSubtree())
            {
                subtree.Read(); // consume the sheets open tag
                while (subtree.Read())
                {
                    if (!XmlStreamUtils.IsElement(subtree, "sheet"))
                    {
                        continue;
                    }
                    try
                    {
                        string sheetName = subtree.GetAttribute("name") ?? "worksheet1";
                        int id = ParserUtils.ParseInt(subtree.GetAttribute("sheetId")); // null will rightly throw
                        string relId = subtree.GetAttribute("r:id");
                        string state = subtree.GetAttribute("state");
                        bool hidden = state != null && ParserUtils.ToLower(state) == "hidden";
                        WorksheetDefinition definition = new WorksheetDefinition(id, sheetName, relId)
                        {
                            Hidden = hidden
                        };
                        Workbook.AuxiliaryData.SetData(PlugInUUID.WorkbookReader, PlugInUUID.WorksheetDefinitionEntity, visibleWorksheetOrder, definition);
                        visibleWorksheetOrder++;
                    }
                    catch (Exception e)
                    {
                        throw new IOException("The workbook information could not be resolved. Please see the inner exception:", e);
                    }
                }
            }
        }
        #endregion
    }
}