Merge branch 'master' into mf/rssInboundManager

server/utils/fileUtils.js

@@ -1,6 +1,7 @@
 const axios = require('axios')
 const Path = require('path')
 const ssrfFilter = require('ssrf-req-filter')
+const exec = require('child_process').exec
 const fs = require('../libs/fsExtra')
 const rra = require('../libs/recursiveReaddirAsync')
 const Logger = require('../Logger')
@@ -378,3 +379,65 @@ module.exports.isWritable = async (directory) => {
   }
 }
 
+/**
+ * Get Windows drives as array e.g. ["C:/", "F:/"]
+ * 
+ * @returns {Promise<string[]>}
+ */
+module.exports.getWindowsDrives = async () => {
+  if (!global.isWin) {
+    return []
+  }
+  return new Promise((resolve, reject) => {
+    exec('wmic logicaldisk get name', async (error, stdout, stderr) => {
+      if (error) {
+        reject(error)
+        return
+      }
+      let drives = stdout?.split(/\r?\n/).map(line => line.trim()).filter(line => line).slice(1)
+      const validDrives = []
+      for (const drive of drives) {
+        let drivepath = drive + '/'
+        if (await fs.pathExists(drivepath)) {
+          validDrives.push(drivepath)
+        } else {
+          Logger.error(`Invalid drive ${drivepath}`)
+        }
+      }
+      resolve(validDrives)
+    })
+  })
+}
+
+/**
+ * Get array of directory paths in a directory
+ * 
+ * @param {string} dirPath 
+ * @param {number} level
+ * @returns {Promise<{ path:string, dirname:string, level:number }[]>}
+ */
+module.exports.getDirectoriesInPath = async (dirPath, level) => {
+  try {
+    const paths = await fs.readdir(dirPath)
+    let dirs = await Promise.all(paths.map(async dirname => {
+      const fullPath = Path.join(dirPath, dirname)
+
+      const lstat = await fs.lstat(fullPath).catch((error) => {
+        Logger.debug(`Failed to lstat "${fullPath}"`, error)
+        return null
+      })
+      if (!lstat?.isDirectory()) return null
+
+      return {
+        path: this.filePathToPOSIX(fullPath),
+        dirname,
+        level
+      }
+    }))
+    dirs = dirs.filter(d => d)
+    return dirs
+  } catch (error) {
+    Logger.error('Failed to readdir', dirPath, error)
+    return []
+  }
+}

server/utils/generators/opmlGenerator.js

@@ -1,4 +1,5 @@
 const xml = require('../../libs/xml')
+const escapeForXML = require('../../libs/xml/escapeForXML')
 
 /**
  * Generate OPML file string for podcasts in a library
@@ -12,18 +13,18 @@ module.exports.generate = (podcasts, indent = true) => {
     if (!podcast.feedURL) return
     const feedAttributes = {
       type: 'rss',
-      text: podcast.title,
-      title: podcast.title,
-      xmlUrl: podcast.feedURL
+      text: escapeForXML(podcast.title),
+      title: escapeForXML(podcast.title),
+      xmlUrl: escapeForXML(podcast.feedURL)
     }
     if (podcast.description) {
-      feedAttributes.description = podcast.description
+      feedAttributes.description = escapeForXML(podcast.description)
     }
     if (podcast.itunesPageUrl) {
-      feedAttributes.htmlUrl = podcast.itunesPageUrl
+      feedAttributes.htmlUrl = escapeForXML(podcast.itunesPageUrl)
     }
     if (podcast.language) {
-      feedAttributes.language = podcast.language
+      feedAttributes.language = escapeForXML(podcast.language)
     }
     bodyItems.push({
       outline: {

server/utils/parsers/parseEbookMetadata.js

@@ -0,0 +1,42 @@
+const parseEpubMetadata = require('./parseEpubMetadata')
+
+/**
+ * @typedef EBookFileScanData
+ * @property {string} path
+ * @property {string} ebookFormat
+ * @property {string} ebookCoverPath internal image path
+ * @property {import('../../scanner/BookScanner').BookMetadataObject} metadata
+ */
+
+/**
+ * Parse metadata from ebook file
+ * 
+ * @param {import('../../models/Book').EBookFileObject} ebookFile 
+ * @returns {Promise<EBookFileScanData>}
+ */
+async function parse(ebookFile) {
+  if (!ebookFile) return null
+
+  if (ebookFile.ebookFormat === 'epub') {
+    return parseEpubMetadata.parse(ebookFile.metadata.path)
+  }
+  return null
+}
+module.exports.parse = parse
+
+/**
+ * Extract cover from ebook file
+ * 
+ * @param {EBookFileScanData} ebookFileScanData 
+ * @param {string} outputCoverPath 
+ * @returns {Promise<boolean>}
+ */
+async function extractCoverImage(ebookFileScanData, outputCoverPath) {
+  if (!ebookFileScanData?.ebookCoverPath) return false
+
+  if (ebookFileScanData.ebookFormat === 'epub') {
+    return parseEpubMetadata.extractCoverImage(ebookFileScanData.path, ebookFileScanData.ebookCoverPath, outputCoverPath)
+  }
+  return false
+}
+module.exports.extractCoverImage = extractCoverImage

