Book cover uploader, moving streams to /metadata/streams, adding jwt auth from query string, auth check static metadata

server/ApiController.js

@@ -1,10 +1,13 @@
 const express = require('express')
+const Path = require('path')
+const fs = require('fs-extra')
 const Logger = require('./Logger')
 const User = require('./objects/User')
-const { isObject } = require('./utils/index')
+const { isObject, isAcceptableCoverMimeType } = require('./utils/index')
+const { CoverDestination } = require('./utils/constants')
 
 class ApiController {
-  constructor(db, scanner, auth, streamManager, rssFeeds, downloadManager, emitter, clientEmitter) {
+  constructor(MetadataPath, db, scanner, auth, streamManager, rssFeeds, downloadManager, emitter, clientEmitter) {
     this.db = db
     this.scanner = scanner
     this.auth = auth
@@ -13,6 +16,7 @@ class ApiController {
     this.downloadManager = downloadManager
     this.emitter = emitter
     this.clientEmitter = clientEmitter
+    this.MetadataPath = MetadataPath
 
     this.router = express()
     this.init()
@@ -30,6 +34,7 @@ class ApiController {
     this.router.get('/audiobook/:id', this.getAudiobook.bind(this))
     this.router.delete('/audiobook/:id', this.deleteAudiobook.bind(this))
     this.router.patch('/audiobook/:id/tracks', this.updateAudiobookTracks.bind(this))
+    this.router.post('/audiobook/:id/cover', this.uploadAudiobookCover.bind(this))
     this.router.patch('/audiobook/:id', this.updateAudiobook.bind(this))
 
     this.router.get('/metadata/:id/:trackIndex', this.getMetadata.bind(this))
@@ -217,6 +222,85 @@ class ApiController {
     res.json(audiobook.toJSON())
   }
 
+  async uploadAudiobookCover(req, res) {
+    if (!req.user.canUpload || !req.user.canUpdate) {
+      Logger.warn('User attempted to upload a cover without permission', req.user)
+      return res.sendStatus(403)
+    }
+    if (!req.files || !req.files.cover) {
+      return res.status(400).send('No files were uploaded')
+    }
+    var audiobookId = req.params.id
+    var audiobook = this.db.audiobooks.find(ab => ab.id === audiobookId)
+    if (!audiobook) {
+      return res.status(404).send('Audiobook not found')
+    }
+
+    var coverFile = req.files.cover
+    var mimeType = coverFile.mimetype
+    var extname = Path.extname(coverFile.name.toLowerCase()) || '.jpg'
+    if (!isAcceptableCoverMimeType(mimeType)) {
+      return res.status(400).send('Invalid image file type: ' + mimeType)
+    }
+
+    var coverDestination = this.db.serverSettings ? this.db.serverSettings.coverDestination : CoverDestination.METADATA
+    Logger.info(`[ApiController] Cover Upload destination ${coverDestination}`)
+
+    var coverDirpath = audiobook.fullPath
+    var coverRelDirpath = Path.join('/local', audiobook.path)
+    if (coverDestination === CoverDestination.METADATA) {
+      coverDirpath = Path.join(this.MetadataPath, 'books', audiobookId)
+      coverRelDirpath = Path.join('/metadata', 'books', audiobookId)
+      Logger.debug(`[ApiController] storing in metadata | ${coverDirpath}`)
+      await fs.ensureDir(coverDirpath)
+    } else {
+      Logger.debug(`[ApiController] storing in audiobook | ${coverRelDirpath}`)
+    }
+
+    var coverFilename = `cover${extname}`
+    var coverFullPath = Path.join(coverDirpath, coverFilename)
+    var coverPath = Path.join(coverRelDirpath, coverFilename)
+
+    // If current cover is a metadata cover and does not match replacement, then remove it
+    var currentBookCover = audiobook.book.cover
+    if (currentBookCover && currentBookCover.startsWith(Path.sep + 'metadata')) {
+      Logger.debug(`Current Book Cover is metadata ${currentBookCover}`)
+      if (currentBookCover !== coverPath) {
+        Logger.info(`[ApiController] removing old metadata cover "${currentBookCover}"`)
+        var oldFullBookCoverPath = Path.join(this.MetadataPath, currentBookCover.replace(Path.sep + 'metadata', ''))
+
+        // Metadata path may have changed, check if exists first
+        var exists = await fs.pathExists(oldFullBookCoverPath)
+        if (exists) {
+          try {
+            await fs.remove(oldFullBookCoverPath)
+          } catch (error) {
+            Logger.error(`[ApiController] Failed to remove old metadata book cover ${oldFullBookCoverPath}`)
+          }
+        }
+      }
+    }
+
+    var success = await coverFile.mv(coverFullPath).then(() => true).catch((error) => {
+      Logger.error('Failed to move cover file', path, error)
+      return false
+    })
+
+    if (!success) {
+      return res.status(500).send('Failed to move cover into destination')
+    }
+
+    Logger.info(`[ApiController] Uploaded audiobook cover "${coverPath}" for "${audiobook.title}"`)
+
+    audiobook.updateBookCover(coverPath)
+    await this.db.updateAudiobook(audiobook)
+    this.emitter('audiobook_updated', audiobook.toJSONMinified())
+    res.json({
+      success: true,
+      cover: coverPath
+    })
+  }
+
   async updateAudiobook(req, res) {
     if (!req.user.canUpdate) {
       Logger.warn('User attempted to update without permission', req.user)