Merge branch 'master' into authorSort

server/controllers/CustomMetadataProviderController.js

@@ -0,0 +1,117 @@
+const Logger = require('../Logger')
+const SocketAuthority = require('../SocketAuthority')
+const Database = require('../Database')
+
+const { validateUrl } = require('../utils/index')
+
+//
+// This is a controller for routes that don't have a home yet :(
+//
+class CustomMetadataProviderController {
+  constructor() { }
+
+  /**
+   * GET: /api/custom-metadata-providers
+   *
+   * @param {import('express').Request} req
+   * @param {import('express').Response} res
+   */
+  async getAll(req, res) {
+    const providers = await Database.customMetadataProviderModel.findAll()
+
+    res.json({
+      providers
+    })
+  }
+
+  /**
+   * POST: /api/custom-metadata-providers
+   *
+   * @param {import('express').Request} req
+   * @param {import('express').Response} res
+   */
+  async create(req, res) {
+    const { name, url, mediaType, authHeaderValue } = req.body
+
+    if (!name || !url || !mediaType) {
+      return res.status(400).send('Invalid request body')
+    }
+
+    const validUrl = validateUrl(url)
+    if (!validUrl) {
+      Logger.error(`[CustomMetadataProviderController] Invalid url "${url}"`)
+      return res.status(400).send('Invalid url')
+    }
+
+    const provider = await Database.customMetadataProviderModel.create({
+      name,
+      mediaType,
+      url,
+      authHeaderValue: !authHeaderValue ? null : authHeaderValue,
+    })
+
+    // TODO: Necessary to emit to all clients?
+    SocketAuthority.emitter('custom_metadata_provider_added', provider.toClientJson())
+
+    res.json({
+      provider
+    })
+  }
+
+  /**
+   * DELETE: /api/custom-metadata-providers/:id
+   * 
+   * @param {import('express').Request} req
+   * @param {import('express').Response} res
+   */
+  async delete(req, res) {
+    const slug = `custom-${req.params.id}`
+
+    /** @type {import('../models/CustomMetadataProvider')} */
+    const provider = req.customMetadataProvider
+    const providerClientJson = provider.toClientJson()
+
+    const fallbackProvider = provider.mediaType === 'book' ? 'google' : 'itunes'
+
+    await provider.destroy()
+
+    // Libraries using this provider fallback to default provider
+    await Database.libraryModel.update({
+      provider: fallbackProvider
+    }, {
+      where: {
+        provider: slug
+      }
+    })
+
+    // TODO: Necessary to emit to all clients?
+    SocketAuthority.emitter('custom_metadata_provider_removed', providerClientJson)
+
+    res.sendStatus(200)
+  }
+
+  /**
+   * Middleware that requires admin or up
+   * 
+   * @param {import('express').Request} req 
+   * @param {import('express').Response} res 
+   * @param {import('express').NextFunction} next 
+   */
+  async middleware(req, res, next) {
+    if (!req.user.isAdminOrUp) {
+      Logger.warn(`[CustomMetadataProviderController] Non-admin user "${req.user.username}" attempted access route "${req.path}"`)
+      return res.sendStatus(403)
+    }
+
+    // If id param then add req.customMetadataProvider
+    if (req.params.id) {
+      req.customMetadataProvider = await Database.customMetadataProviderModel.findByPk(req.params.id)
+      if (!req.customMetadataProvider) {
+        return res.sendStatus(404)
+      }
+    }
+
+    next()
+  }
+}
+module.exports = new CustomMetadataProviderController()

server/controllers/LibraryController.js

@@ -33,6 +33,14 @@ class LibraryController {
       return res.status(500).send('Invalid request')
     }
 