server/utils/parsers/parseEpubMetadata.js

@@ -0,0 +1,109 @@
+const Path = require('path')
+const Logger = require('../../Logger')
+const StreamZip = require('../../libs/nodeStreamZip')
+const parseOpfMetadata = require('./parseOpfMetadata')
+const { xmlToJSON } = require('../index')
+
+
+/**
+ * Extract file from epub and return string content
+ * 
+ * @param {string} epubPath 
+ * @param {string} filepath 
+ * @returns {Promise<string>}
+ */
+async function extractFileFromEpub(epubPath, filepath) {
+  const zip = new StreamZip.async({ file: epubPath })
+  const data = await zip.entryData(filepath).catch((error) => {
+    Logger.error(`[parseEpubMetadata] Failed to extract ${filepath} from epub at "${epubPath}"`, error)
+  })
+  const filedata = data?.toString('utf8')
+  await zip.close()
+  return filedata
+}
+
+/**
+ * Extract an XML file from epub and return JSON
+ * 
+ * @param {string} epubPath 
+ * @param {string} xmlFilepath 
+ * @returns {Promise<Object>}
+ */
+async function extractXmlToJson(epubPath, xmlFilepath) {
+  const filedata = await extractFileFromEpub(epubPath, xmlFilepath)
+  if (!filedata) return null
+  return xmlToJSON(filedata)
+}
+
+/**
+ * Extract cover image from epub return true if success
+ * 
+ * @param {string} epubPath 
+ * @param {string} epubImageFilepath 
+ * @param {string} outputCoverPath 
+ * @returns {Promise<boolean>}
+ */
+async function extractCoverImage(epubPath, epubImageFilepath, outputCoverPath) {
+  const zip = new StreamZip.async({ file: epubPath })
+
+  const success = await zip.extract(epubImageFilepath, outputCoverPath).then(() => true).catch((error) => {
+    Logger.error(`[parseEpubMetadata] Failed to extract image ${epubImageFilepath} from epub at "${epubPath}"`, error)
+    return false
+  })
+
+  await zip.close()
+
+  return success
+}
+module.exports.extractCoverImage = extractCoverImage
+
+/**
+ * Parse metadata from epub
+ * 
+ * @param {string} epubPath 
+ * @returns {Promise<import('./parseEbookMetadata').EBookFileScanData>}
+ */
+async function parse(epubPath) {
+  Logger.debug(`Parsing metadata from epub at "${epubPath}"`)
+  // Entrypoint of the epub that contains the filepath to the package document (opf file)
+  const containerJson = await extractXmlToJson(epubPath, 'META-INF/container.xml')
+
+  // Get package document opf filepath from container.xml
+  const packageDocPath = containerJson.container?.rootfiles?.[0]?.rootfile?.[0]?.$?.['full-path']
+  if (!packageDocPath) {
+    Logger.error(`Failed to get package doc path in Container.xml`, JSON.stringify(containerJson, null, 2))
+    return null
+  }
+
+  // Extract package document to JSON
+  const packageJson = await extractXmlToJson(epubPath, packageDocPath)
+  if (!packageJson) {
+    return null
+  }
+
+  // Parse metadata from package document opf file
+  const opfMetadata = parseOpfMetadata.parseOpfMetadataJson(packageJson)
+  if (!opfMetadata) {
+    Logger.error(`Unable to parse metadata in package doc with json`, JSON.stringify(packageJson, null, 2))
+    return null
+  }
+
+  const payload = {
+    path: epubPath,
+    ebookFormat: 'epub',
+    metadata: opfMetadata
+  }
+
+  // Attempt to find filepath to cover image
+  const manifestFirstImage = packageJson.package?.manifest?.[0]?.item?.find(item => item.$?.['media-type']?.startsWith('image/'))
+  let coverImagePath = manifestFirstImage?.$?.href
+  if (coverImagePath) {
+    const packageDirname = Path.dirname(packageDocPath)
+    payload.ebookCoverPath = Path.posix.join(packageDirname, coverImagePath)
+  } else {
+    Logger.warn(`Cover image not found in manifest for epub at "${epubPath}"`)
+  }
+
+  return payload
+}
+module.exports.parse = parse

