Migrate tools and collapse series. fix continue shelves. remove old objects

server/models/Book.js

@@ -130,130 +130,6 @@ class Book extends Model {
     this.series
   }
 
-  static getOldBook(libraryItemExpanded) {
-    const bookExpanded = libraryItemExpanded.media
-    let authors = []
-    if (bookExpanded.authors?.length) {
-      authors = bookExpanded.authors.map((au) => {
-        return {
-          id: au.id,
-          name: au.name
-        }
-      })
-    } else if (bookExpanded.bookAuthors?.length) {
-      authors = bookExpanded.bookAuthors
-        .map((ba) => {
-          if (ba.author) {
-            return {
-              id: ba.author.id,
-              name: ba.author.name
-            }
-          } else {
-            Logger.error(`[Book] Invalid bookExpanded bookAuthors: no author`, ba)
-            return null
-          }
-        })
-        .filter((a) => a)
-    }
-
-    let series = []
-    if (bookExpanded.series?.length) {
-      series = bookExpanded.series.map((se) => {
-        return {
-          id: se.id,
-          name: se.name,
-          sequence: se.bookSeries.sequence
-        }
-      })
-    } else if (bookExpanded.bookSeries?.length) {
-      series = bookExpanded.bookSeries
-        .map((bs) => {
-          if (bs.series) {
-            return {
-              id: bs.series.id,
-              name: bs.series.name,
-              sequence: bs.sequence
-            }
-          } else {
-            Logger.error(`[Book] Invalid bookExpanded bookSeries: no series`, bs)
-            return null
-          }
-        })
-        .filter((s) => s)
-    }
-
-    return {
-      id: bookExpanded.id,
-      libraryItemId: libraryItemExpanded.id,
-      coverPath: bookExpanded.coverPath,
-      tags: bookExpanded.tags,
-      audioFiles: bookExpanded.audioFiles,
-      chapters: bookExpanded.chapters,
-      ebookFile: bookExpanded.ebookFile,
-      metadata: {
-        title: bookExpanded.title,
-        subtitle: bookExpanded.subtitle,
-        authors: authors,
-        narrators: bookExpanded.narrators,
-        series: series,
-        genres: bookExpanded.genres,
-        publishedYear: bookExpanded.publishedYear,
-        publishedDate: bookExpanded.publishedDate,
-        publisher: bookExpanded.publisher,
-        description: bookExpanded.description,
-        isbn: bookExpanded.isbn,
-        asin: bookExpanded.asin,
-        language: bookExpanded.language,
-        explicit: bookExpanded.explicit,
-        abridged: bookExpanded.abridged
-      }
-    }
-  }
-
-  /**
-   * @param {object} oldBook
-   * @returns {boolean} true if updated
-   */
-  static saveFromOld(oldBook) {
-    const book = this.getFromOld(oldBook)
-    return this.update(book, {
-      where: {
-        id: book.id
-      }
-    })
-      .then((result) => result[0] > 0)
-      .catch((error) => {
-        Logger.error(`[Book] Failed to save book ${book.id}`, error)
-        return false
-      })
-  }
-
-  static getFromOld(oldBook) {
-    return {
-      id: oldBook.id,
-      title: oldBook.metadata.title,
-      titleIgnorePrefix: oldBook.metadata.titleIgnorePrefix,
-      subtitle: oldBook.metadata.subtitle,
-      publishedYear: oldBook.metadata.publishedYear,
-      publishedDate: oldBook.metadata.publishedDate,
-      publisher: oldBook.metadata.publisher,
-      description: oldBook.metadata.description,
-      isbn: oldBook.metadata.isbn,
-      asin: oldBook.metadata.asin,
-      language: oldBook.metadata.language,
-      explicit: !!oldBook.metadata.explicit,
-      abridged: !!oldBook.metadata.abridged,
-      narrators: oldBook.metadata.narrators,
-      ebookFile: oldBook.ebookFile?.toJSON() || null,
-      coverPath: oldBook.coverPath,
-      duration: oldBook.duration,
-      audioFiles: oldBook.audioFiles?.map((af) => af.toJSON()) || [],
-      chapters: oldBook.chapters,
-      tags: oldBook.tags,
-      genres: oldBook.metadata.genres
-    }
-  }
-
   /**
    * Initialize model
    * @param {import('../Database').sequelize} sequelize

server/models/LibraryItem.js

@@ -1,11 +1,8 @@
-const util = require('util')
 const Path = require('path')
 const { DataTypes, Model } = require('sequelize')
 const fsExtra = require('../libs/fsExtra')
 const Logger = require('../Logger')
-const oldLibraryItem = require('../objects/LibraryItem')
 const libraryFilters = require('../utils/queries/libraryFilters')
-const { areEquivalent } = require('../utils/index')
 const { filePathToPOSIX, getFileTimestampsWithIno } = require('../utils/fileUtils')
 const LibraryFile = require('../objects/files/LibraryFile')
 const Book = require('./Book')
@@ -122,44 +119,6 @@ class LibraryItem extends Model {
     })
   }
 
-  /**
-   * Convert an expanded LibraryItem into an old library item
-   *
-   * @param {Model<LibraryItem>} libraryItemExpanded
-   * @returns {oldLibraryItem}
-   */
-  static getOldLibraryItem(libraryItemExpanded) {
-    let media = null
-    if (libraryItemExpanded.mediaType === 'book') {
-      media = this.sequelize.models.book.getOldBook(libraryItemExpanded)
-    } else if (libraryItemExpanded.mediaType === 'podcast') {
-      media = this.sequelize.models.podcast.getOldPodcast(libraryItemExpanded)
-    }
-
-    return new oldLibraryItem({
-      id: libraryItemExpanded.id,
-      ino: libraryItemExpanded.ino,
-      oldLibraryItemId: libraryItemExpanded.extraData?.oldLibraryItemId || null,
-      libraryId: libraryItemExpanded.libraryId,
-      folderId: libraryItemExpanded.libraryFolderId,
-      path: libraryItemExpanded.path,
-      relPath: libraryItemExpanded.relPath,
-      isFile: libraryItemExpanded.isFile,
-      mtimeMs: libraryItemExpanded.mtime?.valueOf(),
-      ctimeMs: libraryItemExpanded.ctime?.valueOf(),
-      birthtimeMs: libraryItemExpanded.birthtime?.valueOf(),
-      addedAt: libraryItemExpanded.createdAt.valueOf(),
-      updatedAt: libraryItemExpanded.updatedAt.valueOf(),
-      lastScan: libraryItemExpanded.lastScan?.valueOf(),
-      scanVersion: libraryItemExpanded.lastScanVersion,
-      isMissing: !!libraryItemExpanded.isMissing,
-      isInvalid: !!libraryItemExpanded.isInvalid,
-      mediaType: libraryItemExpanded.mediaType,
-      media,
-      libraryFiles: libraryItemExpanded.libraryFiles
-    })
-  }
-
   /**
    * Remove library item by id
    *
@@ -318,61 +277,12 @@ class LibraryItem extends Model {
     return libraryItem
   }
 
-  /**
-   * Get old library item by id
-   * @param {string} libraryItemId
-   * @returns {oldLibraryItem}
-   */
-  static async getOldById(libraryItemId) {
-    if (!libraryItemId) return null
-
-    const libraryItem = await this.findByPk(libraryItemId)
-    if (!libraryItem) {
-      Logger.error(`[LibraryItem] Library item not found with id "${libraryItemId}"`)
-      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: ['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 this.getOldLibraryItem(libraryItem)
-  }
-
   /**
    * Get library items using filter and sort
    * @param {import('./Library')} library
    * @param {import('./User')} user
    * @param {object} options
-   * @returns {{ libraryItems:oldLibraryItem[], count:number }}
+   * @returns {{ libraryItems:Object[], count:number }}
    */
   static async getByFilterAndSort(library, user, options) {
     let start = Date.now()
@@ -426,17 +336,19 @@ class LibraryItem extends Model {
     // "Continue Listening" shelf
     const itemsInProgressPayload = await libraryFilters.getMediaItemsInProgress(library, user, include, limit, false)
     if (itemsInProgressPayload.items.length) {
-      const ebookOnlyItemsInProgress = itemsInProgressPayload.items.filter((li) => li.media.isEBookOnly)
-      const audioOnlyItemsInProgress = itemsInProgressPayload.items.filter((li) => !li.media.isEBookOnly)
+      const ebookOnlyItemsInProgress = itemsInProgressPayload.items.filter((li) => li.media.ebookFormat && !li.media.numTracks)
+      const audioItemsInProgress = itemsInProgressPayload.items.filter((li) => li.media.numTracks)
 
-      shelves.push({
-        id: 'continue-listening',
-        label: 'Continue Listening',
-        labelStringKey: 'LabelContinueListening',
-        type: library.isPodcast ? 'episode' : 'book',
-        entities: audioOnlyItemsInProgress,
-        total: itemsInProgressPayload.count
-      })
+      if (audioItemsInProgress.length) {
+        shelves.push({
+          id: 'continue-listening',
+          label: 'Continue Listening',
+          labelStringKey: 'LabelContinueListening',
+          type: library.isPodcast ? 'episode' : 'book',
+          entities: audioItemsInProgress,
+          total: itemsInProgressPayload.count
+        })
+      }
 
       if (ebookOnlyItemsInProgress.length) {
         // "Continue Reading" shelf
@@ -535,17 +447,19 @@ class LibraryItem extends Model {
     // "Listen Again" shelf
     const mediaFinishedPayload = await libraryFilters.getMediaFinished(library, user, include, limit)
     if (mediaFinishedPayload.items.length) {
-      const ebookOnlyItemsInProgress = mediaFinishedPayload.items.filter((li) => li.media.isEBookOnly)
-      const audioOnlyItemsInProgress = mediaFinishedPayload.items.filter((li) => !li.media.isEBookOnly)
+      const ebookOnlyItemsInProgress = mediaFinishedPayload.items.filter((li) => li.media.ebookFormat && !li.media.numTracks)
+      const audioItemsInProgress = mediaFinishedPayload.items.filter((li) => li.media.numTracks)
 
-      shelves.push({
-        id: 'listen-again',
-        label: 'Listen Again',
-        labelStringKey: 'LabelListenAgain',
-        type: library.isPodcast ? 'episode' : 'book',
-        entities: audioOnlyItemsInProgress,
-        total: mediaFinishedPayload.count
-      })
+      if (audioItemsInProgress.length) {
+        shelves.push({
+          id: 'listen-again',
+          label: 'Listen Again',
+          labelStringKey: 'LabelListenAgain',
+          type: library.isPodcast ? 'episode' : 'book',
+          entities: audioItemsInProgress,
+          total: mediaFinishedPayload.count
+        })
+      }
 
       // "Read Again" shelf
       if (ebookOnlyItemsInProgress.length) {

server/models/MediaProgress.js

@@ -36,33 +36,6 @@ class MediaProgress extends Model {
     this.createdAt
   }
 
-  static upsertFromOld(oldMediaProgress) {
-    const mediaProgress = this.getFromOld(oldMediaProgress)
-    return this.upsert(mediaProgress)
-  }
-
-  static getFromOld(oldMediaProgress) {
-    return {
-      id: oldMediaProgress.id,
-      userId: oldMediaProgress.userId,
-      mediaItemId: oldMediaProgress.mediaItemId,
-      mediaItemType: oldMediaProgress.mediaItemType,
-      duration: oldMediaProgress.duration,
-      currentTime: oldMediaProgress.currentTime,
-      ebookLocation: oldMediaProgress.ebookLocation || null,
-      ebookProgress: oldMediaProgress.ebookProgress || null,
-      isFinished: !!oldMediaProgress.isFinished,
-      hideFromContinueListening: !!oldMediaProgress.hideFromContinueListening,
-      finishedAt: oldMediaProgress.finishedAt,
-      createdAt: oldMediaProgress.startedAt || oldMediaProgress.lastUpdate,
-      updatedAt: oldMediaProgress.lastUpdate,
-      extraData: {
-        libraryItemId: oldMediaProgress.libraryItemId,
-        progress: oldMediaProgress.progress
-      }
-    }
-  }
-
   static removeById(mediaProgressId) {
     return this.destroy({
       where: {
@@ -71,12 +44,6 @@ class MediaProgress extends Model {
     })
   }
 
-  getMediaItem(options) {
-    if (!this.mediaItemType) return Promise.resolve(null)
-    const mixinMethodName = `get${this.sequelize.uppercaseFirst(this.mediaItemType)}`
-    return this[mixinMethodName](options)
-  }
-
   /**
    * Initialize model
    *
@@ -162,6 +129,12 @@ class MediaProgress extends Model {
     MediaProgress.belongsTo(user)
   }
 
+  getMediaItem(options) {
+    if (!this.mediaItemType) return Promise.resolve(null)
+    const mixinMethodName = `get${this.sequelize.uppercaseFirst(this.mediaItemType)}`
+    return this[mixinMethodName](options)
+  }
+
   getOldMediaProgress() {
     const isPodcastEpisode = this.mediaItemType === 'podcastEpisode'
 

server/models/Podcast.js

@@ -66,66 +66,6 @@ class Podcast extends Model {
     this.podcastEpisodes
   }
 
-  static getOldPodcast(libraryItemExpanded) {
-    const podcastExpanded = libraryItemExpanded.media
-    const podcastEpisodes = podcastExpanded.podcastEpisodes?.map((ep) => ep.getOldPodcastEpisode(libraryItemExpanded.id).toJSON()).sort((a, b) => a.index - b.index)
-    return {
-      id: podcastExpanded.id,
-      libraryItemId: libraryItemExpanded.id,
-      metadata: {
-        title: podcastExpanded.title,
-        author: podcastExpanded.author,
-        description: podcastExpanded.description,
-        releaseDate: podcastExpanded.releaseDate,
-        genres: podcastExpanded.genres,
-        feedUrl: podcastExpanded.feedURL,
-        imageUrl: podcastExpanded.imageURL,
-        itunesPageUrl: podcastExpanded.itunesPageURL,
-        itunesId: podcastExpanded.itunesId,
-        itunesArtistId: podcastExpanded.itunesArtistId,
-        explicit: podcastExpanded.explicit,
-        language: podcastExpanded.language,
-        type: podcastExpanded.podcastType
-      },
-      coverPath: podcastExpanded.coverPath,
-      tags: podcastExpanded.tags,
-      episodes: podcastEpisodes || [],
-      autoDownloadEpisodes: podcastExpanded.autoDownloadEpisodes,
-      autoDownloadSchedule: podcastExpanded.autoDownloadSchedule,
-      lastEpisodeCheck: podcastExpanded.lastEpisodeCheck?.valueOf() || null,
-      maxEpisodesToKeep: podcastExpanded.maxEpisodesToKeep,
-      maxNewEpisodesToDownload: podcastExpanded.maxNewEpisodesToDownload
-    }
-  }
-
-  static getFromOld(oldPodcast) {
-    const oldPodcastMetadata = oldPodcast.metadata
-    return {
-      id: oldPodcast.id,
-      title: oldPodcastMetadata.title,
-      titleIgnorePrefix: oldPodcastMetadata.titleIgnorePrefix,
-      author: oldPodcastMetadata.author,
-      releaseDate: oldPodcastMetadata.releaseDate,
-      feedURL: oldPodcastMetadata.feedUrl,
-      imageURL: oldPodcastMetadata.imageUrl,
-      description: oldPodcastMetadata.description,
-      itunesPageURL: oldPodcastMetadata.itunesPageUrl,
-      itunesId: oldPodcastMetadata.itunesId,
-      itunesArtistId: oldPodcastMetadata.itunesArtistId,
-      language: oldPodcastMetadata.language,
-      podcastType: oldPodcastMetadata.type,
-      explicit: !!oldPodcastMetadata.explicit,
-      autoDownloadEpisodes: !!oldPodcast.autoDownloadEpisodes,
-      autoDownloadSchedule: oldPodcast.autoDownloadSchedule,
-      lastEpisodeCheck: oldPodcast.lastEpisodeCheck,
-      maxEpisodesToKeep: oldPodcast.maxEpisodesToKeep,
-      maxNewEpisodesToDownload: oldPodcast.maxNewEpisodesToDownload,
-      coverPath: oldPodcast.coverPath,
-      tags: oldPodcast.tags,
-      genres: oldPodcastMetadata.genres
-    }
-  }
-
   /**
    * Payload from the /api/podcasts POST endpoint
    *

server/models/PodcastEpisode.js

@@ -1,5 +1,4 @@
 const { DataTypes, Model } = require('sequelize')
-const oldPodcastEpisode = require('../objects/entities/PodcastEpisode')
 
 /**
  * @typedef ChapterObject
@@ -53,40 +52,6 @@ class PodcastEpisode extends Model {
     this.updatedAt
   }
 
-  static createFromOld(oldEpisode) {
-    const podcastEpisode = this.getFromOld(oldEpisode)
-    return this.create(podcastEpisode)
-  }
-
-  static getFromOld(oldEpisode) {
-    const extraData = {}
-    if (oldEpisode.oldEpisodeId) {
-      extraData.oldEpisodeId = oldEpisode.oldEpisodeId
-    }
-    if (oldEpisode.guid) {
-      extraData.guid = oldEpisode.guid
-    }
-    return {
-      id: oldEpisode.id,
-      index: oldEpisode.index,
-      season: oldEpisode.season,
-      episode: oldEpisode.episode,
-      episodeType: oldEpisode.episodeType,
-      title: oldEpisode.title,
-      subtitle: oldEpisode.subtitle,
-      description: oldEpisode.description,
-      pubDate: oldEpisode.pubDate,
-      enclosureURL: oldEpisode.enclosure?.url || null,
-      enclosureSize: oldEpisode.enclosure?.length || null,
-      enclosureType: oldEpisode.enclosure?.type || null,
-      publishedAt: oldEpisode.publishedAt,
-      podcastId: oldEpisode.podcastId,
-      audioFile: oldEpisode.audioFile?.toJSON() || null,
-      chapters: oldEpisode.chapters,
-      extraData
-    }
-  }
-
   /**
    *
    * @param {import('../utils/podcastUtils').RssPodcastEpisode} rssPodcastEpisode
@@ -208,42 +173,6 @@ class PodcastEpisode extends Model {
     return track
   }
 
-  /**
-   * @param {string} libraryItemId
-   * @returns {oldPodcastEpisode}
-   */
-  getOldPodcastEpisode(libraryItemId = null) {
-    let enclosure = null
-    if (this.enclosureURL) {
-      enclosure = {
-        url: this.enclosureURL,
-        type: this.enclosureType,
-        length: this.enclosureSize !== null ? String(this.enclosureSize) : null
-      }
-    }
-    return new oldPodcastEpisode({
-      libraryItemId: libraryItemId || null,
-      podcastId: this.podcastId,
-      id: this.id,
-      oldEpisodeId: this.extraData?.oldEpisodeId || null,
-      index: this.index,
-      season: this.season,
-      episode: this.episode,
-      episodeType: this.episodeType,
-      title: this.title,
-      subtitle: this.subtitle,
-      description: this.description,
-      enclosure,
-      guid: this.extraData?.guid || null,
-      pubDate: this.pubDate,
-      chapters: this.chapters,
-      audioFile: this.audioFile,
-      publishedAt: this.publishedAt?.valueOf() || null,
-      addedAt: this.createdAt.valueOf(),
-      updatedAt: this.updatedAt.valueOf()
-    })
-  }
-
   toOldJSON(libraryItemId) {
     if (!libraryItemId) {
       throw new Error(`[PodcastEpisode] Cannot convert to old JSON because libraryItemId is not provided`)

server/models/User.js

@@ -563,9 +563,8 @@ class User extends Model {
 
   /**
    * Check user can access library item
-   * TODO: Currently supports both old and new library item models
    *
-   * @param {import('../objects/LibraryItem')|import('./LibraryItem')} libraryItem
+   * @param {import('./LibraryItem')} libraryItem
    * @returns {boolean}
    */
   checkCanAccessLibraryItem(libraryItem) {