Update podcasts to new library item model

Merge pull request #3789 from advplyr/migrate-podcasts-new-library-item
2026-06-03 17:30:39 +02:00 · 2025-01-04 12:41:09 -06:00 · 2025-01-03 16:59:13 -06:00 · 2025-01-03 16:48:24 -06:00 · 2025-01-03 14:07:27 -06:00 · 2025-01-03 13:04:18 -06:00
31 changed files with 1009 additions and 636 deletions
@@ -170,6 +170,12 @@ export default {
        this.show = false
      }
    },
+    libraryItemUpdated(libraryItem) {
+      const episode = libraryItem.media.episodes.find((e) => e.id === this.selectedEpisodeId)
+      if (episode) {
+        this.episodeItem = episode
+      }
+    },
    hotkey(action) {
      if (action === this.$hotkeys.Modal.NEXT_PAGE) {
        this.goNextEpisode()
@@ -178,9 +184,15 @@ export default {
      }
    },
    registerListeners() {
+      if (this.libraryItem) {
+        this.$eventBus.$on(`${this.libraryItem.id}_updated`, this.libraryItemUpdated)
+      }
      this.$eventBus.$on('modal-hotkey', this.hotkey)
    },
    unregisterListeners() {
+      if (this.libraryItem) {
+        this.$eventBus.$on(`${this.libraryItem.id}_updated`, this.libraryItemUpdated)
+      }
      this.$eventBus.$off('modal-hotkey', this.hotkey)
    }
  },
@@ -163,13 +163,10 @@ export default {

      this.isProcessing = false
      if (updateResult) {
-        if (updateResult) {
-          this.$toast.success(this.$strings.ToastItemUpdateSuccess)
-          return true
-        } else {
-          this.$toast.info(this.$strings.MessageNoUpdatesWereNecessary)
-        }
+        this.$toast.success(this.$strings.ToastItemUpdateSuccess)
+        return true
      }
+
      return false
    }
  },
@@ -695,6 +695,27 @@ class Database {
      await book.destroy()
    }