server/utils/parsers/parseOpfMetadata.js

@@ -103,15 +103,24 @@ function fetchSeries(metadataMeta) {
   if (!metadataMeta) return []
   const result = []
   for (let i = 0; i < metadataMeta.length; i++) {
-    if (metadataMeta[i].$?.name === "calibre:series" && metadataMeta[i].$.content?.trim()) {
+    if (metadataMeta[i].$?.name === 'calibre:series' && metadataMeta[i].$.content?.trim()) {
       const name = metadataMeta[i].$.content.trim()
       let sequence = null
-      if (metadataMeta[i + 1]?.$?.name === "calibre:series_index" && metadataMeta[i + 1].$?.content?.trim()) {
+      if (metadataMeta[i + 1]?.$?.name === 'calibre:series_index' && metadataMeta[i + 1].$?.content?.trim()) {
         sequence = metadataMeta[i + 1].$.content.trim()
       }
       result.push({ name, sequence })
     }
   }
+
+  // If one series was found with no series_index then check if any series_index meta can be found
+  //   this is to support when calibre:series_index is not directly underneath calibre:series
+  if (result.length === 1 && !result[0].sequence) {
+    const seriesIndexMeta = metadataMeta.find(m => m.$?.name === 'calibre:series_index' && m.$.content?.trim())
+    if (seriesIndexMeta) {
+      result[0].sequence = seriesIndexMeta.$.content.trim()
+    }
+  }
   return result
 }
 
@@ -136,11 +145,7 @@ function stripPrefix(str) {
   return str.split(':').pop()
 }
 
-module.exports.parseOpfMetadataXML = async (xml) => {
-  const json = await xmlToJSON(xml)
-
-  if (!json) return null
-
+module.exports.parseOpfMetadataJson = (json) => {
   // Handle <package ...> or with prefix <ns0:package ...>
   const packageKey = Object.keys(json).find(key => stripPrefix(key) === 'package')
   if (!packageKey) return null
@@ -167,7 +172,7 @@ module.exports.parseOpfMetadataXML = async (xml) => {
   const creators = parseCreators(metadata)
   const authors = (fetchCreators(creators, 'aut') || []).map(au => au?.trim()).filter(au => au)
   const narrators = (fetchNarrators(creators, metadata) || []).map(nrt => nrt?.trim()).filter(nrt => nrt)
-  const data = {
+  return {
     title: fetchTitle(metadata),
     subtitle: fetchSubtitle(metadata),
     authors,
@@ -182,5 +187,10 @@ module.exports.parseOpfMetadataXML = async (xml) => {
     series: fetchSeries(metadataMeta),
     tags: fetchTags(metadata)
   }
-  return data
+}
+
+module.exports.parseOpfMetadataXML = async (xml) => {
+  const json = await xmlToJSON(xml)
+  if (!json) return null
+  return this.parseOpfMetadataJson(json)
 }

server/utils/podcastUtils.js

@@ -233,7 +233,7 @@ module.exports.getPodcastFeed = (feedUrl, excludeEpisodeMetadata = false) => {
     method: 'GET',
     timeout: 12000,
     responseType: 'arraybuffer',
-    headers: { Accept: 'application/rss+xml, application/xhtml+xml, application/xml' },
+    headers: { Accept: 'application/rss+xml, application/xhtml+xml, application/xml, */*;q=0.8' },
     httpAgent: ssrfFilter(feedUrl),
     httpsAgent: ssrfFilter(feedUrl)
   }).then(async (data) => {