ExternalLinkReader.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 NanoXLSX.Interfaces;
using NanoXLSX.Interfaces.Reader;
using NanoXLSX.Registry;
using NanoXLSX.Registry.Attributes;
using NanoXLSX.Utils;
using NanoXLSX.Utils.Xml;
using System;
using System.Collections.Generic;
using System.IO;
using System.Xml;
using IOException = NanoXLSX.Exceptions.IOException;
 
namespace NanoXLSX.Internal.Reader
{
    [NanoXlsxQueuePlugIn(PlugInUUID = "EXTERNAL_LINK_READER", QueueUUID = PlugInUUID.ReaderPrependingQueue, PlugInOrder = 20000)]
    internal class ExternalLinkReader : IDiscoveryPackageReader
    {
        #region privateFields
 
        private Stream stream;
 
        private const string ExternalLinkPathRelationshipType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/externalLinkPath";
        private const string OfficeRelationshipNamespace = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
        private const string AlternateUrlNamespace = "http://schemas.microsoft.com/office/spreadsheetml/2021/extlinks2021";
 
        #endregion
 
        #region properties
        public IOptions Options { get; set; }
        public Workbook Workbook { get; set; }
        public Action<Stream, Workbook, string, IOptions, int?> InlinePluginHandler { get; set; }

        public string StreamEntryName => null; // NoOp

        public RelationshipInfo CurrentRelationship { get; set; }

        public string DocumentType { get { return "http://schemas.openxmlformats.org/officeDocument/2006/relationships/externalLink"; } }
        #endregion
 
        #region constructors
        public ExternalLinkReader()
        {
        }
        #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;
        }

        public void Execute()
        {
            Dictionary<int, ExternalWorksheet> worksheets = new Dictionary<int, ExternalWorksheet>();
            List<ExternalDefinedName> definedNames = new List<ExternalDefinedName>();
            string targetRelationshipId = null;
            string absoluteAlternateRelationshipId = null;
            string relativeAlternateRelationshipId = null;
            try
            {
                using (XmlReader reader = XmlReader.Create(stream, XmlStreamUtils.CreateSettings()))
                {
                    bool isExternalBook = false;
                    while (reader.Read())
                    {
                        if (XmlStreamUtils.IsElement(reader, "externalBook"))
                        {
                            isExternalBook = true;
                            targetRelationshipId = reader.GetAttribute("id", OfficeRelationshipNamespace);
                        }
 
                        if (isExternalBook)
                        {
                            if (reader.NamespaceURI == AlternateUrlNamespace && XmlStreamUtils.IsElement(reader, "absoluteUrl"))
                            {
                                absoluteAlternateRelationshipId = reader.GetAttribute("id", OfficeRelationshipNamespace);
                            }
                            else if (reader.NamespaceURI == AlternateUrlNamespace && XmlStreamUtils.IsElement(reader, "relativeUrl"))
                            {
                                relativeAlternateRelationshipId = reader.GetAttribute("id", OfficeRelationshipNamespace);
                            }
                            else if (XmlStreamUtils.IsElement(reader, "sheetNames"))
                            {
                                GetSheeetNames(reader.ReadSubtree(), worksheets);
                                if (worksheets.Count == 0)
                                {
                                    throw new IOException("No cached worksheets could be determined");
                                }
                            }
                            else if (XmlStreamUtils.IsElement(reader, "sheetDataSet"))
                            {
                                GetSheetData(reader.ReadSubtree(), worksheets);
                            }
                            else if (XmlStreamUtils.IsElement(reader, "definedNames"))
                            {
                                GetDefinedNames(reader.ReadSubtree(), definedNames);
                            }
                        }
                    }
                }
                ExternalLink link = new ExternalLink();
                RelationshipCatalog discoveryCatalog = Workbook.AuxiliaryData.GetData<RelationshipCatalog>(PlugInUUID.DiscoveryReader, PlugInUUID.DiscoveryCatalogEntity);
                if (discoveryCatalog == null)
                {
                    throw new IOException("The relationship catalog is not available for the external link.");
                }
                string sourcePartPath = CurrentRelationship.ResolvedTargetPath;
                RelationshipInfo target = GetExternalLinkPathRelationship(discoveryCatalog, sourcePartPath, targetRelationshipId, "target", true);
                RelationshipInfo absoluteAlternate = GetExternalLinkPathRelationship(discoveryCatalog, sourcePartPath, absoluteAlternateRelationshipId, "absolute alternate", false);
                RelationshipInfo relativeAlternate = GetExternalLinkPathRelationship(discoveryCatalog, sourcePartPath, relativeAlternateRelationshipId, "relative alternate", false);
 
                link.SetReadUris(target.Target, absoluteAlternate?.Target, relativeAlternate?.Target);
                foreach (KeyValuePair<int, ExternalWorksheet> worksheet in worksheets)
                {
                    link.AddWorksheet(worksheet.Value);
                }
                foreach (ExternalDefinedName definedName in definedNames)
                {
                    link.AddDefinedName(definedName);
                }
                link.WorkbookRId = CurrentRelationship.Id;
 
                List<ExternalLink> externalLinks = Workbook.AuxiliaryData.GetDataList<ExternalLink>(PlugInUUID.CompatibilityInlineProcessor, CompatibilityConstants.EXTERNAL_LINK_OBJECT_ENTITY);
                int index = externalLinks.Count;
                Workbook.AuxiliaryData.SetData(PlugInUUID.CompatibilityInlineProcessor, CompatibilityConstants.EXTERNAL_LINK_OBJECT_ENTITY, index, link, true);
            }
            catch (Exception ex)
            {
                throw new IOException("The XML entry could not be read from the " + nameof(stream) + ". Please see the inner exception:", ex);
            }
        }

