Podcast home page shelves for currently listening episodes, newest episodes. Podcast episode card

server/controllers/LibraryController.js

@@ -300,12 +300,12 @@ class LibraryController {
     var limitPerShelf = req.query.limit && !isNaN(req.query.limit) ? Number(req.query.limit) : 12
     var minified = req.query.minified === '1'
 
-    var itemsWithUserProgress = libraryHelpers.getItemsWithUserProgress(req.user, libraryItems)
+    var itemsWithUserProgress = libraryHelpers.getMediaProgressWithItems(req.user, libraryItems)
     var categories = [
       {
         id: 'continue-listening',
         label: 'Continue Listening',
-        type: req.library.mediaType,
+        type: isPodcastLibrary ? 'episode' : req.library.mediaType,
         entities: libraryHelpers.getItemsMostRecentlyListened(itemsWithUserProgress, limitPerShelf, minified)
       },
       {
@@ -317,7 +317,7 @@ class LibraryController {
       {
         id: 'listen-again',
         label: 'Listen Again',
-        type: req.library.mediaType,
+        type: isPodcastLibrary ? 'episode' : req.library.mediaType,
         entities: libraryHelpers.getItemsMostRecentlyFinished(itemsWithUserProgress, limitPerShelf, minified)
       }
     ].filter(cats => { // Remove categories with no items
@@ -372,57 +372,17 @@ class LibraryController {
           entities: authors
         })
       }
-    }
-
-    res.json(categories)
-  }
-
-  // LEGACY
-  // api/libraries/:id/books/categories
-  async getLibraryCategories(req, res) {
-    var library = req.library
-    var books = this.db.audiobooks.filter(ab => ab.libraryId === library.id)
-    var limitPerShelf = req.query.limit && !isNaN(req.query.limit) ? Number(req.query.limit) : 12
-    var minified = req.query.minified === '1'
-
-    var booksWithUserAb = libraryHelpers.getItemsWithUserProgress(req.user, books)
-    var series = libraryHelpers.getSeriesFromBooks(books, minified)
-    var seriesWithUserAb = libraryHelpers.getSeriesWithProgressFromBooks(req.user, books)
-
-    var categories = [
-      {
-        id: 'continue-reading',
-        label: 'Continue Reading',
-        type: 'books',
-        entities: libraryHelpers.getBooksMostRecentlyRead(booksWithUserAb, limitPerShelf, minified)
-      },
-      {
-        id: 'continue-series',
-        label: 'Continue Series',
-        type: 'books',
-        entities: libraryHelpers.getBooksNextInSeries(seriesWithUserAb, limitPerShelf, minified)
-      },
-      {
-        id: 'recently-added',
-        label: 'Recently Added',
-        type: 'books',
-        entities: libraryHelpers.getBooksMostRecentlyAdded(books, limitPerShelf, minified)
-      },
-      {
-        id: 'read-again',
-        label: 'Read Again',
-        type: 'books',
-        entities: libraryHelpers.getBooksMostRecentlyFinished(booksWithUserAb, limitPerShelf, minified)
-      },
-      {
-        id: 'recent-series',
-        label: 'Recent Series',
-        type: 'series',
-        entities: libraryHelpers.getSeriesMostRecentlyAdded(series, limitPerShelf)
+    } else {
+      var episodesRecentlyAdded = libraryHelpers.getEpisodesRecentlyAdded(libraryItems, limitPerShelf, minified)
+      if (episodesRecentlyAdded.length) {
+        categories.splice(1, 0, {
+          id: 'episodes-recently-added',
+          label: 'Newest Episodes',
+          type: 'episode',
+          entities: episodesRecentlyAdded
+        })
       }
-    ].filter(cats => { // Remove categories with no items
-      return cats.entities.length
-    })
+    }
 
     res.json(categories)
   }

server/objects/mediaTypes/Podcast.js

@@ -257,5 +257,9 @@ class Podcast {
     if (!episode) return 0
     return episode.duration
   }
+
+  getEpisode(episodeId) {
+    return this.episodes.find(ep => ep.id == episodeId)
+  }
 }
 module.exports = Podcast

server/objects/user/User.js

@@ -251,6 +251,11 @@ class User {
     })
   }
 