+    // Validate that the custom provider exists if given any
+    if (newLibraryPayload.provider?.startsWith('custom-')) {
+      if (!await Database.customMetadataProviderModel.checkExistsBySlug(newLibraryPayload.provider)) {
+        Logger.error(`[LibraryController] Custom metadata provider "${newLibraryPayload.provider}" does not exist`)
+        return res.status(400).send('Custom metadata provider does not exist')
+      }
+    }
+
     // Validate folder paths exist or can be created & resolve rel paths
     //   returns 400 if a folder fails to access
     newLibraryPayload.folders = newLibraryPayload.folders.map(f => {
@@ -86,19 +94,27 @@ class LibraryController {
     })
   }
 
+  /**
+   * GET: /api/libraries/:id
+   * 
+   * @param {import('express').Request} req 
+   * @param {import('express').Response} res 
+   */
   async findOne(req, res) {
     const includeArray = (req.query.include || '').split(',')
     if (includeArray.includes('filterdata')) {
       const filterdata = await libraryFilters.getFilterData(req.library.mediaType, req.library.id)
+      const customMetadataProviders = await Database.customMetadataProviderModel.getForClientByMediaType(req.library.mediaType)
 
       return res.json({
         filterdata,
         issues: filterdata.numIssues,
         numUserPlaylists: await Database.playlistModel.getNumPlaylistsForUserAndLibrary(req.user.id, req.library.id),
+        customMetadataProviders,
         library: req.library
       })
     }
-    return res.json(req.library)
+    res.json(req.library)
   }
 
   /**
@@ -115,6 +131,14 @@ class LibraryController {
   async update(req, res) {
     const library = req.library
 
+    // Validate that the custom provider exists if given any
+    if (req.body.provider?.startsWith('custom-')) {
+      if (!await Database.customMetadataProviderModel.checkExistsBySlug(req.body.provider)) {
+        Logger.error(`[LibraryController] Custom metadata provider "${req.body.provider}" does not exist`)
+        return res.status(400).send('Custom metadata provider does not exist')
+      }
+    }
+
     // Validate new folder paths exist or can be created & resolve rel paths
     //   returns 400 if a new folder fails to access
     if (req.body.folders) {

server/controllers/LibraryItemController.js

@@ -124,6 +124,11 @@ class LibraryItemController {
     const libraryItem = req.libraryItem
     const mediaPayload = req.body
 
+    if (mediaPayload.url) {
+      await LibraryItemController.prototype.uploadCover.bind(this)(req, res, false)
+      if (res.writableEnded) return
+    }
+
     // Book specific
     if (libraryItem.isBook) {
       await this.createAuthorsAndSeriesForItemUpdate(mediaPayload, libraryItem.libraryId)
@@ -146,7 +151,7 @@ class LibraryItemController {
       seriesRemoved = libraryItem.media.metadata.series.filter(se => !seriesIdsInUpdate.includes(se.id))
     }
 
-    const hasUpdates = libraryItem.media.update(mediaPayload)
+    const hasUpdates = libraryItem.media.update(mediaPayload) || mediaPayload.url
     if (hasUpdates) {
       libraryItem.updatedAt = Date.now()
 
@@ -171,7 +176,7 @@ class LibraryItemController {
   }
 
   // POST: api/items/:id/cover
-  async uploadCover(req, res) {
+  async uploadCover(req, res, updateAndReturnJson = true) {
     if (!req.user.canUpload) {
       Logger.warn('User attempted to upload a cover without permission', req.user)
       return res.sendStatus(403)
@@ -196,12 +201,14 @@ class LibraryItemController {
       return res.status(500).send('Unknown error occurred')
     }
 
-    await Database.updateLibraryItem(libraryItem)
-    SocketAuthority.emitter('item_updated', libraryItem.toJSONExpanded())
-    res.json({
-      success: true,
-      cover: result.cover
-    })
+    if (updateAndReturnJson) {
+      await Database.updateLibraryItem(libraryItem)
+      SocketAuthority.emitter('item_updated', libraryItem.toJSONExpanded())
+      res.json({
+        success: true,
+        cover: result.cover
+      })
+    }
   }
 
   // PATCH: api/items/:id/cover
@@ -276,6 +283,9 @@ class LibraryItemController {
       return res.sendStatus(404)
     }
 
+    if (req.query.ts)
+      res.set('Cache-Control', 'private, max-age=86400')
+
     if (raw) { // any value
       if (global.XAccel) {
         const encodedURI = encodeUriPath(global.XAccel + libraryItem.media.coverPath)

server/controllers/MeController.js

@@ -336,7 +336,7 @@ class MeController {
   }
 
   /**
-   * GET: /api/stats/year/:year
+   * GET: /api/me/stats/year/:year
    * 
    * @param {import('express').Request} req 
    * @param {import('express').Response} res 

server/controllers/MiscController.js

@@ -633,7 +633,7 @@ class MiscController {
       } else if (key === 'authOpenIDMobileRedirectURIs') {
         function isValidRedirectURI(uri) {
           if (typeof uri !== 'string') return false
-          const pattern = new RegExp('^\\w+://[\\w.-]+$', 'i')
+          const pattern = new RegExp('^\\w+://[\\w\\.-]+(/[\\w\\./-]*)*$', 'i')
           return pattern.test(uri)
         }
 
@@ -699,7 +699,7 @@ class MiscController {
   }
 
   /**
-   * GET: /api/me/stats/year/:year
+   * GET: /api/stats/year/:year
    * 
    * @param {import('express').Request} req 
    * @param {import('express').Response} res 
@@ -717,5 +717,23 @@ class MiscController {
     const stats = await adminStats.getStatsForYear(year)
     res.json(stats)
   }
+
+  /**
+   * GET: /api/logger-data
+   * admin or up
+   * 
+   * @param {import('express').Request} req 
+   * @param {import('express').Response} res 
+   */
+  async getLoggerData(req, res) {
+    if (!req.user.isAdminOrUp) {
+      Logger.error(`[MiscController] Non-admin user "${req.user.username}" attempted to get logger data`)
+      return res.sendStatus(403)
+    }
+
+    res.json({
+      currentDailyLogs: Logger.logManager.getMostRecentCurrentDailyLogs()
+    })
+  }
 }
 module.exports = new MiscController()

