| using System; | |
| using System.Collections.Generic; | |
| using System.IO; | |
| using System.Threading.Tasks; | |
| using System.Xml.Linq; | |
| using VersOne.Epub.Environment; | |
| using VersOne.Epub.Options; | |
| using VersOne.Epub.Schema; | |
| using VersOne.Epub.Utils; | |
| namespace VersOne.Epub.Internal | |
| { | |
| internal class PackageReader | |
| { | |
| private readonly EpubReaderOptions epubReaderOptions; | |
| public PackageReader(EpubReaderOptions? epubReaderOptions = null) | |
| { | |
| this.epubReaderOptions = epubReaderOptions ?? new EpubReaderOptions(); | |
| } | |
| public async Task<EpubPackage> ReadPackageAsync(IZipFile epubFile, string rootFilePath) | |
| { | |
| IZipFileEntry? rootFileEntry = epubFile.GetEntry(rootFilePath) ?? throw new EpubContainerException("EPUB parsing error: root file not found in the EPUB file."); | |
| XDocument containerDocument; | |
| using (Stream containerStream = rootFileEntry.Open()) | |
| { | |
| containerDocument = await XmlUtils.LoadDocumentAsync(containerStream, epubReaderOptions.XmlReaderOptions).ConfigureAwait(false); | |
| } | |
| XNamespace opfNamespace = "http://www.idpf.org/2007/opf"; | |
| XElement packageNode = containerDocument.Element(opfNamespace + "package") ?? | |
| throw new EpubPackageException("EPUB parsing error: package XML element not found in the package file."); | |
| string? uniqueIdentifier = null; | |
| string? epubVersionString = null; | |
| string? id = null; | |
| EpubTextDirection? textDirection = null; | |
| string? prefix = null; | |
| string? language = null; | |
| foreach (XAttribute packageNodeAttribute in packageNode.Attributes()) | |
| { | |
| string attributeValue = packageNodeAttribute.Value; | |
| switch (packageNodeAttribute.GetLowerCaseLocalName()) | |
| { | |
| case "unique-identifier": | |
| uniqueIdentifier = attributeValue; | |
| break; | |
| case "version": | |
| epubVersionString = attributeValue; | |
| break; | |
| case "id": | |
| id = attributeValue; | |
| break; | |
| case "dir": | |
| textDirection = EpubTextDirectionParser.Parse(attributeValue); | |
| break; | |
| case "prefix": | |
| prefix = attributeValue; | |
| break; | |
| case "lang": | |
| language = attributeValue; | |
| break; | |
| } | |
| } | |
| if (epubVersionString == null) | |
| { | |
| throw new EpubPackageException("EPUB parsing error: EPUB version is not specified in the package."); | |
| } | |
| EpubVersion epubVersion = epubVersionString switch | |
| { | |
| "2.0" => EpubVersion.EPUB_2, | |
| "3.0" => EpubVersion.EPUB_3, | |
| "3.1" => EpubVersion.EPUB_3_1, | |
| _ => throw new EpubPackageException($"Unsupported EPUB version: \"{epubVersionString}\".") | |
| }; | |
| XElement metadataNode = packageNode.Element(opfNamespace + "metadata") ?? throw new EpubPackageException("EPUB parsing error: metadata not found in the package."); | |
| EpubMetadata metadata = MetadataReader.ReadMetadata(metadataNode); | |
| XElement manifestNode = packageNode.Element(opfNamespace + "manifest") ?? throw new EpubPackageException("EPUB parsing error: manifest not found in the package."); | |
| EpubManifest manifest = ReadManifest(manifestNode, epubReaderOptions.PackageReaderOptions); | |
| XElement spineNode = packageNode.Element(opfNamespace + "spine") ?? throw new EpubPackageException("EPUB parsing error: spine not found in the package."); | |
| EpubSpine spine = ReadSpine(spineNode, epubVersion, epubReaderOptions.PackageReaderOptions); | |
| EpubGuide? guide = null; | |
| XElement guideNode = packageNode.Element(opfNamespace + "guide"); | |
| if (guideNode != null) | |
| { | |
| guide = ReadGuide(guideNode); | |
| } | |
| List<EpubCollection> collections = ReadCollections(packageNode); | |
| return new(uniqueIdentifier, epubVersion, metadata, manifest, spine, guide, collections, id, textDirection, prefix, language); | |
| } | |
| private static EpubManifest ReadManifest(XElement manifestNode, PackageReaderOptions packageReaderOptions) | |
| { | |
| XAttribute? manifestIdAttribute = manifestNode.Attribute("id"); | |
| string? manifestId = manifestIdAttribute?.Value; | |
| List<EpubManifestItem> items = new(); | |
| HashSet<string> manifestItemIds = new(); | |
| HashSet<string> manifestItemHrefs = new(); | |
| foreach (XElement manifestItemNode in manifestNode.Elements()) | |
| { | |
| if (manifestItemNode.CompareNameTo("item")) | |
| { | |
| string? manifestItemId = null; | |
| string? href = null; | |
| string? mediaType = null; | |
| string? mediaOverlay = null; | |
| string? requiredNamespace = null; | |
| string? requiredModules = null; | |
| string? fallback = null; | |
| string? fallbackStyle = null; | |
| List<EpubManifestProperty>? properties = null; | |
| foreach (XAttribute manifestItemNodeAttribute in manifestItemNode.Attributes()) | |
| { | |
| string attributeValue = manifestItemNodeAttribute.Value; | |
| switch (manifestItemNodeAttribute.GetLowerCaseLocalName()) | |
| { | |
| case "id": | |
| manifestItemId = attributeValue; | |
| break; | |
| case "href": | |
| href = Uri.UnescapeDataString(attributeValue); | |
| break; | |
| case "media-type": | |
| mediaType = attributeValue; | |
| break; | |
| case "media-overlay": | |
| mediaOverlay = attributeValue; | |
| break; | |
| case "required-namespace": | |
| requiredNamespace = attributeValue; | |
| break; | |
| case "required-modules": | |
| requiredModules = attributeValue; | |
| break; | |
| case "fallback": | |
| fallback = attributeValue; | |
| break; | |
| case "fallback-style": | |
| fallbackStyle = attributeValue; | |
| break; | |
| case "properties": | |
| properties = EpubManifestPropertyParser.ParsePropertyList(attributeValue); | |
| break; | |
| } | |
| } | |
| if (manifestItemId == null) | |
| { | |
| if (packageReaderOptions != null && packageReaderOptions.SkipInvalidManifestItems) | |
| { | |
| continue; | |
| } | |
| throw new EpubPackageException("Incorrect EPUB manifest: item ID is missing."); | |
| } | |
| if (href == null) | |
| { | |
| if (packageReaderOptions != null && packageReaderOptions.SkipInvalidManifestItems) | |
| { | |
| continue; | |
| } | |
| throw new EpubPackageException("Incorrect EPUB manifest: item href is missing."); | |
| } | |
| if (mediaType == null) | |
| { | |
| if (packageReaderOptions != null && packageReaderOptions.SkipInvalidManifestItems) | |
| { | |
| continue; | |
| } | |
| throw new EpubPackageException("Incorrect EPUB manifest: item media type is missing."); | |
| } | |
| if (manifestItemIds.Contains(manifestItemId)) | |
| { | |
| throw new EpubPackageException($"Incorrect EPUB manifest: item with ID = \"{manifestItemId}\" is not unique."); | |
| } | |
| manifestItemIds.Add(manifestItemId); | |
| if (manifestItemHrefs.Contains(href)) | |
| { | |
| throw new EpubPackageException($"Incorrect EPUB manifest: item with href = \"{href}\" is not unique."); | |
| } | |
| manifestItemHrefs.Add(href); | |
| items.Add(new EpubManifestItem(manifestItemId, href, mediaType, mediaOverlay, requiredNamespace, requiredModules, fallback, fallbackStyle, properties)); | |
| } | |
| } | |
| return new(manifestId, items); | |
| } | |
| private static EpubSpine ReadSpine(XElement spineNode, EpubVersion epubVersion, PackageReaderOptions packageReaderOptions) | |
| { | |
| string? spineId = null; | |
| EpubPageProgressionDirection? pageProgressionDirection = null; | |
| string? toc = null; | |
| List<EpubSpineItemRef> items = new(); | |
| foreach (XAttribute spineNodeAttribute in spineNode.Attributes()) | |
| { | |
| string attributeValue = spineNodeAttribute.Value; | |
| switch (spineNodeAttribute.GetLowerCaseLocalName()) | |
| { | |
| case "id": | |
| spineId = attributeValue; | |
| break; | |
| case "page-progression-direction": | |
| pageProgressionDirection = EpubPageProgressionDirectionParser.Parse(attributeValue); | |
| break; | |
| case "toc": | |
| toc = attributeValue; | |
| break; | |
| } | |
| } | |
| if (epubVersion == EpubVersion.EPUB_2 && String.IsNullOrWhiteSpace(toc) && (packageReaderOptions == null || !packageReaderOptions.IgnoreMissingToc)) | |
| { | |
| throw new EpubPackageException("Incorrect EPUB spine: TOC is missing."); | |
| } | |
| foreach (XElement spineItemNode in spineNode.Elements()) | |
| { | |
| if (spineItemNode.CompareNameTo("itemref")) | |
| { | |
| string? spineItemRefId = null; | |
| string? idRef = null; | |
| bool isLinear; | |
| List<EpubSpineProperty>? properties = null; | |
| foreach (XAttribute spineItemNodeAttribute in spineItemNode.Attributes()) | |
| { | |
| string attributeValue = spineItemNodeAttribute.Value; | |
| switch (spineItemNodeAttribute.GetLowerCaseLocalName()) | |
| { | |
| case "id": | |
| spineItemRefId = attributeValue; | |
| break; | |
| case "idref": | |
| idRef = attributeValue; | |
| break; | |
| case "properties": | |
| properties = EpubSpinePropertyParser.ParsePropertyList(attributeValue); | |
| break; | |
| } | |
| } | |
| if (idRef == null) | |
| { | |
| throw new EpubPackageException("Incorrect EPUB spine: item ID ref is missing."); | |
| } | |
| XAttribute linearAttribute = spineItemNode.Attribute("linear"); | |
| isLinear = linearAttribute == null || !linearAttribute.CompareValueTo("no"); | |
| items.Add(new EpubSpineItemRef(spineItemRefId, idRef, isLinear, properties)); | |
| } | |
| } | |
| return new(spineId, pageProgressionDirection, toc, items); | |
| } | |
| private static EpubGuide ReadGuide(XElement guideNode) | |
| { | |
| List<EpubGuideReference> items = new(); | |
| foreach (XElement guideReferenceNode in guideNode.Elements()) | |
| { | |
| if (guideReferenceNode.CompareNameTo("reference")) | |
| { | |
| string? type = null; | |
| string? title = null; | |
| string? href = null; | |
| foreach (XAttribute guideReferenceNodeAttribute in guideReferenceNode.Attributes()) | |
| { | |
| string attributeValue = guideReferenceNodeAttribute.Value; | |
| switch (guideReferenceNodeAttribute.GetLowerCaseLocalName()) | |
| { | |
| case "type": | |
| type = attributeValue; | |
| break; | |
| case "title": | |
| title = attributeValue; | |
| break; | |
| case "href": | |
| href = Uri.UnescapeDataString(attributeValue); | |
| break; | |
| } | |
| } | |
| if (type == null) | |
| { | |
| throw new EpubPackageException("Incorrect EPUB guide: item type is missing."); | |
| } | |
| if (href == null) | |
| { | |
| throw new EpubPackageException("Incorrect EPUB guide: item href is missing."); | |
| } | |
| items.Add(new EpubGuideReference(type, title, href)); | |
| } | |
| } | |
| return new(items); | |
| } | |
| private static List<EpubCollection> ReadCollections(XElement packageNode) | |
| { | |
| List<EpubCollection> result = new(); | |
| foreach (XElement collectionNode in packageNode.Elements(packageNode.Name.Namespace + "collection")) | |
| { | |
| result.Add(ReadCollection(collectionNode)); | |
| } | |
| return result; | |
| } | |
| private static EpubCollection ReadCollection(XElement collectionNode) | |
| { | |
| string? role = null; | |
| string? id = null; | |
| EpubTextDirection? textDirection = null; | |
| string? language = null; | |
| foreach (XAttribute collectionNodeAttribute in collectionNode.Attributes()) | |
| { | |
| string attributeValue = collectionNodeAttribute.Value; | |
| switch (collectionNodeAttribute.GetLowerCaseLocalName()) | |
| { | |
| case "role": | |
| role = attributeValue; | |
| break; | |
| case "id": | |
| id = attributeValue; | |
| break; | |
| case "dir": | |
| textDirection = EpubTextDirectionParser.Parse(attributeValue); | |
| break; | |
| case "lang": | |
| language = attributeValue; | |
| break; | |
| } | |
| } | |
| if (role == null) | |
| { | |
| throw new EpubPackageException("Incorrect EPUB collection: collection role is missing."); | |
| } | |
| EpubMetadata? metadata = null; | |
| List<EpubCollection> nestedCollections = new(); | |
| List<EpubMetadataLink> links = new(); | |
| foreach (XElement collectionChildNode in collectionNode.Elements()) | |
| { | |
| switch (collectionChildNode.GetLowerCaseLocalName()) | |
| { | |
| case "metadata": | |
| metadata = MetadataReader.ReadMetadata(collectionChildNode); | |
| break; | |
| case "collection": | |
| EpubCollection nestedCollection = ReadCollection(collectionChildNode); | |
| nestedCollections.Add(nestedCollection); | |
| break; | |
| case "link": | |
| EpubMetadataLink link = MetadataReader.ReadLink(collectionChildNode); | |
| links.Add(link); | |
| break; | |
| } | |
| } | |
| return new(role, metadata, nestedCollections, links, id, textDirection, language); | |
| } | |
| } | |
| } | |