        private static RelationshipInfo GetExternalLinkPathRelationship(
            RelationshipCatalog catalog,
            string sourcePartPath,
            string relationshipId,
            string role,
            bool required)
        {
            if (string.IsNullOrEmpty(relationshipId))
            {
                if (required)
                {
                    throw new IOException("The external-link " + role + " relationship ID is missing.");
                }
                return null;
            }
 
            RelationshipInfo relationship = catalog.GetBySourceAndId(sourcePartPath, relationshipId);
            if (relationship == null)
            {
                throw new IOException("The external-link " + role + " relationship '" + relationshipId + "' could not be resolved.");
            }
            if (!string.Equals(relationship.Type, ExternalLinkPathRelationshipType, StringComparison.Ordinal)
                || relationship.TargetMode != System.IO.Packaging.TargetMode.External)
            {
                throw new IOException("The external-link " + role + " relationship '" + relationshipId + "' has an invalid type or target mode.");
            }
            return relationship;
        }

        private static void GetSheeetNames(XmlReader sheetNames, Dictionary<int, ExternalWorksheet> worksheets)
        {
            int index = 0;
            while (sheetNames.Read())
            {
                if (XmlStreamUtils.IsElement(sheetNames, "sheetName"))
                {
                    string val = sheetNames.GetAttribute("val");
                    ExternalWorksheet worksheet = new ExternalWorksheet(val);
                    worksheets[index] = worksheet;
                    index++;
                }
            }
        }

        private static void GetSheetData(XmlReader sheetDataSet, Dictionary<int, ExternalWorksheet> worksheets)
        {
            int currentIndex = -1;
            ExternalWorksheet currentWorksheet = null;
            while (sheetDataSet.Read())
            {
                if (XmlStreamUtils.IsElement(sheetDataSet, "sheetData"))
                {
                    string id = sheetDataSet.GetAttribute("sheetId");
                    currentIndex = ParserUtils.ParseInt(id);
                    if (!worksheets.TryGetValue(currentIndex, out currentWorksheet))
                    {
                        throw new IOException("The cached worksheet with sheet ID '" + id + "' is not defined.");
                    }
                    string refreshErrors = sheetDataSet.GetAttribute("refreshErrors");
                    if (refreshErrors != null)
                    {
                        int parserdSate = ParserUtils.ParseBinaryBool(refreshErrors);
                        currentWorksheet.RefreshErros = parserdSate == 1 ? true : false;
                    }
                    continue;
                }
                else if (XmlStreamUtils.IsElement(sheetDataSet, "row"))
                {
                    GetRowData(sheetDataSet.ReadSubtree(), currentWorksheet);
                }
            }
        }

        private static void GetDefinedNames(XmlReader definitions, List<ExternalDefinedName> definedNames)
        {
            while (definitions.Read())
            {
                if (!XmlStreamUtils.IsElement(definitions, "definedName"))
                {
                    continue;
                }
                ExternalDefinedName definedName = new ExternalDefinedName(
                    definitions.GetAttribute("name"),
                    definitions.GetAttribute("refersTo"),
                    false)
                {
                    RelationshipId = definitions.GetAttribute("sheetId")
                };
                definedNames.Add(definedName);
            }
        }

        private static void GetRowData(XmlReader row, ExternalWorksheet worksheet)
        {
            while (row.Read())
            {
                if (!XmlStreamUtils.IsElement(row, "cell"))
                {
                    continue;
                }
 
                string address = row.GetAttribute("r");
                string type = row.GetAttribute("t");
                string cellMetaData = row.GetAttribute("vm"); // Roundtrip only
                ExternalCellValue.DataType dataType = ExternalCellValue.DataType.Number;
                if (type != null)
                {
                    switch (type)
                    {
                        case "b":
                            dataType = ExternalCellValue.DataType.Boolean;
                            break;
                        case "d":
                            dataType = ExternalCellValue.DataType.Date;
                            break;
                        case "e":
                            dataType = ExternalCellValue.DataType.Error;
                            break;
                        case "s": // Should not be used
                        case "str":
                            dataType = ExternalCellValue.DataType.String;
                            break;
                    }
                }
 
                string value = null;
                if (!row.IsEmptyElement)
                {
                    using (XmlReader cell = row.ReadSubtree())
                    {
                        while (cell.Read())
                        {
                            if (XmlStreamUtils.IsElement(cell, "v"))
                            {
                                value = cell.ReadElementContentAsString();
                                break;
                            }
                        }
                    }
                }
                worksheet.AddCell(address, value, dataType, cellMetaData);
            }
        }
        #endregion
    }
 
}