server/controllers/SearchController.js

@@ -43,12 +43,15 @@ class SearchController {
    */
   async findPodcasts(req, res) {
     const term = req.query.term
+    const country = req.query.country || 'us'
     if (!term) {
       Logger.error('[SearchController] Invalid request query param "term" is required')
       return res.status(400).send('Invalid request query param "term" is required')
     }
 
-    const results = await PodcastFinder.search(term)
+    const results = await PodcastFinder.search(term, {
+      country
+    })
     res.json(results)
   }
 

server/controllers/SessionController.js

@@ -161,7 +161,7 @@ class SessionController {
    * @typedef batchDeleteReqBody
    * @property {string[]} sessions
    * 
-   * @param {import('express').Request<{}, {}, batchDeleteReqBody, {}} req 
+   * @param {import('express').Request<{}, {}, batchDeleteReqBody, {}>} req 
    * @param {import('express').Response} res 
    */
   async batchDelete(req, res) {

server/controllers/UserController.js

@@ -194,6 +194,23 @@ class UserController {
     })
   }
 
+  /**
+   * PATCH: /api/users/:id/openid-unlink
+   * 
+   * @param {import('express').Request} req 
+   * @param {import('express').Response} res 
+   */
+  async unlinkFromOpenID(req, res) {
+    Logger.debug(`[UserController] Unlinking user "${req.reqUser.username}" from OpenID with sub "${req.reqUser.authOpenIDSub}"`)
+    req.reqUser.authOpenIDSub = null
+    if (await Database.userModel.updateFromOld(req.reqUser)) {
+      SocketAuthority.clientEmitter(req.user.id, 'user_updated', req.reqUser.toJSONForBrowser())
+      res.sendStatus(200)
+    } else {
+      res.sendStatus(500)
+    }
+  }
+
   // GET: api/users/:id/listening-sessions
   async getListeningSessions(req, res) {
     var listeningSessions = await this.getUserListeningSessionsHelper(req.params.id)