audiobookshelf/server/Database.js

699 lines
21 KiB
JavaScript
Raw Normal View History

2023-07-05 01:14:44 +02:00
const Path = require('path')
const { Sequelize } = require('sequelize')
const packageJson = require('../package.json')
const fs = require('./libs/fsExtra')
const Logger = require('./Logger')
const dbMigration = require('./utils/migrations/dbMigration')
2023-07-22 22:32:20 +02:00
const Auth = require('./Auth')
2023-07-05 01:14:44 +02:00
class Database {
constructor() {
this.sequelize = null
this.dbPath = null
2023-07-08 21:40:49 +02:00
this.isNew = false // New absdatabase.sqlite created
2023-07-22 22:32:20 +02:00
this.hasRootUser = false // Used to show initialization page in web ui
2023-07-05 01:14:44 +02:00
// Temporarily using format of old DB
// TODO: below data should be loaded from the DB as needed
2023-07-05 01:14:44 +02:00
this.libraryItems = []
this.settings = []
// Cached library filter data
this.libraryFilterData = {}
/** @type {import('./objects/settings/ServerSettings')} */
2023-07-05 01:14:44 +02:00
this.serverSettings = null
/** @type {import('./objects/settings/NotificationSettings')} */
2023-07-05 01:14:44 +02:00
this.notificationSettings = null
/** @type {import('./objects/settings/EmailSettings')} */
2023-07-05 01:14:44 +02:00
this.emailSettings = null
}
get models() {
return this.sequelize?.models || {}
}
2023-08-20 20:34:03 +02:00
/** @type {typeof import('./models/User')} */
get userModel() {
return this.models.user
}
/** @type {typeof import('./models/Library')} */
get libraryModel() {
return this.models.library
}
/** @type {typeof import('./models/Author')} */
get authorModel() {
return this.models.author
}
/** @type {typeof import('./models/Series')} */
get seriesModel() {
return this.models.series
}
/** @type {typeof import('./models/Book')} */
get bookModel() {
return this.models.book
}
2023-08-20 20:34:03 +02:00
/** @type {typeof import('./models/BookSeries')} */
get bookSeriesModel() {
return this.models.bookSeries
}
/** @type {typeof import('./models/BookAuthor')} */
get bookAuthorModel() {
return this.models.bookAuthor
}
/** @type {typeof import('./models/Podcast')} */
get podcastModel() {
return this.models.podcast
}
2023-08-20 20:34:03 +02:00
/** @type {typeof import('./models/PodcastEpisode')} */
get podcastEpisodeModel() {
return this.models.podcastEpisode
}
/** @type {typeof import('./models/LibraryItem')} */
get libraryItemModel() {
return this.models.libraryItem
}
/** @type {typeof import('./models/PodcastEpisode')} */
get podcastEpisodeModel() {
return this.models.podcastEpisode
}
/** @type {typeof import('./models/MediaProgress')} */
get mediaProgressModel() {
return this.models.mediaProgress
}
2023-08-20 20:34:03 +02:00
/** @type {typeof import('./models/Collection')} */
get collectionModel() {
return this.models.collection
}
/** @type {typeof import('./models/CollectionBook')} */
get collectionBookModel() {
return this.models.collectionBook
}
/** @type {typeof import('./models/Playlist')} */
get playlistModel() {
return this.models.playlist
}
/** @type {typeof import('./models/PlaylistMediaItem')} */
get playlistMediaItemModel() {
return this.models.playlistMediaItem
}
/** @type {typeof import('./models/Feed')} */
get feedModel() {
return this.models.feed
}
/** @type {typeof import('./models/Feed')} */
get feedEpisodeModel() {
return this.models.feedEpisode
}
/**
* Check if db file exists
* @returns {boolean}
*/
2023-07-05 01:14:44 +02:00
async checkHasDb() {
if (!await fs.pathExists(this.dbPath)) {
2023-07-08 21:40:49 +02:00
Logger.info(`[Database] absdatabase.sqlite not found at ${this.dbPath}`)
2023-07-05 01:14:44 +02:00
return false
}
return true
}
/**
* Connect to db, build models and run migrations
* @param {boolean} [force=false] Used for testing, drops & re-creates all tables
*/
2023-07-05 01:14:44 +02:00
async init(force = false) {
2023-07-08 21:40:49 +02:00
this.dbPath = Path.join(global.ConfigPath, 'absdatabase.sqlite')
2023-07-05 01:14:44 +02:00
// First check if this is a new database
this.isNew = !(await this.checkHasDb()) || force
if (!await this.connect()) {
throw new Error('Database connection failed')
}
await this.buildModels(force)
Logger.info(`[Database] Db initialized with models:`, Object.keys(this.sequelize.models).join(', '))
2023-07-05 01:14:44 +02:00
2023-07-08 21:40:49 +02:00
await this.loadData()
2023-07-05 01:14:44 +02:00
}
/**
* Connect to db
* @returns {boolean}
*/
2023-07-05 01:14:44 +02:00
async connect() {
Logger.info(`[Database] Initializing db at "${this.dbPath}"`)
this.sequelize = new Sequelize({
dialect: 'sqlite',
storage: this.dbPath,
logging: false,
transactionType: 'IMMEDIATE'
2023-07-05 01:14:44 +02:00
})
// Helper function
this.sequelize.uppercaseFirst = str => str ? `${str[0].toUpperCase()}${str.substr(1)}` : ''
try {
await this.sequelize.authenticate()
Logger.info(`[Database] Db connection was successful`)
return true
} catch (error) {
Logger.error(`[Database] Failed to connect to db`, error)
return false
}
}
/**
* Disconnect from db
*/
2023-07-08 21:40:49 +02:00
async disconnect() {
Logger.info(`[Database] Disconnecting sqlite db`)
await this.sequelize.close()
this.sequelize = null
}
/**
* Reconnect to db and init
*/
2023-07-08 21:40:49 +02:00
async reconnect() {
Logger.info(`[Database] Reconnecting sqlite db`)
await this.init()
}
2023-07-05 01:14:44 +02:00
buildModels(force = false) {
2023-08-16 23:38:48 +02:00
require('./models/User').init(this.sequelize)
2023-08-16 01:03:43 +02:00
require('./models/Library').init(this.sequelize)
require('./models/LibraryFolder').init(this.sequelize)
require('./models/Book').init(this.sequelize)
2023-08-16 23:38:48 +02:00
require('./models/Podcast').init(this.sequelize)
require('./models/PodcastEpisode').init(this.sequelize)
require('./models/LibraryItem').init(this.sequelize)
require('./models/MediaProgress').init(this.sequelize)
require('./models/Series').init(this.sequelize)
2023-08-16 01:03:43 +02:00
require('./models/BookSeries').init(this.sequelize)
2023-08-15 01:22:38 +02:00
require('./models/Author').init(this.sequelize)
2023-08-16 01:03:43 +02:00
require('./models/BookAuthor').init(this.sequelize)
require('./models/Collection').init(this.sequelize)
require('./models/CollectionBook').init(this.sequelize)
2023-08-16 23:38:48 +02:00
require('./models/Playlist').init(this.sequelize)
require('./models/PlaylistMediaItem').init(this.sequelize)
2023-08-16 01:03:43 +02:00
require('./models/Device').init(this.sequelize)
2023-08-16 23:38:48 +02:00
require('./models/PlaybackSession').init(this.sequelize)
2023-08-16 01:03:43 +02:00
require('./models/Feed').init(this.sequelize)
require('./models/FeedEpisode').init(this.sequelize)
2023-08-16 23:38:48 +02:00
require('./models/Setting').init(this.sequelize)
2023-07-05 01:14:44 +02:00
2023-07-06 01:18:37 +02:00
return this.sequelize.sync({ force, alter: false })
2023-07-05 01:14:44 +02:00
}
2023-07-21 23:59:00 +02:00
/**
* Compare two server versions
* @param {string} v1
* @param {string} v2
* @returns {-1|0|1} 1 if v1 > v2
*/
compareVersions(v1, v2) {
if (!v1 || !v2) return 0
return v1.localeCompare(v2, undefined, { numeric: true, sensitivity: "case", caseFirst: "upper" })
}
/**
* Checks if migration to sqlite db is necessary & runs migration.
*
* Check if version was upgraded and run any version specific migrations.
*
* Loads most of the data from the database. This is a temporary solution.
*/
2023-07-08 21:40:49 +02:00
async loadData() {
if (this.isNew && await dbMigration.checkShouldMigrate()) {
2023-07-05 01:14:44 +02:00
Logger.info(`[Database] New database was created and old database was detected - migrating old to new`)
await dbMigration.migrate(this.models)
}
const startTime = Date.now()
const settingsData = await this.models.setting.getOldSettings()
this.settings = settingsData.settings
this.emailSettings = settingsData.emailSettings
this.serverSettings = settingsData.serverSettings
this.notificationSettings = settingsData.notificationSettings
global.ServerSettings = this.serverSettings.toJSON()
// Version specific migrations
if (this.serverSettings.version === '2.3.0' && this.compareVersions(packageJson.version, '2.3.0') == 1) {
await dbMigration.migrationPatch(this)
}
if (['2.3.0', '2.3.1', '2.3.2', '2.3.3'].includes(this.serverSettings.version) && this.compareVersions(packageJson.version, '2.3.3') >= 0) {
2023-07-21 23:59:00 +02:00
await dbMigration.migrationPatch2(this)
}
Logger.info(`[Database] Loading db data...`)
this.libraryItems = await this.models.libraryItem.loadAllLibraryItems()
Logger.info(`[Database] Loaded ${this.libraryItems.length} library items`)
2023-07-22 22:32:20 +02:00
// Set if root user has been created
this.hasRootUser = await this.models.user.getHasRootUser()
Logger.info(`[Database] Db data loaded in ${((Date.now() - startTime) / 1000).toFixed(2)}s`)
2023-07-05 01:14:44 +02:00
if (packageJson.version !== this.serverSettings.version) {
Logger.info(`[Database] Server upgrade detected from ${this.serverSettings.version} to ${packageJson.version}`)
this.serverSettings.version = packageJson.version
await this.updateServerSettings()
}
}
2023-07-22 22:32:20 +02:00
/**
* Create root user
* @param {string} username
* @param {string} pash
* @param {Auth} auth
* @returns {boolean} true if created
*/
async createRootUser(username, pash, auth) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-22 22:32:20 +02:00
await this.models.user.createRootUser(username, pash, auth)
this.hasRootUser = true
return true
2023-07-05 01:14:44 +02:00
}
updateServerSettings() {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
global.ServerSettings = this.serverSettings.toJSON()
return this.updateSetting(this.serverSettings)
}
updateSetting(settings) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.setting.updateSettingObj(settings.toJSON())
}
async createUser(oldUser) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
await this.models.user.createFromOld(oldUser)
return true
}
updateUser(oldUser) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.user.updateFromOld(oldUser)
}
updateBulkUsers(oldUsers) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return Promise.all(oldUsers.map(u => this.updateUser(u)))
}
removeUser(userId) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
return this.models.user.removeById(userId)
2023-07-05 01:14:44 +02:00
}
upsertMediaProgress(oldMediaProgress) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.mediaProgress.upsertFromOld(oldMediaProgress)
}
removeMediaProgress(mediaProgressId) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.mediaProgress.removeById(mediaProgressId)
}
updateBulkBooks(oldBooks) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return Promise.all(oldBooks.map(oldBook => this.models.book.saveFromOld(oldBook)))
}
createLibrary(oldLibrary) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
return this.models.library.createFromOld(oldLibrary)
2023-07-05 01:14:44 +02:00
}
updateLibrary(oldLibrary) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.library.updateFromOld(oldLibrary)
}
removeLibrary(libraryId) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
return this.models.library.removeById(libraryId)
2023-07-05 01:14:44 +02:00
}
createBulkCollectionBooks(collectionBooks) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.collectionBook.bulkCreate(collectionBooks)
}
createPlaylistMediaItem(playlistMediaItem) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.playlistMediaItem.create(playlistMediaItem)
}
createBulkPlaylistMediaItems(playlistMediaItems) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.playlistMediaItem.bulkCreate(playlistMediaItems)
}
getLibraryItem(libraryItemId) {
if (!this.sequelize || !libraryItemId) return false
// Temp support for old library item ids from mobile
if (libraryItemId.startsWith('li_')) return this.libraryItems.find(li => li.oldLibraryItemId === libraryItemId)
2023-07-05 01:14:44 +02:00
return this.libraryItems.find(li => li.id === libraryItemId)
}
async createLibraryItem(oldLibraryItem) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
await oldLibraryItem.saveMetadata()
2023-07-05 01:14:44 +02:00
await this.models.libraryItem.fullCreateFromOld(oldLibraryItem)
this.libraryItems.push(oldLibraryItem)
}
async updateLibraryItem(oldLibraryItem) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
await oldLibraryItem.saveMetadata()
2023-07-05 01:14:44 +02:00
return this.models.libraryItem.fullUpdateFromOld(oldLibraryItem)
}
async updateBulkLibraryItems(oldLibraryItems) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
let updatesMade = 0
for (const oldLibraryItem of oldLibraryItems) {
await oldLibraryItem.saveMetadata()
2023-07-05 01:14:44 +02:00
const hasUpdates = await this.models.libraryItem.fullUpdateFromOld(oldLibraryItem)
if (hasUpdates) {
updatesMade++
}
2023-07-05 01:14:44 +02:00
}
return updatesMade
}
async createBulkLibraryItems(oldLibraryItems) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
for (const oldLibraryItem of oldLibraryItems) {
await oldLibraryItem.saveMetadata()
2023-07-05 01:14:44 +02:00
await this.models.libraryItem.fullCreateFromOld(oldLibraryItem)
this.libraryItems.push(oldLibraryItem)
}
}
async removeLibraryItem(libraryItemId) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
await this.models.libraryItem.removeById(libraryItemId)
this.libraryItems = this.libraryItems.filter(li => li.id !== libraryItemId)
}
2023-07-06 01:18:37 +02:00
async createFeed(oldFeed) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-06 01:18:37 +02:00
await this.models.feed.fullCreateFromOld(oldFeed)
2023-07-05 01:14:44 +02:00
}
updateFeed(oldFeed) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-06 01:18:37 +02:00
return this.models.feed.fullUpdateFromOld(oldFeed)
2023-07-05 01:14:44 +02:00
}
async removeFeed(feedId) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
await this.models.feed.removeById(feedId)
}
updateSeries(oldSeries) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.series.updateFromOld(oldSeries)
}
async createSeries(oldSeries) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
await this.models.series.createFromOld(oldSeries)
}
async createBulkSeries(oldSeriesObjs) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
await this.models.series.createBulkFromOld(oldSeriesObjs)
}
async removeSeries(seriesId) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
await this.models.series.removeById(seriesId)
}
async createAuthor(oldAuthor) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-16 22:29:43 +02:00
await this.models.author.createFromOld(oldAuthor)
2023-07-05 01:14:44 +02:00
}
async createBulkAuthors(oldAuthors) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
await this.models.author.createBulkFromOld(oldAuthors)
}
updateAuthor(oldAuthor) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.author.updateFromOld(oldAuthor)
}
async removeAuthor(authorId) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
await this.models.author.removeById(authorId)
}
async createBulkBookAuthors(bookAuthors) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
await this.models.bookAuthor.bulkCreate(bookAuthors)
}
async removeBulkBookAuthors(authorId = null, bookId = null) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
if (!authorId && !bookId) return
await this.models.bookAuthor.removeByIds(authorId, bookId)
}
getPlaybackSessions(where = null) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.playbackSession.getOldPlaybackSessions(where)
}
getPlaybackSession(sessionId) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.playbackSession.getById(sessionId)
}
createPlaybackSession(oldSession) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.playbackSession.createFromOld(oldSession)
}
updatePlaybackSession(oldSession) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.playbackSession.updateFromOld(oldSession)
}
removePlaybackSession(sessionId) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.playbackSession.removeById(sessionId)
}
getDeviceByDeviceId(deviceId) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.device.getOldDeviceByDeviceId(deviceId)
}
updateDevice(oldDevice) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.device.updateFromOld(oldDevice)
}
createDevice(oldDevice) {
2023-07-08 21:40:49 +02:00
if (!this.sequelize) return false
2023-07-05 01:14:44 +02:00
return this.models.device.createFromOld(oldDevice)
}
replaceTagInFilterData(oldTag, newTag) {
for (const libraryId in this.libraryFilterData) {
const indexOf = this.libraryFilterData[libraryId].tags.findIndex(n => n === oldTag)
if (indexOf >= 0) {
this.libraryFilterData[libraryId].tags.splice(indexOf, 1, newTag)
}
}
}
removeTagFromFilterData(tag) {
for (const libraryId in this.libraryFilterData) {
this.libraryFilterData[libraryId].tags = this.libraryFilterData[libraryId].tags.filter(t => t !== tag)
}
}
addTagsToFilterData(libraryId, tags) {
if (!this.libraryFilterData[libraryId] || !tags?.length) return
tags.forEach((t) => {
if (!this.libraryFilterData[libraryId].tags.includes(t)) {
this.libraryFilterData[libraryId].tags.push(t)
}
})
}
replaceGenreInFilterData(oldGenre, newGenre) {
for (const libraryId in this.libraryFilterData) {
const indexOf = this.libraryFilterData[libraryId].genres.findIndex(n => n === oldGenre)
if (indexOf >= 0) {
this.libraryFilterData[libraryId].genres.splice(indexOf, 1, newGenre)
}
}
}
removeGenreFromFilterData(genre) {
for (const libraryId in this.libraryFilterData) {
this.libraryFilterData[libraryId].genres = this.libraryFilterData[libraryId].genres.filter(g => g !== genre)
}
}
addGenresToFilterData(libraryId, genres) {
if (!this.libraryFilterData[libraryId] || !genres?.length) return
genres.forEach((g) => {
if (!this.libraryFilterData[libraryId].genres.includes(g)) {
this.libraryFilterData[libraryId].genres.push(g)
}
})
}
replaceNarratorInFilterData(oldNarrator, newNarrator) {
for (const libraryId in this.libraryFilterData) {
const indexOf = this.libraryFilterData[libraryId].narrators.findIndex(n => n === oldNarrator)
if (indexOf >= 0) {
this.libraryFilterData[libraryId].narrators.splice(indexOf, 1, newNarrator)
}
}
}
removeNarratorFromFilterData(narrator) {
for (const libraryId in this.libraryFilterData) {
this.libraryFilterData[libraryId].narrators = this.libraryFilterData[libraryId].narrators.filter(n => n !== narrator)
}
}
addNarratorsToFilterData(libraryId, narrators) {
if (!this.libraryFilterData[libraryId] || !narrators?.length) return
narrators.forEach((n) => {
if (!this.libraryFilterData[libraryId].narrators.includes(n)) {
this.libraryFilterData[libraryId].narrators.push(n)
}
})
}
removeSeriesFromFilterData(libraryId, seriesId) {
if (!this.libraryFilterData[libraryId]) return
this.libraryFilterData[libraryId].series = this.libraryFilterData[libraryId].series.filter(se => se.id !== seriesId)
}
addSeriesToFilterData(libraryId, seriesName, seriesId) {
if (!this.libraryFilterData[libraryId]) return
// Check if series is already added
if (this.libraryFilterData[libraryId].series.some(se => se.id === seriesId)) return
this.libraryFilterData[libraryId].series.push({
id: seriesId,
name: seriesName
})
}
removeAuthorFromFilterData(libraryId, authorId) {
if (!this.libraryFilterData[libraryId]) return
this.libraryFilterData[libraryId].authors = this.libraryFilterData[libraryId].authors.filter(au => au.id !== authorId)
}
addAuthorToFilterData(libraryId, authorName, authorId) {
if (!this.libraryFilterData[libraryId]) return
// Check if author is already added
if (this.libraryFilterData[libraryId].authors.some(au => au.id === authorId)) return
this.libraryFilterData[libraryId].authors.push({
id: authorId,
name: authorName
})
}
addPublisherToFilterData(libraryId, publisher) {
if (!this.libraryFilterData[libraryId] || !publisher || this.libraryFilterData[libraryId].publishers.includes(publisher)) return
this.libraryFilterData[libraryId].publishers.push(publisher)
}
addLanguageToFilterData(libraryId, language) {
if (!this.libraryFilterData[libraryId] || !language || this.libraryFilterData[libraryId].languages.includes(language)) return
this.libraryFilterData[libraryId].languages.push(language)
}
/**
* Used when updating items to make sure author id exists
* If library filter data is set then use that for check
* otherwise lookup in db
* @param {string} libraryId
* @param {string} authorId
* @returns {Promise<boolean>}
*/
async checkAuthorExists(libraryId, authorId) {
if (!this.libraryFilterData[libraryId]) {
return this.authorModel.checkExistsById(authorId)
}
return this.libraryFilterData[libraryId].authors.some(au => au.id === authorId)
}
/**
* Used when updating items to make sure series id exists
* If library filter data is set then use that for check
* otherwise lookup in db
* @param {string} libraryId
* @param {string} seriesId
* @returns {Promise<boolean>}
*/
async checkSeriesExists(libraryId, seriesId) {
if (!this.libraryFilterData[libraryId]) {
return this.seriesModel.checkExistsById(seriesId)
}
return this.libraryFilterData[libraryId].series.some(se => se.id === seriesId)
}
/**
* Reset numIssues for library
* @param {string} libraryId
*/
async resetLibraryIssuesFilterData(libraryId) {
if (!this.libraryFilterData[libraryId]) return // Do nothing if filter data is not set
this.libraryFilterData[libraryId].numIssues = await this.libraryItemModel.count({
where: {
libraryId,
[Sequelize.Op.or]: [
{
isMissing: true
},
{
isInvalid: true
}
]
}
})
}
2023-07-05 01:14:44 +02:00
}
module.exports = new Database()