+  getAllMediaProgressForLibraryItem(libraryItemId) {
+    if (!this.mediaProgress) return []
+    return this.mediaProgress.filter(li => li.libraryItemId === libraryItemId)
+  }
+
   createUpdateMediaProgress(libraryItem, updatePayload, episodeId = null) {
     var itemProgress = this.mediaProgress.find(li => {
       if (episodeId && li.episodeId !== episodeId) return false

server/utils/libraryHelpers.js

@@ -1,4 +1,5 @@
 const { sort, createNewSortInstance } = require('fast-sort')
+const Logger = require('../Logger')
 const naturalSort = createNewSortInstance({
   comparer: new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' }).compare
 })
@@ -172,14 +173,28 @@ module.exports = {
     })
   },
 
-  getItemsWithUserProgress(user, libraryItems) {
-    return libraryItems.map(li => {
-      var itemProgress = user.getMediaProgress(li.id)
-      return {
-        userProgress: itemProgress ? itemProgress.toJSON() : null,
-        libraryItem: li
-      }
-    }).filter(b => !!b.userProgress)
+  getMediaProgressWithItems(user, libraryItems) {
+    var mediaProgress = []
+    libraryItems.forEach(li => {
+      var itemProgress = user.getAllMediaProgressForLibraryItem(li.id).map(mp => {
+        var episode = null
+        if (mp.episodeId) {
+          episode = li.media.getEpisode(mp.episodeId)
+          if (!episode) {
+            // Episode not found for library item
+            return null
+          }
+        }
+        return {
+          userProgress: mp.toJSON(),
+          libraryItem: li,
+          episode
+        }
+      }).filter(mp => !!mp)
+
+      mediaProgress = mediaProgress.concat(itemProgress)
+    })
+    return mediaProgress
   },
 
   getItemsMostRecentlyListened(itemsWithUserProgress, limit, minified = false) {
@@ -187,7 +202,13 @@ module.exports = {
     itemsInProgress.sort((a, b) => {
       return b.userProgress.lastUpdate - a.userProgress.lastUpdate
     })
-    return itemsInProgress.map(b => minified ? b.libraryItem.toJSONMinified() : b.libraryItem.toJSONExpanded()).slice(0, limit)
+    return itemsInProgress.map(b => {
+      var libjson = minified ? b.libraryItem.toJSONMinified() : b.libraryItem.toJSONExpanded()
+      if (b.episode) {
+        libjson.recentEpisode = b.episode
+      }
+      return libjson
+    }).slice(0, limit)
   },
 
   getBooksNextInSeries(seriesWithUserAb, limit, minified = false) {
@@ -202,17 +223,39 @@ module.exports = {
     return booksNextInSeries.sort((a, b) => { return b.DateLastReadSeries - a.DateLastReadSeries }).map(b => minified ? b.book.toJSONMinified() : b.book.toJSONExpanded()).slice(0, limit)
   },
 
-  getItemsMostRecentlyAdded(libraryItems, limit, minified = false) {
-    var itemsSortedByAddedAt = sort(libraryItems).desc(li => li.addedAt)
-    return itemsSortedByAddedAt.map(b => minified ? b.toJSONMinified() : b.toJSONExpanded()).slice(0, limit)
-  },
-
   getItemsMostRecentlyFinished(itemsWithUserProgress, limit, minified = false) {
     var itemsFinished = itemsWithUserProgress.filter((data) => data.userProgress && data.userProgress.isFinished)
     itemsFinished.sort((a, b) => {
       return b.userProgress.finishedAt - a.userProgress.finishedAt
     })
-    return itemsFinished.map(i => minified ? i.libraryItem.toJSONMinified() : i.libraryItem.toJSONExpanded()).slice(0, limit)
+    return itemsFinished.map(i => {
+      var libjson = minified ? i.libraryItem.toJSONMinified() : i.libraryItem.toJSONExpanded()
+      if (i.episode) {
+        libjson.recentEpisode = i.episode
+      }
+      return libjson
+    }).slice(0, limit)
+  },
+
+  getItemsMostRecentlyAdded(libraryItems, limit, minified = false) {
+    var itemsSortedByAddedAt = sort(libraryItems).desc(li => li.addedAt)
+    return itemsSortedByAddedAt.map(b => minified ? b.toJSONMinified() : b.toJSONExpanded()).slice(0, limit)
+  },
+
+  getEpisodesRecentlyAdded(libraryItems, limit, minified = false) {
+    var libraryItemsWithEpisode = []
+    libraryItems.forEach((li) => {
+      if (li.mediaType !== 'podcast' || !li.media.hasMediaEntities) return
+      var libjson = minified ? li.toJSONMinified() : li.toJSONExpanded()
+      var episodes = sort(li.media.episodes || []).desc(ep => ep.addedAt)
+      episodes.forEach((ep) => {
+        var lie = { ...libjson }
+        lie.recentEpisode = ep
+        libraryItemsWithEpisode.push(lie)
+      })
+    })
+    libraryItemsWithEpisode = sort(libraryItemsWithEpisode).desc(lie => lie.recentEpisode.addedAt)
+    return libraryItemsWithEpisode.slice(0, limit)
   },
 
   getSeriesMostRecentlyAdded(series, limit) {