+    const playlistMediaItemsWithNoMediaItem = await this.playlistMediaItemModel.findAll({
+      include: [
+        {
+          model: this.bookModel,
+          attributes: ['id']
+        },
+        {
+          model: this.podcastEpisodeModel,
+          attributes: ['id']
+        }
+      ],
+      where: {
+        '$book.id$': null,
+        '$podcastEpisode.id$': null
+      }
+    })
+    for (const playlistMediaItem of playlistMediaItemsWithNoMediaItem) {
+      Logger.warn(`Found playlistMediaItem with no book or podcastEpisode - removing it`)
+      await playlistMediaItem.destroy()
+    }
+
    // Remove empty series
    const emptySeries = await this.seriesModel.findAll({
      include: {
@@ -249,6 +249,9 @@ class LibraryItemController {

    const hasUpdates = (await req.libraryItem.media.updateFromRequest(mediaPayload)) || mediaPayload.url
    if (hasUpdates) {
+      req.libraryItem.changed('updatedAt', true)
+      await req.libraryItem.save()
+
      if (isPodcastAutoDownloadUpdated) {
        this.cronManager.checkUpdatePodcastCron(req.libraryItem)
      }
@@ -971,6 +974,20 @@ class LibraryItemController {
      }
    } else if (req.libraryItem.media.podcastEpisodes.some((ep) => ep.audioFile.ino === req.params.fileid)) {
      const episodeToRemove = req.libraryItem.media.podcastEpisodes.find((ep) => ep.audioFile.ino === req.params.fileid)
+      // Remove episode from all playlists
+      await Database.playlistModel.removeMediaItemsFromPlaylists([episodeToRemove.id])
+
+      // Remove episode media progress
+      const numProgressRemoved = await Database.mediaProgressModel.destroy({
+        where: {
+          mediaItemId: episodeToRemove.id
+        }
+      })
+      if (numProgressRemoved > 0) {
+        Logger.info(`[LibraryItemController] Removed media progress for episode ${episodeToRemove.id}`)
+      }
+
+      // Remove episode
      await episodeToRemove.destroy()

      req.libraryItem.media.podcastEpisodes = req.libraryItem.media.podcastEpisodes.filter((ep) => ep.audioFile.ino !== req.params.fileid)
@@ -1,3 +1,4 @@
+const Path = require('path')
 const { Request, Response, NextFunction } = require('express')
 const Logger = require('../Logger')
 const SocketAuthority = require('../SocketAuthority')
@@ -12,13 +13,16 @@ const { validateUrl } = require('../utils/index')
 const Scanner = require('../scanner/Scanner')
 const CoverManager = require('../managers/CoverManager')

-const LibraryItem = require('../objects/LibraryItem')
-
 /**
 * @typedef RequestUserObject
 * @property {import('../models/User')} user
 *
 * @typedef {Request & RequestUserObject} RequestWithUser
+ *
+ * @typedef RequestEntityObject
+ * @property {import('../models/LibraryItem')} libraryItem
+ *
+ * @typedef {RequestWithUser & RequestEntityObject} RequestWithLibraryItem
 */

 class PodcastController {
@@ -37,6 +41,9 @@ class PodcastController {
      return res.sendStatus(403)
    }
    const payload = req.body
+    if (!payload.media || !payload.media.metadata) {
+      return res.status(400).send('Invalid request body. "media" and "media.metadata" are required')
+    }

    const library = await Database.libraryModel.findByIdWithFolders(payload.libraryId)
    if (!library) {
@@ -78,48 +85,87 @@ class PodcastController {
    let relPath = payload.path.replace(folder.fullPath, '')
    if (relPath.startsWith('/')) relPath = relPath.slice(1)

-    const libraryItemPayload = {
-      path: podcastPath,
-      relPath,
-      folderId: payload.folderId,
-      libraryId: payload.libraryId,
-      ino: libraryItemFolderStats.ino,
-      mtimeMs: libraryItemFolderStats.mtimeMs || 0,
-      ctimeMs: libraryItemFolderStats.ctimeMs || 0,
-      birthtimeMs: libraryItemFolderStats.birthtimeMs || 0,
-      media: payload.media
+    let newLibraryItem = null
+    const transaction = await Database.sequelize.transaction()
+    try {
+      const podcast = await Database.podcastModel.createFromRequest(payload.media, transaction)
+
+      newLibraryItem = await Database.libraryItemModel.create(
+        {
+          ino: libraryItemFolderStats.ino,
+          path: podcastPath,
+          relPath,
+          mediaId: podcast.id,
+          mediaType: 'podcast',
+          isFile: false,
+          isMissing: false,
+          isInvalid: false,
+          mtime: libraryItemFolderStats.mtimeMs || 0,
+          ctime: libraryItemFolderStats.ctimeMs || 0,
+          birthtime: libraryItemFolderStats.birthtimeMs || 0,
+          size: 0,
+          libraryFiles: [],
+          extraData: {},
+          libraryId: library.id,
+          libraryFolderId: folder.id
+        },
+        { transaction }
+      )
+
+      await transaction.commit()
+    } catch (error) {
+      Logger.error(`[PodcastController] Failed to create podcast: ${error}`)
+      await transaction.rollback()
+      return res.status(500).send('Failed to create podcast')
    }

-    const libraryItem = new LibraryItem()
-    libraryItem.setData('podcast', libraryItemPayload)
+    newLibraryItem.media = await newLibraryItem.getMediaExpanded()

    // Download and save cover image
-    if (payload.media.metadata.imageUrl) {
-      // TODO: Scan cover image to library files
+    if (typeof payload.media.metadata.imageUrl === 'string' && payload.media.metadata.imageUrl.startsWith('http')) {
      // Podcast cover will always go into library item folder
-      const coverResponse = await CoverManager.downloadCoverFromUrl(libraryItem, payload.media.metadata.imageUrl, true)
-      if (coverResponse) {
-        if (coverResponse.error) {
-          Logger.error(`[PodcastController] Download cover error from "${payload.media.metadata.imageUrl}": ${coverResponse.error}`)
-        } else if (coverResponse.cover) {
-          libraryItem.media.coverPath = coverResponse.cover
+      const coverResponse = await CoverManager.downloadCoverFromUrlNew(payload.media.metadata.imageUrl, newLibraryItem.id, newLibraryItem.path, true)
+      if (coverResponse.error) {
+        Logger.error(`[PodcastController] Download cover error from "${payload.media.metadata.imageUrl}": ${coverResponse.error}`)
+      } else if (coverResponse.cover) {
+        const coverImageFileStats = await getFileTimestampsWithIno(coverResponse.cover)
+        if (!coverImageFileStats) {
+          Logger.error(`[PodcastController] Failed to get cover image stats for "${coverResponse.cover}"`)
+        } else {
+          // Add libraryFile to libraryItem and coverPath to podcast
+          const newLibraryFile = {
+            ino: coverImageFileStats.ino,
+            fileType: 'image',
+            addedAt: Date.now(),
+            updatedAt: Date.now(),
+            metadata: {
+              filename: Path.basename(coverResponse.cover),
+              ext: Path.extname(coverResponse.cover).slice(1),
+              path: coverResponse.cover,
+              relPath: Path.basename(coverResponse.cover),
+              size: coverImageFileStats.size,
+              mtimeMs: coverImageFileStats.mtimeMs || 0,
+              ctimeMs: coverImageFileStats.ctimeMs || 0,
+              birthtimeMs: coverImageFileStats.birthtimeMs || 0
+            }
+          }
+          newLibraryItem.libraryFiles.push(newLibraryFile)
+          newLibraryItem.changed('libraryFiles', true)
+          await newLibraryItem.save()
+
+          newLibraryItem.media.coverPath = coverResponse.cover
+          await newLibraryItem.media.save()
        }
      }
    }

-    await Database.createLibraryItem(libraryItem)
-    SocketAuthority.emitter('item_added', libraryItem.toJSONExpanded())
+    SocketAuthority.emitter('item_added', newLibraryItem.toOldJSONExpanded())

-    res.json(libraryItem.toJSONExpanded())
-
-    if (payload.episodesToDownload?.length) {
-      Logger.info(`[PodcastController] Podcast created now starting ${payload.episodesToDownload.length} episode downloads`)
-      this.podcastManager.downloadPodcastEpisodes(libraryItem, payload.episodesToDownload)
-    }
+    res.json(newLibraryItem.toOldJSONExpanded())

    // Turn on podcast auto download cron if not already on
-    if (libraryItem.media.autoDownloadEpisodes) {
-      this.cronManager.checkUpdatePodcastCron(libraryItem)
+    if (newLibraryItem.media.autoDownloadEpisodes) {
+      this.cronManager.checkUpdatePodcastCron(newLibraryItem)
    }
  }

@@ -213,7 +259,7 @@ class PodcastController {
   *
   * @this import('../routers/ApiRouter')
   *
-   * @param {RequestWithUser} req
+   * @param {RequestWithLibraryItem} req
   * @param {Response} res
   */
  async checkNewEpisodes(req, res) {
@@ -222,15 +268,14 @@ class PodcastController {
      return res.sendStatus(403)
    }

-    var libraryItem = req.libraryItem
-    if (!libraryItem.media.metadata.feedUrl) {
-      Logger.error(`[PodcastController] checkNewEpisodes no feed url for item ${libraryItem.id}`)
-      return res.status(500).send('Podcast has no rss feed url')
+    if (!req.libraryItem.media.feedURL) {
+      Logger.error(`[PodcastController] checkNewEpisodes no feed url for item ${req.libraryItem.id}`)
+      return res.status(400).send('Podcast has no rss feed url')
    }

    const maxEpisodesToDownload = !isNaN(req.query.limit) ? Number(req.query.limit) : 3

-    var newEpisodes = await this.podcastManager.checkAndDownloadNewEpisodes(libraryItem, maxEpisodesToDownload)
+    const newEpisodes = await this.podcastManager.checkAndDownloadNewEpisodes(req.libraryItem, maxEpisodesToDownload)
    res.json({
      episodes: newEpisodes || []
    })
@@ -258,23 +303,28 @@ class PodcastController {
   *
   * @this {import('../routers/ApiRouter')}
   *
-   * @param {RequestWithUser} req
+   * @param {RequestWithLibraryItem} req
   * @param {Response} res
   */
  getEpisodeDownloads(req, res) {
-    var libraryItem = req.libraryItem
-
-    var downloadsInQueue = this.podcastManager.getEpisodeDownloadsInQueue(libraryItem.id)
+    const downloadsInQueue = this.podcastManager.getEpisodeDownloadsInQueue(req.libraryItem.id)
    res.json({
      downloads: downloadsInQueue.map((d) => d.toJSONForClient())
    })
  }

+  /**
+   * GET: /api/podcasts/:id/search-episode
+   * Search for an episode in a podcast
+   *
+   * @param {RequestWithLibraryItem} req
+   * @param {Response} res
+   */
  async findEpisode(req, res) {
-    const rssFeedUrl = req.libraryItem.media.metadata.feedUrl
+    const rssFeedUrl = req.libraryItem.media.feedURL
    if (!rssFeedUrl) {
      Logger.error(`[PodcastController] findEpisode: Podcast has no feed url`)
-      return res.status(500).send('Podcast does not have an RSS feed URL')
+      return res.status(400).send('Podcast does not have an RSS feed URL')
    }

    const searchTitle = req.query.title
@@ -292,7 +342,7 @@ class PodcastController {
   *
   * @this {import('../routers/ApiRouter')}
   *
-   * @param {RequestWithUser} req
+   * @param {RequestWithLibraryItem} req
   * @param {Response} res
   */
  async downloadEpisodes(req, res) {
@@ -300,13 +350,13 @@ class PodcastController {
      Logger.error(`[PodcastController] Non-admin user "${req.user.username}" attempted to download episodes`)
      return res.sendStatus(403)
    }
-    const libraryItem = req.libraryItem
+
    const episodes = req.body
-    if (!episodes?.length) {
+    if (!Array.isArray(episodes) || !episodes.length) {
      return res.sendStatus(400)
    }

-    this.podcastManager.downloadPodcastEpisodes(libraryItem, episodes)
+    this.podcastManager.downloadPodcastEpisodes(req.libraryItem, episodes)
    res.sendStatus(200)
  }

@@ -315,7 +365,7 @@ class PodcastController {
   *
   * @this {import('../routers/ApiRouter')}
   *
-   * @param {RequestWithUser} req
+   * @param {RequestWithLibraryItem} req
   * @param {Response} res
   */
  async quickMatchEpisodes(req, res) {
@@ -325,10 +375,11 @@ class PodcastController {
    }

    const overrideDetails = req.query.override === '1'
-    const episodesUpdated = await Scanner.quickMatchPodcastEpisodes(req.libraryItem, { overrideDetails })
+    const oldLibraryItem = Database.libraryItemModel.getOldLibraryItem(req.libraryItem)
+    const episodesUpdated = await Scanner.quickMatchPodcastEpisodes(oldLibraryItem, { overrideDetails })
    if (episodesUpdated) {
-      await Database.updateLibraryItem(req.libraryItem)
-      SocketAuthority.emitter('item_updated', req.libraryItem.toJSONExpanded())
+      await Database.updateLibraryItem(oldLibraryItem)
+      SocketAuthority.emitter('item_updated', oldLibraryItem.toJSONExpanded())
    }

    res.json({
@@ -339,58 +390,76 @@ class PodcastController {
  /**
   * PATCH: /api/podcasts/:id/episode/:episodeId
   *
-   * @param {RequestWithUser} req
+   * @param {RequestWithLibraryItem} req
   * @param {Response} res
   */
  async updateEpisode(req, res) {
-    const libraryItem = req.libraryItem
-
-    var episodeId = req.params.episodeId
-    if (!libraryItem.media.checkHasEpisode(episodeId)) {
+    /** @type {import('../models/PodcastEpisode')} */
+    const episode = req.libraryItem.media.podcastEpisodes.find((ep) => ep.id === req.params.episodeId)
+    if (!episode) {
      return res.status(404).send('Episode not found')
    }

-    if (libraryItem.media.updateEpisode(episodeId, req.body)) {
-      await Database.updateLibraryItem(libraryItem)
-      SocketAuthority.emitter('item_updated', libraryItem.toJSONExpanded())
+    const updatePayload = {}
+    const supportedStringKeys = ['title', 'subtitle', 'description', 'pubDate', 'episode', 'season', 'episodeType']
+    for (const key in req.body) {
+      if (supportedStringKeys.includes(key) && typeof req.body[key] === 'string') {
+        updatePayload[key] = req.body[key]
+      } else if (key === 'chapters' && Array.isArray(req.body[key]) && req.body[key].every((ch) => typeof ch === 'object' && ch.title && ch.start)) {
+        updatePayload[key] = req.body[key]
+      } else if (key === 'publishedAt' && typeof req.body[key] === 'number') {
+        updatePayload[key] = req.body[key]
+      }
    }

-    res.json(libraryItem.toJSONExpanded())
+    if (Object.keys(updatePayload).length) {
+      episode.set(updatePayload)
+      if (episode.changed()) {
+        Logger.info(`[PodcastController] Updated episode "${episode.title}" keys`, episode.changed())
+        await episode.save()
+
+        SocketAuthority.emitter('item_updated', req.libraryItem.toOldJSONExpanded())
+      } else {
+        Logger.info(`[PodcastController] No changes to episode "${episode.title}"`)
+      }
+    }
+
+    res.json(req.libraryItem.toOldJSONExpanded())
  }

  /**
   * GET: /api/podcasts/:id/episode/:episodeId
   *
-   * @param {RequestWithUser} req
+   * @param {RequestWithLibraryItem} req
   * @param {Response} res
   */
  async getEpisode(req, res) {
    const episodeId = req.params.episodeId
-    const libraryItem = req.libraryItem

-    const episode = libraryItem.media.episodes.find((ep) => ep.id === episodeId)
+    /** @type {import('../models/PodcastEpisode')} */
+    const episode = req.libraryItem.media.podcastEpisodes.find((ep) => ep.id === episodeId)
    if (!episode) {
-      Logger.error(`[PodcastController] getEpisode episode ${episodeId} not found for item ${libraryItem.id}`)
+      Logger.error(`[PodcastController] getEpisode episode ${episodeId} not found for item ${req.libraryItem.id}`)
      return res.sendStatus(404)
    }

-    res.json(episode)
+    res.json(episode.toOldJSON(req.libraryItem.id))
  }

  /**
   * DELETE: /api/podcasts/:id/episode/:episodeId
   *
-   * @param {RequestWithUser} req
+   * @param {RequestWithLibraryItem} req
   * @param {Response} res
   */
  async removeEpisode(req, res) {
    const episodeId = req.params.episodeId
-    const libraryItem = req.libraryItem
    const hardDelete = req.query.hard === '1'

-    const episode = libraryItem.media.episodes.find((ep) => ep.id === episodeId)
+    /** @type {import('../models/PodcastEpisode')} */
+    const episode = req.libraryItem.media.podcastEpisodes.find((ep) => ep.id === episodeId)
    if (!episode) {
-      Logger.error(`[PodcastController] removeEpisode episode ${episodeId} not found for item ${libraryItem.id}`)
+      Logger.error(`[PodcastController] removeEpisode episode ${episodeId} not found for item ${req.libraryItem.id}`)
      return res.sendStatus(404)
    }

@@ -407,36 +476,8 @@ class PodcastController {
        })
    }

-    // Remove episode from Podcast and library file
-    const episodeRemoved = libraryItem.media.removeEpisode(episodeId)
-    if (episodeRemoved?.audioFile) {
-      libraryItem.removeLibraryFile(episodeRemoved.audioFile.ino)
-    }
-
-    // Update/remove playlists that had this podcast episode
-    const playlistMediaItems = await Database.playlistMediaItemModel.findAll({
-      where: {
-        mediaItemId: episodeId
-      },
-      include: {
-        model: Database.playlistModel,
-        include: Database.playlistMediaItemModel
-      }
-    })
-    for (const pmi of playlistMediaItems) {
-      const numItems = pmi.playlist.playlistMediaItems.length - 1
-
-      if (!numItems) {
-        Logger.info(`[PodcastController] Playlist "${pmi.playlist.name}" has no more items - removing it`)
-        const jsonExpanded = await pmi.playlist.getOldJsonExpanded()
-        SocketAuthority.clientEmitter(pmi.playlist.userId, 'playlist_removed', jsonExpanded)
-        await pmi.playlist.destroy()
-      } else {
-        await pmi.destroy()
-        const jsonExpanded = await pmi.playlist.getOldJsonExpanded()
-        SocketAuthority.clientEmitter(pmi.playlist.userId, 'playlist_updated', jsonExpanded)
-      }
-    }
+    // Remove episode from playlists
+    await Database.playlistModel.removeMediaItemsFromPlaylists([episodeId])

    // Remove media progress for this episode
    const mediaProgressRemoved = await Database.mediaProgressModel.destroy({
@@ -448,9 +489,16 @@ class PodcastController {
      Logger.info(`[PodcastController] Removed ${mediaProgressRemoved} media progress for episode ${episode.id}`)
    }

-    await Database.updateLibraryItem(libraryItem)
-    SocketAuthority.emitter('item_updated', libraryItem.toJSONExpanded())
-    res.json(libraryItem.toJSON())
+    // Remove episode
+    await episode.destroy()
+
+    // Remove library file
+    req.libraryItem.libraryFiles = req.libraryItem.libraryFiles.filter((file) => file.ino !== episode.audioFile.ino)
+    req.libraryItem.changed('libraryFiles', true)
+    await req.libraryItem.save()
+
+    SocketAuthority.emitter('item_updated', req.libraryItem.toOldJSONExpanded())
+    res.json(req.libraryItem.toOldJSON())
  }

  /**
@@ -460,15 +508,15 @@ class PodcastController {
   * @param {NextFunction} next
   */
  async middleware(req, res, next) {
-    const item = await Database.libraryItemModel.getOldById(req.params.id)
-    if (!item?.media) return res.sendStatus(404)
+    const libraryItem = await Database.libraryItemModel.getExpandedById(req.params.id)
+    if (!libraryItem?.media) return res.sendStatus(404)

-    if (!item.isPodcast) {
+    if (!libraryItem.isPodcast) {
      return res.sendStatus(500)
    }

    // Check user can access this library item
-    if (!req.user.checkCanAccessLibraryItem(item)) {
+    if (!req.user.checkCanAccessLibraryItem(libraryItem)) {
      return res.sendStatus(403)
    }

@@ -480,7 +528,7 @@ class PodcastController {
      return res.sendStatus(403)
    }

-    req.libraryItem = item
+    req.libraryItem = libraryItem
    next()
  }
 }
@@ -149,7 +149,7 @@ class SessionController {
   * @param {Response} res
   */
  async getOpenSession(req, res) {
-    const libraryItem = await Database.libraryItemModel.getOldById(req.playbackSession.libraryItemId)
+    const libraryItem = await Database.libraryItemModel.getExpandedById(req.playbackSession.libraryItemId)
    const sessionForClient = req.playbackSession.toJSONForClient(libraryItem)
    res.json(sessionForClient)
  }
@@ -70,14 +70,13 @@ class ShareController {
    }

    try {
-      const oldLibraryItem = await Database.mediaItemShareModel.getMediaItemsOldLibraryItem(mediaItemShare.mediaItemId, mediaItemShare.mediaItemType)
-
-      if (!oldLibraryItem) {
+      const libraryItem = await Database.mediaItemShareModel.getMediaItemsLibraryItem(mediaItemShare.mediaItemId, mediaItemShare.mediaItemType)
+      if (!libraryItem) {
        return res.status(404).send('Media item not found')
      }

      let startOffset = 0
-      const publicTracks = oldLibraryItem.media.includedAudioFiles.map((audioFile) => {
+      const publicTracks = libraryItem.media.includedAudioFiles.map((audioFile) => {
        const audioTrack = {
          index: audioFile.index,
          startOffset,
@@ -86,7 +85,7 @@ class ShareController {
          contentUrl: `${global.RouterBasePath}/public/share/${slug}/track/${audioFile.index}`,
          mimeType: audioFile.mimeType,
          codec: audioFile.codec || null,
-          metadata: audioFile.metadata.clone()
+          metadata: structuredClone(audioFile.metadata)
        }
        startOffset += audioTrack.duration
        return audioTrack
@@ -105,12 +104,12 @@ class ShareController {
      const deviceInfo = await this.playbackSessionManager.getDeviceInfo(req, clientDeviceInfo)

      const newPlaybackSession = new PlaybackSession()
-      newPlaybackSession.setData(oldLibraryItem, null, 'web-share', deviceInfo, startTime)
+      newPlaybackSession.setData(libraryItem, null, 'web-share', deviceInfo, startTime)
      newPlaybackSession.audioTracks = publicTracks
      newPlaybackSession.playMethod = PlayMethod.DIRECTPLAY
      newPlaybackSession.shareSessionId = shareSessionId
      newPlaybackSession.mediaItemShareId = mediaItemShare.id
-      newPlaybackSession.coverAspectRatio = oldLibraryItem.librarySettings.coverAspectRatio
+      newPlaybackSession.coverAspectRatio = libraryItem.library.settings.coverAspectRatio

      mediaItemShare.playbackSession = newPlaybackSession.toJSONForClient()
      ShareManager.addOpenSharePlaybackSession(newPlaybackSession)
@@ -338,13 +338,14 @@ class CoverManager {
   *
   * @param {string} url
   * @param {string} libraryItemId
-   * @param {string} [libraryItemPath] null if library item isFile or is from adding new podcast
+   * @param {string} [libraryItemPath] - null if library item isFile
+   * @param {boolean} [forceLibraryItemFolder=false] - force save cover with library item (used for adding new podcasts)
   * @returns {Promise<{error:string}|{cover:string}>}
   */
-  async downloadCoverFromUrlNew(url, libraryItemId, libraryItemPath) {
+  async downloadCoverFromUrlNew(url, libraryItemId, libraryItemPath, forceLibraryItemFolder = false) {
    try {
      let coverDirPath = null
-      if (global.ServerSettings.storeCoverWithItem && libraryItemPath) {
+      if ((global.ServerSettings.storeCoverWithItem || forceLibraryItemFolder) && libraryItemPath) {
        coverDirPath = libraryItemPath
      } else {
        coverDirPath = Path.posix.join(global.MetadataPath, 'items', libraryItemId)
@@ -181,7 +181,7 @@ class CronManager {
    // Get podcast library items to check
    const libraryItems = []
    for (const libraryItemId of libraryItemIds) {
-      const libraryItem = await Database.libraryItemModel.getOldById(libraryItemId)
+      const libraryItem = await Database.libraryItemModel.getExpandedById(libraryItemId)
      if (!libraryItem) {
        Logger.error(`[CronManager] Library item ${libraryItemId} not found for episode check cron ${expression}`)
        podcastCron.libraryItemIds = podcastCron.libraryItemIds.filter((lid) => lid !== libraryItemId) // Filter it out
@@ -217,7 +217,7 @@ class CronManager {

  /**
   *
-   * @param {import('../models/LibraryItem')} libraryItem - this can be the old model
+   * @param {import('../models/LibraryItem')} libraryItem
   */
  checkUpdatePodcastCron(libraryItem) {
    // Remove from old cron by library item id
@@ -14,6 +14,11 @@ class NotificationManager {
    return notificationData
  }

+  /**
+   *
+   * @param {import('../models/LibraryItem')} libraryItem
+   * @param {import('../models/PodcastEpisode')} episode
+   */
  async onPodcastEpisodeDownloaded(libraryItem, episode) {
    if (!Database.notificationSettings.isUseable) return

@@ -22,17 +27,17 @@ class NotificationManager {
      return
    }

-    Logger.debug(`[NotificationManager] onPodcastEpisodeDownloaded: Episode "${episode.title}" for podcast ${libraryItem.media.metadata.title}`)
+    Logger.debug(`[NotificationManager] onPodcastEpisodeDownloaded: Episode "${episode.title}" for podcast ${libraryItem.media.title}`)
    const library = await Database.libraryModel.findByPk(libraryItem.libraryId)
    const eventData = {
      libraryItemId: libraryItem.id,
      libraryId: libraryItem.libraryId,
      libraryName: library?.name || 'Unknown',
      mediaTags: (libraryItem.media.tags || []).join(', '),
-      podcastTitle: libraryItem.media.metadata.title,
-      podcastAuthor: libraryItem.media.metadata.author || '',
-      podcastDescription: libraryItem.media.metadata.description || '',
-      podcastGenres: (libraryItem.media.metadata.genres || []).join(', '),
+      podcastTitle: libraryItem.media.title,
+      podcastAuthor: libraryItem.media.author || '',
+      podcastDescription: libraryItem.media.description || '',
+      podcastGenres: (libraryItem.media.genres || []).join(', '),
      episodeId: episode.id,
      episodeTitle: episode.title,
      episodeSubtitle: episode.subtitle || '',
@@ -74,7 +74,7 @@ class PlaybackSessionManager {
  async startSessionRequest(req, res, episodeId) {
    const deviceInfo = await this.getDeviceInfo(req, req.body?.deviceInfo)
    Logger.debug(`[PlaybackSessionManager] startSessionRequest for device ${deviceInfo.deviceDescription}`)
-    const { oldLibraryItem: libraryItem, body: options } = req
+    const { libraryItem, body: options } = req
    const session = await this.startSession(req.user, deviceInfo, libraryItem, episodeId, options)
    res.json(session.toJSONForClient(libraryItem))
  }
@@ -279,7 +279,7 @@ class PlaybackSessionManager {
   *
   * @param {import('../models/User')} user
   * @param {DeviceInfo} deviceInfo
-   * @param {import('../objects/LibraryItem')} libraryItem
+   * @param {import('../models/LibraryItem')} libraryItem
   * @param {string|null} episodeId
   * @param {{forceDirectPlay?:boolean, forceTranscode?:boolean, mediaPlayer:string, supportedMimeTypes?:string[]}} options
   * @returns {Promise<PlaybackSession>}
@@ -292,7 +292,7 @@ class PlaybackSessionManager {
      await this.closeSession(user, session, null)
    }

-    const shouldDirectPlay = options.forceDirectPlay || (!options.forceTranscode && libraryItem.media.checkCanDirectPlay(options, episodeId))
+    const shouldDirectPlay = options.forceDirectPlay || (!options.forceTranscode && libraryItem.media.checkCanDirectPlay(options.supportedMimeTypes, episodeId))
    const mediaPlayer = options.mediaPlayer || 'unknown'

    const mediaItemId = episodeId || libraryItem.media.id
@@ -300,7 +300,7 @@ class PlaybackSessionManager {
    let userStartTime = 0
    if (userProgress) {
      if (userProgress.isFinished) {
-        Logger.info(`[PlaybackSessionManager] Starting session for user "${user.username}" and resetting progress for finished item "${libraryItem.media.metadata.title}"`)
+        Logger.info(`[PlaybackSessionManager] Starting session for user "${user.username}" and resetting progress for finished item "${libraryItem.media.title}"`)
        // Keep userStartTime as 0 so the client restarts the media
      } else {
        userStartTime = Number.parseFloat(userProgress.currentTime) || 0
@@ -312,7 +312,7 @@ class PlaybackSessionManager {
    let audioTracks = []
    if (shouldDirectPlay) {
      Logger.debug(`[PlaybackSessionManager] "${user.username}" starting direct play session for item "${libraryItem.id}" with id ${newPlaybackSession.id} (Device: ${newPlaybackSession.deviceDescription})`)
-      audioTracks = libraryItem.getDirectPlayTracklist(episodeId)
+      audioTracks = libraryItem.getTrackList(episodeId)
      newPlaybackSession.playMethod = PlayMethod.DIRECTPLAY
    } else {
      Logger.debug(`[PlaybackSessionManager] "${user.username}" starting stream session for item "${libraryItem.id}" (Device: ${newPlaybackSession.deviceDescription})`)
@@ -1,3 +1,4 @@
+const Path = require('path')
 const Logger = require('../Logger')
 const SocketAuthority = require('../SocketAuthority')
 const Database = require('../Database')
@@ -19,9 +20,7 @@ const NotificationManager = require('../managers/NotificationManager')

 const LibraryFile = require('../objects/files/LibraryFile')
 const PodcastEpisodeDownload = require('../objects/PodcastEpisodeDownload')
-const PodcastEpisode = require('../objects/entities/PodcastEpisode')
 const AudioFile = require('../objects/files/AudioFile')
-const LibraryItem = require('../objects/LibraryItem')

 class PodcastManager {
  constructor() {
@@ -52,15 +51,16 @@ class PodcastManager {
    }
  }

+  /**
+   *
+   * @param {import('../models/LibraryItem')} libraryItem
+   * @param {import('../utils/podcastUtils').RssPodcastEpisode[]} episodesToDownload
+   * @param {boolean} isAutoDownload - If this download was triggered by auto download
+   */
  async downloadPodcastEpisodes(libraryItem, episodesToDownload, isAutoDownload) {
-    let index = Math.max(...libraryItem.media.episodes.filter((ep) => ep.index == null || isNaN(ep.index)).map((ep) => Number(ep.index))) + 1
    for (const ep of episodesToDownload) {
-      const newPe = new PodcastEpisode()
-      newPe.setData(ep, index++)
-      newPe.libraryItemId = libraryItem.id
-      newPe.podcastId = libraryItem.media.id
      const newPeDl = new PodcastEpisodeDownload()
-      newPeDl.setData(newPe, libraryItem, isAutoDownload, libraryItem.libraryId)
+      newPeDl.setData(ep, libraryItem, isAutoDownload, libraryItem.libraryId)
      this.startPodcastEpisodeDownload(newPeDl)
    }
  }
@@ -86,20 +86,20 @@ class PodcastManager {
      key: 'MessageDownloadingEpisode'
    }
    const taskDescriptionString = {
-      text: `Downloading episode "${podcastEpisodeDownload.podcastEpisode.title}".`,
+      text: `Downloading episode "${podcastEpisodeDownload.episodeTitle}".`,
      key: 'MessageTaskDownloadingEpisodeDescription',
-      subs: [podcastEpisodeDownload.podcastEpisode.title]
+      subs: [podcastEpisodeDownload.episodeTitle]
    }
    const task = TaskManager.createAndAddTask('download-podcast-episode', taskTitleString, taskDescriptionString, false, taskData)

    SocketAuthority.emitter('episode_download_started', podcastEpisodeDownload.toJSONForClient())
    this.currentDownload = podcastEpisodeDownload

-    // If this file already exists then append the episode id to the filename
+    // If this file already exists then append a uuid to the filename
    //  e.g. "/tagesschau 20 Uhr.mp3" becomes "/tagesschau 20 Uhr (ep_asdfasdf).mp3"
    //  this handles podcasts where every title is the same (ref https://github.com/advplyr/audiobookshelf/issues/1802)
    if (await fs.pathExists(this.currentDownload.targetPath)) {
-      this.currentDownload.appendEpisodeId = true
+      this.currentDownload.appendRandomId = true
    }

    // Ignores all added files to this dir
@@ -140,7 +140,7 @@ class PodcastManager {
        }
        task.setFailed(taskFailedString)
      } else {
-        Logger.info(`[PodcastManager] Successfully downloaded podcast episode "${this.currentDownload.podcastEpisode.title}"`)
+        Logger.info(`[PodcastManager] Successfully downloaded podcast episode "${this.currentDownload.episodeTitle}"`)
        this.currentDownload.setFinished(true)
        task.setFinished()
      }
@@ -166,47 +166,61 @@ class PodcastManager {
    }
  }

+  /**
+   * Scans the downloaded audio file, create the podcast episode, remove oldest episode if necessary
+   * @returns {Promise<boolean>} - Returns true if added
+   */
  async scanAddPodcastEpisodeAudioFile() {
-    const libraryFile = await this.getLibraryFile(this.currentDownload.targetPath, this.currentDownload.targetRelPath)
+    const libraryFile = new LibraryFile()
+    await libraryFile.setDataFromPath(this.currentDownload.targetPath, this.currentDownload.targetRelPath)

    const audioFile = await this.probeAudioFile(libraryFile)
    if (!audioFile) {
      return false
    }

-    const libraryItem = await Database.libraryItemModel.getOldById(this.currentDownload.libraryItem.id)
+    const libraryItem = await Database.libraryItemModel.getExpandedById(this.currentDownload.libraryItem.id)
    if (!libraryItem) {
      Logger.error(`[PodcastManager] Podcast Episode finished but library item was not found ${this.currentDownload.libraryItem.id}`)
      return false
    }

-    const podcastEpisode = this.currentDownload.podcastEpisode
-    podcastEpisode.audioFile = audioFile
+    const podcastEpisode = await Database.podcastEpisodeModel.createFromRssPodcastEpisode(this.currentDownload.rssPodcastEpisode, libraryItem.media.id, audioFile)

-    if (audioFile.chapters?.length) {
-      podcastEpisode.chapters = audioFile.chapters.map((ch) => ({ ...ch }))
-    }
+    libraryItem.libraryFiles.push(libraryFile.toJSON())
+    libraryItem.changed('libraryFiles', true)

-    libraryItem.media.addPodcastEpisode(podcastEpisode)
-    if (libraryItem.isInvalid) {
-      // First episode added to an empty podcast
-      libraryItem.isInvalid = false
-    }
-    libraryItem.libraryFiles.push(libraryFile)
+    libraryItem.media.podcastEpisodes.push(podcastEpisode)

    if (this.currentDownload.isAutoDownload) {
      // Check setting maxEpisodesToKeep and remove episode if necessary
-      if (libraryItem.media.maxEpisodesToKeep && libraryItem.media.episodesWithPubDate.length > libraryItem.media.maxEpisodesToKeep) {
-        Logger.info(`[PodcastManager] # of episodes (${libraryItem.media.episodesWithPubDate.length}) exceeds max episodes to keep (${libraryItem.media.maxEpisodesToKeep})`)
-        await this.removeOldestEpisode(libraryItem, podcastEpisode.id)
+      const numEpisodesWithPubDate = libraryItem.media.podcastEpisodes.filter((ep) => !!ep.publishedAt).length
+      if (libraryItem.media.maxEpisodesToKeep && numEpisodesWithPubDate > libraryItem.media.maxEpisodesToKeep) {
+        Logger.info(`[PodcastManager] # of episodes (${numEpisodesWithPubDate}) exceeds max episodes to keep (${libraryItem.media.maxEpisodesToKeep})`)
+        const episodeToRemove = await this.getRemoveOldestEpisode(libraryItem, podcastEpisode.id)
+        if (episodeToRemove) {
+          // Remove episode from playlists
+          await Database.playlistModel.removeMediaItemsFromPlaylists([episodeToRemove.id])
+          // Remove media progress for this episode
+          await Database.mediaProgressModel.destroy({
+            where: {
+              mediaItemId: episodeToRemove.id
+            }
+          })
+          await episodeToRemove.destroy()
+          libraryItem.media.podcastEpisodes = libraryItem.media.podcastEpisodes.filter((ep) => ep.id !== episodeToRemove.id)
+
+          // Remove library file
+          libraryItem.libraryFiles = libraryItem.libraryFiles.filter((lf) => lf.ino !== episodeToRemove.audioFile.ino)
+        }
      }
    }

-    libraryItem.updatedAt = Date.now()
-    await Database.updateLibraryItem(libraryItem)
-    SocketAuthority.emitter('item_updated', libraryItem.toJSONExpanded())
-    const podcastEpisodeExpanded = podcastEpisode.toJSONExpanded()
-    podcastEpisodeExpanded.libraryItem = libraryItem.toJSONExpanded()
+    await libraryItem.save()
+
+    SocketAuthority.emitter('item_updated', libraryItem.toOldJSONExpanded())
+    const podcastEpisodeExpanded = podcastEpisode.toOldJSONExpanded(libraryItem.id)
+    podcastEpisodeExpanded.libraryItem = libraryItem.toOldJSONExpanded()
    SocketAuthority.emitter('episode_added', podcastEpisodeExpanded)

    if (this.currentDownload.isAutoDownload) {
@@ -217,45 +231,53 @@ class PodcastManager {
    return true
  }

-  async removeOldestEpisode(libraryItem, episodeIdJustDownloaded) {
-    var smallestPublishedAt = 0
-    var oldestEpisode = null
-    libraryItem.media.episodesWithPubDate
-      .filter((ep) => ep.id !== episodeIdJustDownloaded)
-      .forEach((ep) => {
-        if (!smallestPublishedAt || ep.publishedAt < smallestPublishedAt) {
-          smallestPublishedAt = ep.publishedAt
-          oldestEpisode = ep
-        }
-      })
-    // TODO: Should we check for open playback sessions for this episode?
-    // TODO: remove all user progress for this episode
+  /**
+   * Find oldest episode publishedAt and delete the audio file
+   *
+   * @param {import('../models/LibraryItem').LibraryItemExpanded} libraryItem
+   * @param {string} episodeIdJustDownloaded
+   * @returns {Promise<import('../models/PodcastEpisode')|null>} - Returns the episode to remove
+   */
+  async getRemoveOldestEpisode(libraryItem, episodeIdJustDownloaded) {
+    let smallestPublishedAt = 0
+    /** @type {import('../models/PodcastEpisode')} */
+    let oldestEpisode = null
+
+    /** @type {import('../models/PodcastEpisode')[]} */
+    const podcastEpisodes = libraryItem.media.podcastEpisodes
+
+    for (const ep of podcastEpisodes) {
+      if (ep.id === episodeIdJustDownloaded || !ep.publishedAt) continue
+
+      if (!smallestPublishedAt || ep.publishedAt < smallestPublishedAt) {
+        smallestPublishedAt = ep.publishedAt
+        oldestEpisode = ep
+      }
+    }
+
    if (oldestEpisode?.audioFile) {
      Logger.info(`[PodcastManager] Deleting oldest episode "${oldestEpisode.title}"`)
      const successfullyDeleted = await removeFile(oldestEpisode.audioFile.metadata.path)
      if (successfullyDeleted) {
-        libraryItem.media.removeEpisode(oldestEpisode.id)
-        libraryItem.removeLibraryFile(oldestEpisode.audioFile.ino)
-        return true
+        return oldestEpisode
      } else {
        Logger.warn(`[PodcastManager] Failed to remove oldest episode "${oldestEpisode.title}"`)
      }
    }
-    return false
-  }
-
-  async getLibraryFile(path, relPath) {
-    var newLibFile = new LibraryFile()
-    await newLibFile.setDataFromPath(path, relPath)
-    return newLibFile
+    return null
  }

+  /**
+   *
+   * @param {LibraryFile} libraryFile
+   * @returns {Promise<AudioFile|null>}
+   */
  async probeAudioFile(libraryFile) {
    const path = libraryFile.metadata.path
    const mediaProbeData = await prober.probe(path)
    if (mediaProbeData.error) {
      Logger.error(`[PodcastManager] Podcast Episode downloaded but failed to probe "${path}"`, mediaProbeData.error)
-      return false
+      return null
    }
    const newAudioFile = new AudioFile()
    newAudioFile.setDataFromProbe(libraryFile, mediaProbeData)
@@ -263,18 +285,23 @@ class PodcastManager {
    return newAudioFile
  }

-  // Returns false if auto download episodes was disabled (disabled if reaches max failed checks)
+  /**
+   *
+   * @param {import('../models/LibraryItem')} libraryItem
+   * @returns {Promise<boolean>} - Returns false if auto download episodes was disabled (disabled if reaches max failed checks)
+   */
  async runEpisodeCheck(libraryItem) {
-    const lastEpisodeCheckDate = new Date(libraryItem.media.lastEpisodeCheck || 0)
-    const latestEpisodePublishedAt = libraryItem.media.latestEpisodePublished
-    Logger.info(`[PodcastManager] runEpisodeCheck: "${libraryItem.media.metadata.title}" | Last check: ${lastEpisodeCheckDate} | ${latestEpisodePublishedAt ? `Latest episode pubDate: ${new Date(latestEpisodePublishedAt)}` : 'No latest episode'}`)
+    const lastEpisodeCheck = libraryItem.media.lastEpisodeCheck?.valueOf() || 0
+    const latestEpisodePublishedAt = libraryItem.media.getLatestEpisodePublishedAt()
+
+    Logger.info(`[PodcastManager] runEpisodeCheck: "${libraryItem.media.title}" | Last check: ${new Date(lastEpisodeCheck)} | ${latestEpisodePublishedAt ? `Latest episode pubDate: ${new Date(latestEpisodePublishedAt)}` : 'No latest episode'}`)

    // Use latest episode pubDate if exists OR fallback to using lastEpisodeCheckDate
    //    lastEpisodeCheckDate will be the current time when adding a new podcast
    const dateToCheckForEpisodesAfter = latestEpisodePublishedAt || lastEpisodeCheckDate
-    Logger.debug(`[PodcastManager] runEpisodeCheck: "${libraryItem.media.metadata.title}" checking for episodes after ${new Date(dateToCheckForEpisodesAfter)}`)
+    Logger.debug(`[PodcastManager] runEpisodeCheck: "${libraryItem.media.title}" checking for episodes after ${new Date(dateToCheckForEpisodesAfter)}`)

-    var newEpisodes = await this.checkPodcastForNewEpisodes(libraryItem, dateToCheckForEpisodesAfter, libraryItem.media.maxNewEpisodesToDownload)
+    const newEpisodes = await this.checkPodcastForNewEpisodes(libraryItem, dateToCheckForEpisodesAfter, libraryItem.media.maxNewEpisodesToDownload)
    Logger.debug(`[PodcastManager] runEpisodeCheck: ${newEpisodes?.length || 'N/A'} episodes found`)

    if (!newEpisodes) {
@@ -283,37 +310,48 @@ class PodcastManager {
      if (!this.failedCheckMap[libraryItem.id]) this.failedCheckMap[libraryItem.id] = 0
      this.failedCheckMap[libraryItem.id]++
      if (this.failedCheckMap[libraryItem.id] >= this.MaxFailedEpisodeChecks) {
-        Logger.error(`[PodcastManager] runEpisodeCheck ${this.failedCheckMap[libraryItem.id]} failed attempts at checking episodes for "${libraryItem.media.metadata.title}" - disabling auto download`)
+        Logger.error(`[PodcastManager] runEpisodeCheck ${this.failedCheckMap[libraryItem.id]} failed attempts at checking episodes for "${libraryItem.media.title}" - disabling auto download`)
        libraryItem.media.autoDownloadEpisodes = false
        delete this.failedCheckMap[libraryItem.id]
      } else {
-        Logger.warn(`[PodcastManager] runEpisodeCheck ${this.failedCheckMap[libraryItem.id]} failed attempts at checking episodes for "${libraryItem.media.metadata.title}"`)
+        Logger.warn(`[PodcastManager] runEpisodeCheck ${this.failedCheckMap[libraryItem.id]} failed attempts at checking episodes for "${libraryItem.media.title}"`)
      }
    } else if (newEpisodes.length) {
      delete this.failedCheckMap[libraryItem.id]
-      Logger.info(`[PodcastManager] Found ${newEpisodes.length} new episodes for podcast "${libraryItem.media.metadata.title}" - starting download`)
+      Logger.info(`[PodcastManager] Found ${newEpisodes.length} new episodes for podcast "${libraryItem.media.title}" - starting download`)
      this.downloadPodcastEpisodes(libraryItem, newEpisodes, true)
    } else {
      delete this.failedCheckMap[libraryItem.id]
-      Logger.debug(`[PodcastManager] No new episodes for "${libraryItem.media.metadata.title}"`)
+      Logger.debug(`[PodcastManager] No new episodes for "${libraryItem.media.title}"`)
    }

-    libraryItem.media.lastEpisodeCheck = Date.now()
-    libraryItem.updatedAt = Date.now()
-    await Database.updateLibraryItem(libraryItem)
-    SocketAuthority.emitter('item_updated', libraryItem.toJSONExpanded())
+    libraryItem.media.lastEpisodeCheck = new Date()
+    await libraryItem.media.save()
+
+    libraryItem.changed('updatedAt', true)
+    await libraryItem.save()
+
+    SocketAuthority.emitter('item_updated', libraryItem.toOldJSONExpanded())
+
    return libraryItem.media.autoDownloadEpisodes
  }

+  /**
+   *
+   * @param {import('../models/LibraryItem')} podcastLibraryItem
+   * @param {number} dateToCheckForEpisodesAfter - Unix timestamp
+   * @param {number} maxNewEpisodes
+   * @returns {Promise<import('../utils/podcastUtils').RssPodcastEpisode[]|null>}
+   */
  async checkPodcastForNewEpisodes(podcastLibraryItem, dateToCheckForEpisodesAfter, maxNewEpisodes = 3) {
-    if (!podcastLibraryItem.media.metadata.feedUrl) {
-      Logger.error(`[PodcastManager] checkPodcastForNewEpisodes no feed url for ${podcastLibraryItem.media.metadata.title} (ID: ${podcastLibraryItem.id})`)
-      return false
+    if (!podcastLibraryItem.media.feedURL) {
+      Logger.error(`[PodcastManager] checkPodcastForNewEpisodes no feed url for ${podcastLibraryItem.media.title} (ID: ${podcastLibraryItem.id})`)
+      return null
    }
-    const feed = await getPodcastFeed(podcastLibraryItem.media.metadata.feedUrl)
+    const feed = await getPodcastFeed(podcastLibraryItem.media.feedURL)
    if (!feed?.episodes) {
-      Logger.error(`[PodcastManager] checkPodcastForNewEpisodes invalid feed payload for ${podcastLibraryItem.media.metadata.title} (ID: ${podcastLibraryItem.id})`, feed)
-      return false
+      Logger.error(`[PodcastManager] checkPodcastForNewEpisodes invalid feed payload for ${podcastLibraryItem.media.title} (ID: ${podcastLibraryItem.id})`, feed)
+      return null
    }

    // Filter new and not already has
@@ -326,23 +364,34 @@ class PodcastManager {
    return newEpisodes
  }

+  /**
+   *
+   * @param {import('../models/LibraryItem')} libraryItem
+   * @param {*} maxEpisodesToDownload
+   * @returns {Promise<import('../utils/podcastUtils').RssPodcastEpisode[]>}
+   */
  async checkAndDownloadNewEpisodes(libraryItem, maxEpisodesToDownload) {
-    const lastEpisodeCheckDate = new Date(libraryItem.media.lastEpisodeCheck || 0)
-    Logger.info(`[PodcastManager] checkAndDownloadNewEpisodes for "${libraryItem.media.metadata.title}" - Last episode check: ${lastEpisodeCheckDate}`)
-    var newEpisodes = await this.checkPodcastForNewEpisodes(libraryItem, libraryItem.media.lastEpisodeCheck, maxEpisodesToDownload)
-    if (newEpisodes.length) {
-      Logger.info(`[PodcastManager] Found ${newEpisodes.length} new episodes for podcast "${libraryItem.media.metadata.title}" - starting download`)
+    const lastEpisodeCheck = libraryItem.media.lastEpisodeCheck?.valueOf() || 0
+    const lastEpisodeCheckDate = lastEpisodeCheck > 0 ? libraryItem.media.lastEpisodeCheck : 'Never'
+    Logger.info(`[PodcastManager] checkAndDownloadNewEpisodes for "${libraryItem.media.title}" - Last episode check: ${lastEpisodeCheckDate}`)
+
+    const newEpisodes = await this.checkPodcastForNewEpisodes(libraryItem, lastEpisodeCheck, maxEpisodesToDownload)
+    if (newEpisodes?.length) {
+      Logger.info(`[PodcastManager] Found ${newEpisodes.length} new episodes for podcast "${libraryItem.media.title}" - starting download`)
      this.downloadPodcastEpisodes(libraryItem, newEpisodes, false)
    } else {
-      Logger.info(`[PodcastManager] No new episodes found for podcast "${libraryItem.media.metadata.title}"`)
+      Logger.info(`[PodcastManager] No new episodes found for podcast "${libraryItem.media.title}"`)
    }

-    libraryItem.media.lastEpisodeCheck = Date.now()
-    libraryItem.updatedAt = Date.now()
-    await Database.updateLibraryItem(libraryItem)
-    SocketAuthority.emitter('item_updated', libraryItem.toJSONExpanded())
+    libraryItem.media.lastEpisodeCheck = new Date()
+    await libraryItem.media.save()

-    return newEpisodes
+    libraryItem.changed('updatedAt', true)
+    await libraryItem.save()
+
+    SocketAuthority.emitter('item_updated', libraryItem.toOldJSONExpanded())
+
+    return newEpisodes || []
  }

  async findEpisode(rssFeedUrl, searchTitle) {
@@ -518,64 +567,123 @@ class PodcastManager {
        continue
      }

-      const newPodcastMetadata = {
-        title: feed.metadata.title,
-        author: feed.metadata.author,
-        description: feed.metadata.description,
-        releaseDate: '',
-        genres: [...feed.metadata.categories],
-        feedUrl: feed.metadata.feedUrl,
-        imageUrl: feed.metadata.image,
-        itunesPageUrl: '',
-        itunesId: '',
-        itunesArtistId: '',
-        language: '',
-        numEpisodes: feed.numEpisodes
-      }
+      let newLibraryItem = null
+      const transaction = await Database.sequelize.transaction()
+      try {
+        const libraryItemFolderStats = await getFileTimestampsWithIno(podcastPath)

-      const libraryItemFolderStats = await getFileTimestampsWithIno(podcastPath)
-      const libraryItemPayload = {
-        path: podcastPath,
-        relPath: podcastFilename,
-        folderId: folder.id,
-        libraryId: folder.libraryId,
-        ino: libraryItemFolderStats.ino,
-        mtimeMs: libraryItemFolderStats.mtimeMs || 0,
-        ctimeMs: libraryItemFolderStats.ctimeMs || 0,
-        birthtimeMs: libraryItemFolderStats.birthtimeMs || 0,
-        media: {
-          metadata: newPodcastMetadata,
-          autoDownloadEpisodes
+        const podcastPayload = {
+          autoDownloadEpisodes,
+          metadata: {
+            title: feed.metadata.title,
+            author: feed.metadata.author,
+            description: feed.metadata.description,
+            releaseDate: '',
+            genres: [...feed.metadata.categories],
+            feedUrl: feed.metadata.feedUrl,
+            imageUrl: feed.metadata.image,
+            itunesPageUrl: '',
+            itunesId: '',
+            itunesArtistId: '',
+            language: '',
+            numEpisodes: feed.numEpisodes
+          }
        }
+        const podcast = await Database.podcastModel.createFromRequest(podcastPayload, transaction)
+
+        newLibraryItem = await Database.libraryItemModel.create(
+          {
+            ino: libraryItemFolderStats.ino,
+            path: podcastPath,
+            relPath: podcastFilename,
+            mediaId: podcast.id,
+            mediaType: 'podcast',
+            isFile: false,
+            isMissing: false,
+            isInvalid: false,
+            mtime: libraryItemFolderStats.mtimeMs || 0,
+            ctime: libraryItemFolderStats.ctimeMs || 0,
+            birthtime: libraryItemFolderStats.birthtimeMs || 0,
+            size: 0,
+            libraryFiles: [],
+            extraData: {},
+            libraryId: folder.libraryId,
+            libraryFolderId: folder.id
+          },
+          { transaction }
+        )
+
+        await transaction.commit()
+      } catch (error) {
+        await transaction.rollback()
+        Logger.error(`[PodcastManager] createPodcastsFromFeedUrls: Failed to create podcast library item for "${feed.metadata.title}"`, error)
+        const taskTitleStringFeed = {
+          text: 'OPML import feed',
+          key: 'MessageTaskOpmlImportFeed'
+        }
+        const taskDescriptionStringPodcast = {
+          text: `Creating podcast "${feed.metadata.title}"`,
+          key: 'MessageTaskOpmlImportFeedPodcastDescription',
+          subs: [feed.metadata.title]
+        }
+        const taskErrorString = {
+          text: 'Failed to create podcast library item',
+          key: 'MessageTaskOpmlImportFeedPodcastFailed'
+        }
+        TaskManager.createAndEmitFailedTask('opml-import-feed', taskTitleStringFeed, taskDescriptionStringPodcast, taskErrorString)
+        continue
      }

-      const libraryItem = new LibraryItem()
-      libraryItem.setData('podcast', libraryItemPayload)
+      newLibraryItem.media = await newLibraryItem.getMediaExpanded()

      // Download and save cover image
-      if (newPodcastMetadata.imageUrl) {
-        // TODO: Scan cover image to library files
+      if (typeof feed.metadata.image === 'string' && feed.metadata.image.startsWith('http')) {
        // Podcast cover will always go into library item folder
-        const coverResponse = await CoverManager.downloadCoverFromUrl(libraryItem, newPodcastMetadata.imageUrl, true)
-        if (coverResponse) {
-          if (coverResponse.error) {
-            Logger.error(`[PodcastManager] createPodcastsFromFeedUrls: Download cover error from "${newPodcastMetadata.imageUrl}": ${coverResponse.error}`)
-          } else if (coverResponse.cover) {
-            libraryItem.media.coverPath = coverResponse.cover
+        const coverResponse = await CoverManager.downloadCoverFromUrlNew(feed.metadata.image, newLibraryItem.id, newLibraryItem.path, true)
+        if (coverResponse.error) {
+          Logger.error(`[PodcastManager] Download cover error from "${feed.metadata.image}": ${coverResponse.error}`)
+        } else if (coverResponse.cover) {
+          const coverImageFileStats = await getFileTimestampsWithIno(coverResponse.cover)
+          if (!coverImageFileStats) {
+            Logger.error(`[PodcastManager] Failed to get cover image stats for "${coverResponse.cover}"`)
+          } else {
+            // Add libraryFile to libraryItem and coverPath to podcast
+            const newLibraryFile = {
+              ino: coverImageFileStats.ino,
+              fileType: 'image',
+              addedAt: Date.now(),
+              updatedAt: Date.now(),
+              metadata: {
+                filename: Path.basename(coverResponse.cover),
+                ext: Path.extname(coverResponse.cover).slice(1),
+                path: coverResponse.cover,
+                relPath: Path.basename(coverResponse.cover),
+                size: coverImageFileStats.size,
+                mtimeMs: coverImageFileStats.mtimeMs || 0,
+                ctimeMs: coverImageFileStats.ctimeMs || 0,
+                birthtimeMs: coverImageFileStats.birthtimeMs || 0
+              }
+            }
+            newLibraryItem.libraryFiles.push(newLibraryFile)
+            newLibraryItem.changed('libraryFiles', true)
+            await newLibraryItem.save()
+
+            newLibraryItem.media.coverPath = coverResponse.cover
+            await newLibraryItem.media.save()
          }
        }
      }

-      await Database.createLibraryItem(libraryItem)
-      SocketAuthority.emitter('item_added', libraryItem.toJSONExpanded())
+      SocketAuthority.emitter('item_added', newLibraryItem.toOldJSONExpanded())

      // Turn on podcast auto download cron if not already on
-      if (libraryItem.media.autoDownloadEpisodes) {
-        cronManager.checkUpdatePodcastCron(libraryItem)
+      if (newLibraryItem.media.autoDownloadEpisodes) {
+        cronManager.checkUpdatePodcastCron(newLibraryItem)
      }

      numPodcastsAdded++
    }
+
    const taskFinishedString = {
      text: `Added ${numPodcastsAdded} podcasts`,
      key: 'MessageTaskOpmlImportFinished',
@@ -62,6 +62,13 @@ const parseNameString = require('../utils/parsers/parseNameString')
 * @property {ChapterObject[]} chapters
 * @property {Object} metaTags
 * @property {string} mimeType
+ *
+ * @typedef AudioTrackProperties
+ * @property {string} title
+ * @property {string} contentUrl
+ * @property {number} startOffset
+ *
+ * @typedef {AudioFileObject & AudioTrackProperties} AudioTrack
 */

 class Book extends Model {
@@ -367,16 +374,6 @@ class Book extends Model {
    return this.audioFiles.filter((af) => !af.exclude)
  }

-  get trackList() {
-    let startOffset = 0
-    return this.includedAudioFiles.map((af) => {
-      const track = structuredClone(af)
-      track.startOffset = startOffset
-      startOffset += track.duration
-      return track
-    })
-  }
-
  get hasMediaFiles() {
    return !!this.hasAudioTracks || !!this.ebookFile
  }
@@ -385,6 +382,59 @@ class Book extends Model {
    return !!this.includedAudioFiles.length
  }

+  /**
+   * Supported mime types are sent from the web client and are retrieved using the browser Audio player "canPlayType" function.
+   *
+   * @param {string[]} supportedMimeTypes
+   * @returns {boolean}
+   */
+  checkCanDirectPlay(supportedMimeTypes) {
+    if (!Array.isArray(supportedMimeTypes)) {
+      Logger.error(`[Book] checkCanDirectPlay: supportedMimeTypes is not an array`, supportedMimeTypes)
+      return false
+    }
+    return this.includedAudioFiles.every((af) => supportedMimeTypes.includes(af.mimeType))
+  }
+
+  /**
+   * Get the track list to be used in client audio players
+   * AudioTrack is the AudioFile with startOffset, contentUrl and title
+   *
+   * @param {string} libraryItemId
+   * @returns {AudioTrack[]}
+   */
+  getTracklist(libraryItemId) {
+    let startOffset = 0
+    return this.includedAudioFiles.map((af) => {
+      const track = structuredClone(af)
+      track.title = af.metadata.filename
+      track.startOffset = startOffset
+      track.contentUrl = `${global.RouterBasePath}/api/items/${libraryItemId}/file/${track.ino}`
+      startOffset += track.duration
+      return track
+    })
+  }
+
+  /**
+   *
+   * @returns {ChapterObject[]}
+   */
+  getChapters() {
+    return structuredClone(this.chapters) || []
+  }
+
+  getPlaybackTitle() {
+    return this.title
+  }
+
+  getPlaybackAuthor() {
+    return this.authorName
+  }
+
+  getPlaybackDuration() {
+    return this.duration
+  }
+
  /**
   * Total file size of all audio files and ebook file
   *
@@ -635,7 +685,7 @@ class Book extends Model {
      metadata: this.oldMetadataToJSONMinified(),
      coverPath: this.coverPath,
      tags: [...(this.tags || [])],
-      numTracks: this.trackList.length,
+      numTracks: this.includedAudioFiles.length,
      numAudioFiles: this.audioFiles?.length || 0,
      numChapters: this.chapters?.length || 0,
      duration: this.duration,
@@ -666,7 +716,7 @@ class Book extends Model {
      ebookFile: structuredClone(this.ebookFile),
      duration: this.duration,
      size: this.size,
-      tracks: structuredClone(this.trackList)
+      tracks: this.getTracklist(libraryItemId)
    }
  }
 }
@@ -112,15 +112,15 @@ class FeedEpisode extends Model {
  /**
   * If chapters for an audiobook match the audio tracks then use chapter titles instead of audio file names
   *
+   * @param {import('./Book').AudioTrack[]} trackList
   * @param {import('./Book')} book
   * @returns {boolean}
   */
-  static checkUseChapterTitlesForEpisodes(book) {
-    const tracks = book.trackList || []
+  static checkUseChapterTitlesForEpisodes(trackList, book) {
    const chapters = book.chapters || []
-    if (tracks.length !== chapters.length) return false
-    for (let i = 0; i < tracks.length; i++) {
-      if (Math.abs(chapters[i].start - tracks[i].startOffset) >= 1) {
+    if (trackList.length !== chapters.length) return false
+    for (let i = 0; i < trackList.length; i++) {
+      if (Math.abs(chapters[i].start - trackList[i].startOffset) >= 1) {
        return false
      }
    }
@@ -148,7 +148,7 @@ class FeedEpisode extends Model {
    const contentUrl = `/feed/${slug}/item/${episodeId}/media${Path.extname(audioTrack.metadata.filename)}`

    let title = Path.basename(audioTrack.metadata.filename, Path.extname(audioTrack.metadata.filename))
-    if (book.trackList.length == 1) {
+    if (book.includedAudioFiles.length == 1) {
      // If audiobook is a single file, use book title instead of chapter/file title
      title = book.title
    } else {
@@ -185,11 +185,12 @@ class FeedEpisode extends Model {
   * @returns {Promise<FeedEpisode[]>}
   */
  static async createFromAudiobookTracks(libraryItemExpanded, feed, slug, transaction) {
-    const useChapterTitles = this.checkUseChapterTitlesForEpisodes(libraryItemExpanded.media)
+    const trackList = libraryItemExpanded.getTrackList()
+    const useChapterTitles = this.checkUseChapterTitlesForEpisodes(trackList, libraryItemExpanded.media)

    const feedEpisodeObjs = []
    let numExisting = 0
-    for (const track of libraryItemExpanded.media.trackList) {
+    for (const track of trackList) {
      // Check for existing episode by filepath
      const existingEpisode = feed.feedEpisodes?.find((episode) => {
        return episode.filePath === track.metadata.path
@@ -204,7 +205,7 @@ class FeedEpisode extends Model {

  /**
   *
-   * @param {import('./Book')[]} books
+   * @param {import('./Book').BookExpandedWithLibraryItem[]} books
   * @param {import('./Feed')} feed
   * @param {string} slug
   * @param {import('sequelize').Transaction} transaction
@@ -218,8 +219,9 @@ class FeedEpisode extends Model {
    const feedEpisodeObjs = []
    let numExisting = 0
    for (const book of books) {
-      const useChapterTitles = this.checkUseChapterTitlesForEpisodes(book)
-      for (const track of book.trackList) {
+      const trackList = book.libraryItem.getTrackList()
+      const useChapterTitles = this.checkUseChapterTitlesForEpisodes(trackList, book)
+      for (const track of trackList) {
        // Check for existing episode by filepath
        const existingEpisode = feed.feedEpisodes?.find((episode) => {
          return episode.filePath === track.metadata.path
@@ -497,6 +497,57 @@ class LibraryItem extends Model {
    return libraryItem
  }

+  /**
+   *
+   * @param {import('sequelize').WhereOptions} where
+   * @param {import('sequelize').IncludeOptions} [include]
+   * @returns {Promise<LibraryItemExpanded>}
+   */
+  static async findOneExpanded(where, include = null) {
+    const libraryItem = await this.findOne({
+      where,
+      include
+    })
+    if (!libraryItem) {
+      Logger.error(`[LibraryItem] Library item not found`)
+      return null
+    }
+
+    if (libraryItem.mediaType === 'podcast') {
+      libraryItem.media = await libraryItem.getMedia({
+        include: [
+          {
+            model: this.sequelize.models.podcastEpisode
+          }
+        ]
+      })
+    } else {
+      libraryItem.media = await libraryItem.getMedia({
+        include: [
+          {
+            model: this.sequelize.models.author,
+            through: {
+              attributes: []
+            }
+          },
+          {
+            model: this.sequelize.models.series,
+            through: {
+              attributes: ['id', 'sequence']
+            }
+          }
+        ],
+        order: [
+          [this.sequelize.models.author, this.sequelize.models.bookAuthor, 'createdAt', 'ASC'],
+          [this.sequelize.models.series, 'bookSeries', 'createdAt', 'ASC']
+        ]
+      })
+    }
+
+    if (!libraryItem.media) return null
+    return libraryItem
+  }
+
  /**
   * Get old library item by id
   * @param {string} libraryItemId
@@ -1176,6 +1227,22 @@ class LibraryItem extends Model {
    }
  }

+  /**
+   * Get the track list to be used in client audio players
+   * AudioTrack is the AudioFile with startOffset and contentUrl
+   * Podcasts must have an episodeId to get the track list
+   *
+   * @param {string} [episodeId]
+   * @returns {import('./Book').AudioTrack[]}
+   */
+  getTrackList(episodeId) {
+    if (!this.media) {
+      Logger.error(`[LibraryItem] getTrackList: Library item "${this.id}" does not have media`)
+      return []
+    }
+    return this.media.getTracklist(this.id, episodeId)
+  }
+
  /**
   *
   * @param {string} ino
@@ -76,42 +76,26 @@ class MediaItemShare extends Model {
  }

  /**
+   * Expanded book that includes library settings
   *
   * @param {string} mediaItemId
   * @param {string} mediaItemType
-   * @returns {Promise<import('../objects/LibraryItem')>}
+   * @returns {Promise<import('./LibraryItem').LibraryItemExpanded>}
   */
-  static async getMediaItemsOldLibraryItem(mediaItemId, mediaItemType) {
+  static async getMediaItemsLibraryItem(mediaItemId, mediaItemType) {
+    /** @type {typeof import('./LibraryItem')} */
+    const libraryItemModel = this.sequelize.models.libraryItem
+
    if (mediaItemType === 'book') {
-      const book = await this.sequelize.models.book.findByPk(mediaItemId, {
-        include: [
-          {
-            model: this.sequelize.models.author,
-            through: {
-              attributes: []
-            }
-          },
-          {
-            model: this.sequelize.models.series,
-            through: {
-              attributes: ['sequence']
-            }
-          },
-          {
-            model: this.sequelize.models.libraryItem,
-            include: {
-              model: this.sequelize.models.library,
-              attributes: ['settings']
-            }
-          }
-        ]
-      })
-      const libraryItem = book.libraryItem
-      libraryItem.media = book
-      delete book.libraryItem
-      const oldLibraryItem = this.sequelize.models.libraryItem.getOldLibraryItem(libraryItem)
-      oldLibraryItem.librarySettings = libraryItem.library.settings
-      return oldLibraryItem
+      const libraryItem = await libraryItemModel.findOneExpanded(
+        { mediaId: mediaItemId },
+        {
+          model: this.sequelize.models.library,
+          attributes: ['settings']
+        }
+      )
+
+      return libraryItem
    }
    return null
  }
@@ -1,5 +1,6 @@
 const { DataTypes, Model, Op } = require('sequelize')
 const Logger = require('../Logger')
+const SocketAuthority = require('../SocketAuthority')

 class Playlist extends Model {
  constructor(values, options) {
@@ -163,6 +164,49 @@ class Playlist extends Model {
    return playlists
  }

+  /**
+   * Removes media items and re-orders playlists
+   *
+   * @param {string[]} mediaItemIds
+   */
+  static async removeMediaItemsFromPlaylists(mediaItemIds) {
+    if (!mediaItemIds?.length) return
+
+    const playlistsWithItem = await this.getPlaylistsForMediaItemIds(mediaItemIds)
+
+    if (!playlistsWithItem.length) return
+
+    for (const playlist of playlistsWithItem) {
+      let numMediaItems = playlist.playlistMediaItems.length
+
+      let order = 1
+      // Remove items in playlist and re-order
+      for (const playlistMediaItem of playlist.playlistMediaItems) {
+        if (mediaItemIds.includes(playlistMediaItem.mediaItemId)) {
+          await playlistMediaItem.destroy()
+          numMediaItems--
+        } else {
+          if (playlistMediaItem.order !== order) {
+            playlistMediaItem.update({
+              order
+            })
+          }
+          order++
+        }
+      }
+
+      // If playlist is now empty then remove it
+      const jsonExpanded = await playlist.getOldJsonExpanded()
+      if (!numMediaItems) {
+        Logger.info(`[ApiRouter] Playlist "${playlist.name}" has no more items - removing it`)
+        await playlist.destroy()
+        SocketAuthority.clientEmitter(playlist.userId, 'playlist_removed', jsonExpanded)
+      } else {
+        SocketAuthority.clientEmitter(playlist.userId, 'playlist_updated', jsonExpanded)
+      }
+    }
+  }
+
  /**
   * Initialize model
   * @param {import('../Database').sequelize} sequelize
@@ -126,6 +126,45 @@ class Podcast extends Model {
    }
  }

+  /**
+   * Payload from the /api/podcasts POST endpoint
+   *
+   * @param {Object} payload
+   * @param {import('sequelize').Transaction} transaction
+   */
+  static async createFromRequest(payload, transaction) {
+    const title = typeof payload.metadata.title === 'string' ? payload.metadata.title : null
+    const autoDownloadSchedule = typeof payload.autoDownloadSchedule === 'string' ? payload.autoDownloadSchedule : null
+    const genres = Array.isArray(payload.metadata.genres) && payload.metadata.genres.every((g) => typeof g === 'string' && g.length) ? payload.metadata.genres : []
+    const tags = Array.isArray(payload.tags) && payload.tags.every((t) => typeof t === 'string' && t.length) ? payload.tags : []
+
+    return this.create(
+      {
+        title,
+        titleIgnorePrefix: getTitleIgnorePrefix(title),
+        author: typeof payload.metadata.author === 'string' ? payload.metadata.author : null,
+        releaseDate: typeof payload.metadata.releaseDate === 'string' ? payload.metadata.releaseDate : null,
+        feedURL: typeof payload.metadata.feedUrl === 'string' ? payload.metadata.feedUrl : null,
+        imageURL: typeof payload.metadata.imageUrl === 'string' ? payload.metadata.imageUrl : null,
+        description: typeof payload.metadata.description === 'string' ? payload.metadata.description : null,
+        itunesPageURL: typeof payload.metadata.itunesPageUrl === 'string' ? payload.metadata.itunesPageUrl : null,
+        itunesId: typeof payload.metadata.itunesId === 'string' ? payload.metadata.itunesId : null,
+        itunesArtistId: typeof payload.metadata.itunesArtistId === 'string' ? payload.metadata.itunesArtistId : null,
+        language: typeof payload.metadata.language === 'string' ? payload.metadata.language : null,
+        podcastType: typeof payload.metadata.type === 'string' ? payload.metadata.type : null,
+        explicit: !!payload.metadata.explicit,
+        autoDownloadEpisodes: !!payload.autoDownloadEpisodes,
+        autoDownloadSchedule: autoDownloadSchedule || global.ServerSettings.podcastEpisodeSchedule,
+        lastEpisodeCheck: new Date(),
+        maxEpisodesToKeep: 0,
+        maxNewEpisodesToDownload: 3,
+        tags,
+        genres
+      },
+      { transaction }
+    )
+  }
+
  /**
   * Initialize model
   * @param {import('../Database').sequelize} sequelize
@@ -259,6 +298,10 @@ class Podcast extends Model {
      this.autoDownloadSchedule = payload.autoDownloadSchedule
      hasUpdates = true
    }
+    if (typeof payload.lastEpisodeCheck === 'number' && payload.lastEpisodeCheck !== this.lastEpisodeCheck?.valueOf()) {
+      this.lastEpisodeCheck = payload.lastEpisodeCheck
+      hasUpdates = true
+    }

    const numberKeys = ['maxEpisodesToKeep', 'maxNewEpisodesToDownload']
    numberKeys.forEach((key) => {
@@ -276,6 +319,103 @@ class Podcast extends Model {
    return hasUpdates
  }

+  checkCanDirectPlay(supportedMimeTypes, episodeId) {
+    if (!Array.isArray(supportedMimeTypes)) {
+      Logger.error(`[Podcast] checkCanDirectPlay: supportedMimeTypes is not an array`, supportedMimeTypes)
+      return false
+    }
+    const episode = this.podcastEpisodes.find((ep) => ep.id === episodeId)
+    if (!episode) {
+      Logger.error(`[Podcast] checkCanDirectPlay: episode not found`, episodeId)
+      return false
+    }
+    return supportedMimeTypes.includes(episode.audioFile.mimeType)
+  }
+
+  /**
+   * Get the track list to be used in client audio players
+   * AudioTrack is the AudioFile with startOffset and contentUrl
+   * Podcast episodes only have one track
+   *
+   * @param {string} libraryItemId
+   * @param {string} episodeId
+   * @returns {import('./Book').AudioTrack[]}
+   */
+  getTracklist(libraryItemId, episodeId) {
+    const episode = this.podcastEpisodes.find((ep) => ep.id === episodeId)
+    if (!episode) {
+      Logger.error(`[Podcast] getTracklist: episode not found`, episodeId)
+      return []
+    }
+
+    const audioTrack = episode.getAudioTrack(libraryItemId)
+    return [audioTrack]
+  }
+
+  /**
+   *
+   * @param {string} episodeId
+   * @returns {import('./PodcastEpisode').ChapterObject[]}
+   */
+  getChapters(episodeId) {
+    const episode = this.podcastEpisodes.find((ep) => ep.id === episodeId)
+    if (!episode) {
+      Logger.error(`[Podcast] getChapters: episode not found`, episodeId)
+      return []
+    }
+
+    return structuredClone(episode.chapters) || []
+  }
+
+  getPlaybackTitle(episodeId) {
+    const episode = this.podcastEpisodes.find((ep) => ep.id === episodeId)
+    if (!episode) {
+      Logger.error(`[Podcast] getPlaybackTitle: episode not found`, episodeId)
+      return ''
+    }
+
+    return episode.title
+  }
+
+  getPlaybackAuthor() {
+    return this.author
+  }
+
+  getPlaybackDuration(episodeId) {
+    const episode = this.podcastEpisodes.find((ep) => ep.id === episodeId)
+    if (!episode) {
+      Logger.error(`[Podcast] getPlaybackDuration: episode not found`, episodeId)
+      return 0
+    }
+
+    return episode.duration
+  }
+
+  /**
+   *
+   * @returns {number} - Unix timestamp
+   */
+  getLatestEpisodePublishedAt() {
+    return this.podcastEpisodes.reduce((latest, episode) => {
+      if (episode.publishedAt?.valueOf() > latest) {
+        return episode.publishedAt.valueOf()
+      }
+      return latest
+    }, 0)
+  }
+
+  /**
+   * Used for checking if an rss feed episode is already in the podcast
+   *
+   * @param {import('../utils/podcastUtils').RssPodcastEpisode} feedEpisode - object from rss feed
+   * @returns {boolean}
+   */
+  checkHasEpisodeByFeedEpisode(feedEpisode) {
+    const guid = feedEpisode.guid
+    const url = feedEpisode.enclosure.url
+    return this.podcastEpisodes.some((ep) => ep.checkMatchesGuidOrEnclosureUrl(guid, url))
+  }
+
  /**
   * Old model kept metadata in a separate object
   */
@@ -87,6 +87,40 @@ class PodcastEpisode extends Model {
    }
  }

+  /**
+   *
+   * @param {import('../utils/podcastUtils').RssPodcastEpisode} rssPodcastEpisode
+   * @param {string} podcastId
+   * @param {import('../objects/files/AudioFile')} audioFile
+   */
+  static async createFromRssPodcastEpisode(rssPodcastEpisode, podcastId, audioFile) {
+    const podcastEpisode = {
+      index: null,
+      season: rssPodcastEpisode.season,
+      episode: rssPodcastEpisode.episode,
+      episodeType: rssPodcastEpisode.episodeType,
+      title: rssPodcastEpisode.title,
+      subtitle: rssPodcastEpisode.subtitle,
+      description: rssPodcastEpisode.description,
+      pubDate: rssPodcastEpisode.pubDate,
+      enclosureURL: rssPodcastEpisode.enclosure?.url || null,
+      enclosureSize: rssPodcastEpisode.enclosure?.length || null,
+      enclosureType: rssPodcastEpisode.enclosure?.type || null,
+      publishedAt: rssPodcastEpisode.publishedAt,
+      podcastId,
+      audioFile: audioFile.toJSON(),
+      chapters: [],
+      extraData: {}
+    }
+    if (rssPodcastEpisode.guid) {
+      podcastEpisode.extraData.guid = rssPodcastEpisode.guid
+    }
+    if (audioFile.chapters?.length) {
+      podcastEpisode.chapters = audioFile.chapters.map((ch) => ({ ...ch }))
+    }
+    return this.create(podcastEpisode)
+  }
+
  /**
   * Initialize model
   * @param {import('../Database').sequelize} sequelize
@@ -135,23 +169,45 @@ class PodcastEpisode extends Model {
    PodcastEpisode.belongsTo(podcast)
  }

+  get size() {
+    return this.audioFile?.metadata.size || 0
+  }
+
+  get duration() {
+    return this.audioFile?.duration || 0
+  }
+
  /**
-   * AudioTrack object used in old model
+   * Used for matching the episode with an episode in the RSS feed
   *
-   * @returns {import('./Book').AudioFileObject|null}
+   * @param {string} guid
+   * @param {string} enclosureURL
+   * @returns {boolean}
   */
-  get track() {
-    if (!this.audioFile) return null
+  checkMatchesGuidOrEnclosureUrl(guid, enclosureURL) {
+    if (this.extraData?.guid && this.extraData.guid === guid) {
+      return true
+    }
+    if (this.enclosureURL && this.enclosureURL === enclosureURL) {
+      return true
+    }
+    return false
+  }
+
+  /**
+   * Used in client players
+   *
+   * @param {string} libraryItemId
+   * @returns {import('./Book').AudioTrack}
+   */
+  getAudioTrack(libraryItemId) {
    const track = structuredClone(this.audioFile)
    track.startOffset = 0
    track.title = this.audioFile.metadata.title
+    track.contentUrl = `${global.RouterBasePath}/api/items/${libraryItemId}/file/${track.ino}`
    return track
  }

-  get size() {
-    return this.audioFile?.metadata.size || 0
-  }
-
  /**
   * @param {string} libraryItemId
   * @returns {oldPodcastEpisode}
@@ -228,9 +284,9 @@ class PodcastEpisode extends Model {
  toOldJSONExpanded(libraryItemId) {
    const json = this.toOldJSON(libraryItemId)

-    json.audioTrack = this.track
+    json.audioTrack = this.getAudioTrack(libraryItemId)
    json.size = this.size
-    json.duration = this.audioFile?.duration || 0
+    json.duration = this.duration

    return json
  }
@@ -1,4 +1,3 @@
-const uuidv4 = require('uuid').v4
 const fs = require('../libs/fsExtra')
 const Path = require('path')
 const Logger = require('../Logger')
@@ -178,45 +177,6 @@ class LibraryItem {
    return this.libraryFiles.some((lf) => lf.fileType === 'audio')
  }

-  // Data comes from scandir library item data
-  // TODO: Remove this function. Only used when creating a new podcast now
-  setData(libraryMediaType, payload) {
-    this.id = uuidv4()
-    this.mediaType = libraryMediaType
-    if (libraryMediaType === 'podcast') {
-      this.media = new Podcast()
-    } else {
-      Logger.error(`[LibraryItem] setData called with unsupported media type "${libraryMediaType}"`)
-      return
-    }
-    this.media.id = uuidv4()
-    this.media.libraryItemId = this.id
-
-    for (const key in payload) {
-      if (key === 'libraryFiles') {
-        this.libraryFiles = payload.libraryFiles.map((lf) => lf.clone())
-
-        // Set cover image
-        const imageFiles = this.libraryFiles.filter((lf) => lf.fileType === 'image')
-        const coverMatch = imageFiles.find((iFile) => /\/cover\.[^.\/]*$/.test(iFile.metadata.path))
-        if (coverMatch) {
-          this.media.coverPath = coverMatch.metadata.path
-        } else if (imageFiles.length) {
-          this.media.coverPath = imageFiles[0].metadata.path
-        }
-      } else if (this[key] !== undefined && key !== 'media') {
-        this[key] = payload[key]
-      }
-    }
-
-    if (payload.media) {
-      this.media.setData(payload.media)
-    }
-
-    this.addedAt = Date.now()
-    this.updatedAt = Date.now()
-  }
-
  update(payload) {
    const json = this.toJSON()
    let hasUpdates = false
@@ -249,10 +209,6 @@ class LibraryItem {
    this.updatedAt = Date.now()
  }

-  getDirectPlayTracklist(episodeId) {
-    return this.media.getDirectPlayTracklist(episodeId)
-  }
-
  /**
   * Save metadata.json file
   * TODO: Move to new LibraryItem model
@@ -1,8 +1,6 @@
 const date = require('../libs/dateAndTime')
 const uuidv4 = require('uuid').v4
 const serverVersion = require('../../package.json').version
-const BookMetadata = require('./metadata/BookMetadata')
-const PodcastMetadata = require('./metadata/PodcastMetadata')
 const DeviceInfo = require('./DeviceInfo')

 class PlaybackSession {
@@ -60,7 +58,7 @@ class PlaybackSession {
      bookId: this.bookId,
      episodeId: this.episodeId,
      mediaType: this.mediaType,
-      mediaMetadata: this.mediaMetadata?.toJSON() || null,
+      mediaMetadata: structuredClone(this.mediaMetadata),
      chapters: (this.chapters || []).map((c) => ({ ...c })),
      displayTitle: this.displayTitle,
      displayAuthor: this.displayAuthor,
@@ -82,7 +80,7 @@ class PlaybackSession {

  /**
   * Session data to send to clients
-   * @param {Object} [libraryItem] - old library item
+   * @param {import('../models/LibraryItem')} [libraryItem]
   * @returns
   */
  toJSONForClient(libraryItem) {
@@ -94,7 +92,7 @@ class PlaybackSession {
      bookId: this.bookId,
      episodeId: this.episodeId,
      mediaType: this.mediaType,
-      mediaMetadata: this.mediaMetadata?.toJSON() || null,
+      mediaMetadata: structuredClone(this.mediaMetadata),
      chapters: (this.chapters || []).map((c) => ({ ...c })),
      displayTitle: this.displayTitle,
      displayAuthor: this.displayAuthor,
@@ -112,7 +110,7 @@ class PlaybackSession {
      startedAt: this.startedAt,
      updatedAt: this.updatedAt,
      audioTracks: this.audioTracks.map((at) => at.toJSON?.() || { ...at }),
-      libraryItem: libraryItem?.toJSONExpanded() || null
+      libraryItem: libraryItem?.toOldJSONExpanded() || null
    }
  }

@@ -148,14 +146,7 @@ class PlaybackSession {
    this.serverVersion = session.serverVersion
    this.chapters = session.chapters || []

-    this.mediaMetadata = null
-    if (session.mediaMetadata) {
-      if (this.mediaType === 'book') {
-        this.mediaMetadata = new BookMetadata(session.mediaMetadata)
-      } else if (this.mediaType === 'podcast') {
-        this.mediaMetadata = new PodcastMetadata(session.mediaMetadata)
-      }
-    }
+    this.mediaMetadata = session.mediaMetadata
    this.displayTitle = session.displayTitle || ''
    this.displayAuthor = session.displayAuthor || ''
    this.coverPath = session.coverPath
@@ -205,6 +196,15 @@ class PlaybackSession {
    }
  }

+  /**
+   *
+   * @param {import('../models/LibraryItem')} libraryItem
+   * @param {*} userId
+   * @param {*} mediaPlayer
+   * @param {*} deviceInfo
+   * @param {*} startTime
+   * @param {*} episodeId
+   */
  setData(libraryItem, userId, mediaPlayer, deviceInfo, startTime, episodeId = null) {
    this.id = uuidv4()
    this.userId = userId
@@ -213,13 +213,12 @@ class PlaybackSession {
    this.bookId = episodeId ? null : libraryItem.media.id
    this.episodeId = episodeId
    this.mediaType = libraryItem.mediaType
-    this.mediaMetadata = libraryItem.media.metadata.clone()
+    this.mediaMetadata = libraryItem.media.oldMetadataToJSON()
    this.chapters = libraryItem.media.getChapters(episodeId)
    this.displayTitle = libraryItem.media.getPlaybackTitle(episodeId)
    this.displayAuthor = libraryItem.media.getPlaybackAuthor()
    this.coverPath = libraryItem.media.coverPath
-
-    this.setDuration(libraryItem, episodeId)
+    this.duration = libraryItem.media.getPlaybackDuration(episodeId)

    this.mediaPlayer = mediaPlayer
    this.deviceInfo = deviceInfo || new DeviceInfo()
@@ -235,14 +234,6 @@ class PlaybackSession {
    this.updatedAt = Date.now()
  }

-  setDuration(libraryItem, episodeId) {
-    if (episodeId) {
-      this.duration = libraryItem.media.getEpisodeDuration(episodeId)
-    } else {
-      this.duration = libraryItem.media.duration
-    }
-  }
-
  addListeningTime(timeListened) {
    if (!timeListened || isNaN(timeListened)) return

@@ -6,8 +6,11 @@ const globals = require('../utils/globals')
 class PodcastEpisodeDownload {
  constructor() {
    this.id = null
-    this.podcastEpisode = null
+    /** @type {import('../utils/podcastUtils').RssPodcastEpisode} */
+    this.rssPodcastEpisode = null
+
    this.url = null
+    /** @type {import('../models/LibraryItem')} */
    this.libraryItem = null
    this.libraryId = null

@@ -15,7 +18,7 @@ class PodcastEpisodeDownload {
    this.isFinished = false
    this.failed = false

-    this.appendEpisodeId = false
+    this.appendRandomId = false

    this.startedAt = null
    this.createdAt = null
@@ -25,22 +28,22 @@ class PodcastEpisodeDownload {
  toJSONForClient() {
    return {
      id: this.id,
-      episodeDisplayTitle: this.podcastEpisode?.title ?? null,
+      episodeDisplayTitle: this.rssPodcastEpisode?.title ?? null,
      url: this.url,
-      libraryItemId: this.libraryItem?.id || null,
+      libraryItemId: this.libraryItemId,
      libraryId: this.libraryId || null,
      isFinished: this.isFinished,
      failed: this.failed,
-      appendEpisodeId: this.appendEpisodeId,
+      appendRandomId: this.appendRandomId,
      startedAt: this.startedAt,
      createdAt: this.createdAt,
      finishedAt: this.finishedAt,
-      podcastTitle: this.libraryItem?.media.metadata.title ?? null,
-      podcastExplicit: !!this.libraryItem?.media.metadata.explicit,
-      season: this.podcastEpisode?.season ?? null,
-      episode: this.podcastEpisode?.episode ?? null,
-      episodeType: this.podcastEpisode?.episodeType ?? 'full',
-      publishedAt: this.podcastEpisode?.publishedAt ?? null
+      podcastTitle: this.libraryItem?.media.title ?? null,
+      podcastExplicit: !!this.libraryItem?.media.explicit,
+      season: this.rssPodcastEpisode?.season ?? null,
+      episode: this.rssPodcastEpisode?.episode ?? null,
+      episodeType: this.rssPodcastEpisode?.episodeType ?? 'full',
+      publishedAt: this.rssPodcastEpisode?.publishedAt ?? null
    }
  }

@@ -54,7 +57,7 @@ class PodcastEpisodeDownload {
    return 'mp3'
  }
  get enclosureType() {
-    const enclosureType = this.podcastEpisode?.enclosure?.type
+    const enclosureType = this.rssPodcastEpisode.enclosure.type
    return typeof enclosureType === 'string' ? enclosureType : null
  }
  /**
@@ -67,10 +70,12 @@ class PodcastEpisodeDownload {
    if (this.enclosureType && !this.enclosureType.includes('mpeg')) return false
    return this.fileExtension === 'mp3'
  }
-
+  get episodeTitle() {
+    return this.rssPodcastEpisode.title
+  }
  get targetFilename() {
-    const appendage = this.appendEpisodeId ? ` (${this.podcastEpisode.id})` : ''
-    const filename = `${this.podcastEpisode.title}${appendage}.${this.fileExtension}`
+    const appendage = this.appendRandomId ? ` (${uuidv4()})` : ''
+    const filename = `${this.rssPodcastEpisode.title}${appendage}.${this.fileExtension}`
    return sanitizeFilename(filename)
  }
  get targetPath() {
@@ -80,14 +85,25 @@ class PodcastEpisodeDownload {
    return this.targetFilename
  }
  get libraryItemId() {
-    return this.libraryItem ? this.libraryItem.id : null
+    return this.libraryItem?.id || null
+  }
+  get pubYear() {
+    if (!this.rssPodcastEpisode.publishedAt) return null
+    return new Date(this.rssPodcastEpisode.publishedAt).getFullYear()
  }

-  setData(podcastEpisode, libraryItem, isAutoDownload, libraryId) {
+  /**
+   *
+   * @param {import('../utils/podcastUtils').RssPodcastEpisode} rssPodcastEpisode - from rss feed
+   * @param {import('../models/LibraryItem')} libraryItem
+   * @param {*} isAutoDownload
+   * @param {*} libraryId
+   */
+  setData(rssPodcastEpisode, libraryItem, isAutoDownload, libraryId) {
    this.id = uuidv4()
-    this.podcastEpisode = podcastEpisode
+    this.rssPodcastEpisode = rssPodcastEpisode

-    const url = podcastEpisode.enclosure.url
+    const url = rssPodcastEpisode.enclosure.url
    if (decodeURIComponent(url) !== url) {
      // Already encoded
      this.url = url
@@ -18,6 +18,7 @@ class Stream extends EventEmitter {

    this.id = sessionId
    this.user = user
+    /** @type {import('../models/LibraryItem')} */
    this.libraryItem = libraryItem
    this.episodeId = episodeId

@@ -40,31 +41,25 @@ class Stream extends EventEmitter {
    this.furthestSegmentCreated = 0
  }

-  get isPodcast() {
-    return this.libraryItem.mediaType === 'podcast'
-  }
+  /**
+   * @returns {import('../models/PodcastEpisode') | null}
+   */
  get episode() {
-    if (!this.isPodcast) return null
-    return this.libraryItem.media.episodes.find((ep) => ep.id === this.episodeId)
-  }
-  get libraryItemId() {
-    return this.libraryItem.id
+    if (!this.libraryItem.isPodcast) return null
+    return this.libraryItem.media.podcastEpisodes.find((ep) => ep.id === this.episodeId)
  }
  get mediaTitle() {
-    if (this.episode) return this.episode.title || ''
-    return this.libraryItem.media.metadata.title || ''
+    return this.libraryItem.media.getPlaybackTitle(this.episodeId)
  }
  get totalDuration() {
-    if (this.episode) return this.episode.duration
-    return this.libraryItem.media.duration
+    return this.libraryItem.media.getPlaybackDuration(this.episodeId)
  }
  get tracks() {
-    if (this.episode) return this.episode.tracks
-    return this.libraryItem.media.tracks
+    return this.libraryItem.getTrackList(this.episodeId)
  }
  get tracksAudioFileType() {
    if (!this.tracks.length) return null
-    return this.tracks[0].metadata.format
+    return this.tracks[0].metadata.ext.slice(1)
  }
  get tracksMimeType() {
    if (!this.tracks.length) return null
@@ -116,8 +111,8 @@ class Stream extends EventEmitter {
    return {
      id: this.id,
      userId: this.user.id,
-      libraryItem: this.libraryItem.toJSONExpanded(),
-      episode: this.episode ? this.episode.toJSONExpanded() : null,
+      libraryItem: this.libraryItem.toOldJSONExpanded(),
+      episode: this.episode ? this.episode.toOldJSONExpanded(this.libraryItem.id) : null,
      segmentLength: this.segmentLength,
      playlistPath: this.playlistPath,
      clientPlaylistUri: this.clientPlaylistUri,
@@ -1,4 +1,3 @@
-const uuidv4 = require('uuid').v4
 const { areEquivalent, copyValue } = require('../../utils/index')
 const AudioFile = require('../files/AudioFile')
 const AudioTrack = require('../files/AudioTrack')
@@ -127,27 +126,6 @@ class PodcastEpisode {
  get enclosureUrl() {
    return this.enclosure?.url || null
  }
-  get pubYear() {
-    if (!this.publishedAt) return null
-    return new Date(this.publishedAt).getFullYear()
-  }
-
-  setData(data, index = 1) {
-    this.id = uuidv4()
-    this.index = index
-    this.title = data.title
-    this.subtitle = data.subtitle || ''
-    this.pubDate = data.pubDate || ''
-    this.description = data.description || ''
-    this.enclosure = data.enclosure ? { ...data.enclosure } : null
-    this.guid = data.guid || null
-    this.season = data.season || ''
-    this.episode = data.episode || ''
-    this.episodeType = data.episodeType || 'full'
-    this.publishedAt = data.publishedAt || 0
-    this.addedAt = Date.now()
-    this.updatedAt = Date.now()
-  }

  update(payload) {
    let hasUpdates = false
@@ -167,20 +145,5 @@ class PodcastEpisode {
    }
    return hasUpdates
  }
-
-  // Only checks container format
-  checkCanDirectPlay(payload) {
-    const supportedMimeTypes = payload.supportedMimeTypes || []
-    return supportedMimeTypes.includes(this.audioFile.mimeType)
-  }
-
-  getDirectPlayTracklist() {
-    return this.tracks
-  }
-
-  checkEqualsEnclosureUrl(url) {
-    if (!this.enclosure?.url) return false
-    return this.enclosure.url == url
-  }
 }
 module.exports = PodcastEpisode
@@ -150,27 +150,5 @@ class Book {
    this.coverPath = coverPath
    return true
  }
-
-  // Only checks container format
-  checkCanDirectPlay(payload) {
-    var supportedMimeTypes = payload.supportedMimeTypes || []
-    return !this.tracks.some((t) => !supportedMimeTypes.includes(t.mimeType))
-  }
-
-  getDirectPlayTracklist() {
-    return this.tracks
-  }
-
-  getPlaybackTitle() {
-    return this.metadata.title
-  }
-
-  getPlaybackAuthor() {
-    return this.metadata.authorName
-  }
-
-  getChapters() {
-    return this.chapters?.map((ch) => ({ ...ch })) || []
-  }
 }
 module.exports = Book
@@ -132,18 +132,6 @@ class Podcast {
  get numTracks() {
    return this.episodes.length
  }
-  get latestEpisodePublished() {
-    var largestPublishedAt = 0
-    this.episodes.forEach((ep) => {
-      if (ep.publishedAt && ep.publishedAt > largestPublishedAt) {
-        largestPublishedAt = ep.publishedAt
-      }
-    })
-    return largestPublishedAt
-  }
-  get episodesWithPubDate() {
-    return this.episodes.filter((ep) => !!ep.publishedAt)
-  }

  update(payload) {
    var json = this.toJSON()
@@ -178,67 +166,9 @@ class Podcast {
    return true
  }

-  setData(mediaData) {
-    this.metadata = new PodcastMetadata()
-    if (mediaData.metadata) {
-      this.metadata.setData(mediaData.metadata)
-    }
-
-    this.coverPath = mediaData.coverPath || null
-    this.autoDownloadEpisodes = !!mediaData.autoDownloadEpisodes
-    this.autoDownloadSchedule = mediaData.autoDownloadSchedule || global.ServerSettings.podcastEpisodeSchedule
-    this.lastEpisodeCheck = Date.now() // Makes sure new episodes are after this
-  }
-
  checkHasEpisode(episodeId) {
    return this.episodes.some((ep) => ep.id === episodeId)
  }
-  checkHasEpisodeByFeedEpisode(feedEpisode) {
-    const guid = feedEpisode.guid
-    const url = feedEpisode.enclosure.url
-    return this.episodes.some((ep) => (ep.guid && ep.guid === guid) || ep.checkEqualsEnclosureUrl(url))
-  }
-
-  // Only checks container format
-  checkCanDirectPlay(payload, episodeId) {
-    var episode = this.episodes.find((ep) => ep.id === episodeId)
-    if (!episode) return false
-    return episode.checkCanDirectPlay(payload)
-  }
-
-  getDirectPlayTracklist(episodeId) {
-    var episode = this.episodes.find((ep) => ep.id === episodeId)
-    if (!episode) return false
-    return episode.getDirectPlayTracklist()
-  }
-
-  addPodcastEpisode(podcastEpisode) {
-    this.episodes.push(podcastEpisode)
-  }
-
-  removeEpisode(episodeId) {
-    const episode = this.episodes.find((ep) => ep.id === episodeId)
-    if (episode) {
-      this.episodes = this.episodes.filter((ep) => ep.id !== episodeId)
-    }
-    return episode
-  }
-
-  getPlaybackTitle(episodeId) {
-    var episode = this.episodes.find((ep) => ep.id == episodeId)
-    if (!episode) return this.metadata.title
-    return episode.title
-  }
-
-  getPlaybackAuthor() {
-    return this.metadata.author
-  }
-
-  getEpisodeDuration(episodeId) {
-    var episode = this.episodes.find((ep) => ep.id == episodeId)
-    if (!episode) return 0
-    return episode.duration
-  }

  getEpisode(episodeId) {
    if (!episodeId) return null
@@ -248,9 +178,5 @@ class Podcast {

    return this.episodes.find((ep) => ep.id == episodeId)
  }
-
-  getChapters(episodeId) {
-    return this.getEpisode(episodeId)?.chapters?.map((ch) => ({ ...ch })) || []
-  }
 }
 module.exports = Podcast
@@ -159,11 +159,6 @@ class BookMetadata {
  getSeries(seriesId) {
    return this.series.find((se) => se.id == seriesId)
  }
-  getSeriesSequence(seriesId) {
-    const series = this.series.find((se) => se.id == seriesId)
-    if (!series) return null
-    return series.sequence || ''
-  }

  update(payload) {
    const json = this.toJSON()
@@ -91,24 +91,6 @@ class PodcastMetadata {
    return getTitlePrefixAtEnd(this.title)
  }

-  setData(mediaMetadata = {}) {
-    this.title = mediaMetadata.title || null
-    this.author = mediaMetadata.author || null
-    this.description = mediaMetadata.description || null
-    this.releaseDate = mediaMetadata.releaseDate || null
-    this.feedUrl = mediaMetadata.feedUrl || null
-    this.imageUrl = mediaMetadata.imageUrl || null
-    this.itunesPageUrl = mediaMetadata.itunesPageUrl || null
-    this.itunesId = mediaMetadata.itunesId || null
-    this.itunesArtistId = mediaMetadata.itunesArtistId || null
-    this.explicit = !!mediaMetadata.explicit
-    this.language = mediaMetadata.language || null
-    this.type = mediaMetadata.type || null
-    if (mediaMetadata.genres && mediaMetadata.genres.length) {
-      this.genres = [...mediaMetadata.genres]
-    }
-  }
-
  update(payload) {
    const json = this.toJSON()
    let hasUpdates = false
@@ -361,36 +361,7 @@ class ApiRouter {
    }

    // remove item from playlists
-    const playlistsWithItem = await Database.playlistModel.getPlaylistsForMediaItemIds(mediaItemIds)
-    for (const playlist of playlistsWithItem) {
-      let numMediaItems = playlist.playlistMediaItems.length
-
-      let order = 1
-      // Remove items in playlist and re-order
-      for (const playlistMediaItem of playlist.playlistMediaItems) {
-        if (mediaItemIds.includes(playlistMediaItem.mediaItemId)) {
-          await playlistMediaItem.destroy()
-          numMediaItems--
-        } else {
-          if (playlistMediaItem.order !== order) {
-            playlistMediaItem.update({
-              order
-            })
-          }
-          order++
-        }
-      }
-
-      // If playlist is now empty then remove it
-      const jsonExpanded = await playlist.getOldJsonExpanded()
-      if (!numMediaItems) {
-        Logger.info(`[ApiRouter] Playlist "${playlist.name}" has no more items - removing it`)
-        await playlist.destroy()
-        SocketAuthority.clientEmitter(playlist.userId, 'playlist_removed', jsonExpanded)
-      } else {
-        SocketAuthority.clientEmitter(playlist.userId, 'playlist_updated', jsonExpanded)
-      }
-    }
+    await Database.playlistModel.removeMediaItemsFromPlaylists(mediaItemIds)

    // Close rss feed - remove from db and emit socket event
    await RssFeedManager.closeFeedForEntityId(libraryItemId)
@@ -97,6 +97,11 @@ async function resizeImage(filePath, outputPath, width, height) {
 }
 module.exports.resizeImage = resizeImage

+/**
+ *
+ * @param {import('../objects/PodcastEpisodeDownload')} podcastEpisodeDownload
+ * @returns
+ */
 module.exports.downloadPodcastEpisode = (podcastEpisodeDownload) => {
  return new Promise(async (resolve) => {
    const response = await axios({
@@ -118,32 +123,33 @@ module.exports.downloadPodcastEpisode = (podcastEpisodeDownload) => {
    ffmpeg.addOption('-loglevel debug') // Debug logs printed on error
    ffmpeg.outputOptions('-c:a', 'copy', '-map', '0:a', '-metadata', 'podcast=1')

-    const podcastMetadata = podcastEpisodeDownload.libraryItem.media.metadata
-    const podcastEpisode = podcastEpisodeDownload.podcastEpisode
+    /** @type {import('../models/Podcast')} */
+    const podcast = podcastEpisodeDownload.libraryItem.media
+    const podcastEpisode = podcastEpisodeDownload.rssPodcastEpisode
    const finalSizeInBytes = Number(podcastEpisode.enclosure?.length || 0)

    const taggings = {
-      album: podcastMetadata.title,
-      'album-sort': podcastMetadata.title,
-      artist: podcastMetadata.author,
-      'artist-sort': podcastMetadata.author,
+      album: podcast.title,
+      'album-sort': podcast.title,
+      artist: podcast.author,
+      'artist-sort': podcast.author,
      comment: podcastEpisode.description,
      subtitle: podcastEpisode.subtitle,
      disc: podcastEpisode.season,
-      genre: podcastMetadata.genres.length ? podcastMetadata.genres.join(';') : null,
-      language: podcastMetadata.language,
-      MVNM: podcastMetadata.title,
+      genre: podcast.genres.length ? podcast.genres.join(';') : null,
+      language: podcast.language,
+      MVNM: podcast.title,
      MVIN: podcastEpisode.episode,
      track: podcastEpisode.episode,
      'series-part': podcastEpisode.episode,
      title: podcastEpisode.title,
      'title-sort': podcastEpisode.title,
-      year: podcastEpisode.pubYear,
+      year: podcastEpisodeDownload.pubYear,
      date: podcastEpisode.pubDate,
      releasedate: podcastEpisode.pubDate,
-      'itunes-id': podcastMetadata.itunesId,
-      'podcast-type': podcastMetadata.type,
-      'episode-type': podcastMetadata.episodeType
+      'itunes-id': podcast.itunesId,
+      'podcast-type': podcast.podcastType,
+      'episode-type': podcastEpisode.episodeType
    }

    for (const tag in taggings) {
@@ -4,6 +4,49 @@ const Logger = require('../Logger')
 const { xmlToJSON, levenshteinDistance } = require('./index')
 const htmlSanitizer = require('../utils/htmlSanitizer')

+/**
+ * @typedef RssPodcastEpisode
+ * @property {string} title
+ * @property {string} subtitle
+ * @property {string} description
+ * @property {string} descriptionPlain
+ * @property {string} pubDate
+ * @property {string} episodeType
+ * @property {string} season
+ * @property {string} episode
+ * @property {string} author
+ * @property {string} duration
+ * @property {string} explicit
+ * @property {number} publishedAt - Unix timestamp
+ * @property {{ url: string, type?: string, length?: string }} enclosure
+ * @property {string} guid
+ * @property {string} chaptersUrl
+ * @property {string} chaptersType
+ */
+
+/**
+ * @typedef RssPodcastMetadata
+ * @property {string} title
+ * @property {string} language
+ * @property {string} explicit
+ * @property {string} author
+ * @property {string} pubDate
+ * @property {string} link
+ * @property {string} image
+ * @property {string[]} categories
+ * @property {string} feedUrl
+ * @property {string} description
+ * @property {string} descriptionPlain
+ * @property {string} type
+ */
+
+/**
+ * @typedef RssPodcast
+ * @property {RssPodcastMetadata} metadata
+ * @property {RssPodcastEpisode[]} episodes
+ * @property {number} numEpisodes
+ */
+
 function extractFirstArrayItem(json, key) {
  if (!json[key]?.length) return null
  return json[key][0]
@@ -223,7 +266,7 @@ module.exports.parsePodcastRssFeedXml = async (xml, excludeEpisodeMetadata = fal
 *
 * @param {string} feedUrl
 * @param {boolean} [excludeEpisodeMetadata=false]
- * @returns {Promise}
+ * @returns {Promise<RssPodcast|null>}
 */
 module.exports.getPodcastFeed = (feedUrl, excludeEpisodeMetadata = false) => {
  Logger.debug(`[podcastUtils] getPodcastFeed for "${feedUrl}"`)
Author	SHA1	Message	Date
advplyr	d8823c8b1c	Update podcasts to new library item model	2025-01-04 12:41:09 -06:00
advplyr	4a398f6113	Merge pull request #3789 from advplyr/migrate-podcasts-new-library-item Update podcasts to new library item model	2025-01-03 16:59:13 -06:00
advplyr	69d1744496	Update podcasts to new library item model	2025-01-03 16:48:24 -06:00
advplyr	0357dc90d4	Update libraryItem.updatedAt on media update	2025-01-03 14:07:27 -06:00
advplyr	6cd874dffc	Merge pull request #3787 from advplyr/fix-remove-episode-from-playlist Fix remove episode from playlist	2025-01-03 13:04:18 -06:00
advplyr	6467a92de6	Remove media progress when deleting podcast episode audio file	2025-01-03 12:12:56 -06:00
advplyr	63466ec48b	Fix deleting episode library file removes episode from playlist #3784	2025-01-03 12:06:20 -06:00
advplyr	de7296eaab	Merge pull request #3785 from advplyr/playback-session-use-new-library-item Update PlaybackSession to use new library item model	2025-01-03 11:20:33 -06:00
advplyr	c251f1899d	Update PlaybackSession to use new library item model	2025-01-03 11:16:03 -06:00
advplyr	d205c6f734	Merge pull request #3779 from advplyr/refactor-library-item Refactor LibraryItem to use new model	2025-01-02 17:30:22 -06:00