mirror of
https://github.com/advplyr/audiobookshelf.git
synced 2024-12-29 01:58:49 +01:00
358 lines
12 KiB
JavaScript
358 lines
12 KiB
JavaScript
const Logger = require('../../Logger')
|
|
const AudioBookmark = require('./AudioBookmark')
|
|
const LibraryItemProgress = require('./LibraryItemProgress')
|
|
|
|
class User {
|
|
constructor(user) {
|
|
this.id = null
|
|
this.username = null
|
|
this.pash = null
|
|
this.type = null
|
|
this.token = null
|
|
this.isActive = true
|
|
this.isLocked = false
|
|
this.lastSeen = null
|
|
this.createdAt = null
|
|
|
|
this.libraryItemProgress = []
|
|
this.bookmarks = []
|
|
|
|
this.settings = {}
|
|
this.permissions = {}
|
|
this.librariesAccessible = [] // Library IDs (Empty if ALL libraries)
|
|
this.itemTagsAccessible = [] // Empty if ALL item tags accessible
|
|
|
|
if (user) {
|
|
this.construct(user)
|
|
}
|
|
}
|
|
|
|
get isRoot() {
|
|
return this.type === 'root'
|
|
}
|
|
get canDelete() {
|
|
return !!this.permissions.delete && this.isActive
|
|
}
|
|
get canUpdate() {
|
|
return !!this.permissions.update && this.isActive
|
|
}
|
|
get canDownload() {
|
|
return !!this.permissions.download && this.isActive
|
|
}
|
|
get canUpload() {
|
|
return !!this.permissions.upload && this.isActive
|
|
}
|
|
get canAccessAllLibraries() {
|
|
return !!this.permissions.accessAllLibraries && this.isActive
|
|
}
|
|
get canAccessAllTags() {
|
|
return !!this.permissions.accessAllTags && this.isActive
|
|
}
|
|
get hasPw() {
|
|
return !!this.pash && !!this.pash.length
|
|
}
|
|
|
|
getDefaultUserSettings() {
|
|
return {
|
|
mobileOrderBy: 'recent',
|
|
mobileOrderDesc: true,
|
|
mobileFilterBy: 'all',
|
|
orderBy: 'book.title',
|
|
orderDesc: false,
|
|
filterBy: 'all',
|
|
playbackRate: 1,
|
|
bookshelfCoverSize: 120,
|
|
collapseSeries: false
|
|
}
|
|
}
|
|
|
|
getDefaultUserPermissions() {
|
|
return {
|
|
download: true,
|
|
update: true,
|
|
delete: this.type === 'root',
|
|
upload: this.type === 'root' || this.type === 'admin',
|
|
accessAllLibraries: true,
|
|
accessAllTags: true
|
|
}
|
|
}
|
|
|
|
toJSON() {
|
|
return {
|
|
id: this.id,
|
|
username: this.username,
|
|
pash: this.pash,
|
|
type: this.type,
|
|
token: this.token,
|
|
libraryItemProgress: this.libraryItemProgress ? this.libraryItemProgress.map(li => li.toJSON()) : [],
|
|
bookmarks: this.bookmarks ? this.bookmarks.map(b => b.toJSON()) : [],
|
|
isActive: this.isActive,
|
|
isLocked: this.isLocked,
|
|
lastSeen: this.lastSeen,
|
|
createdAt: this.createdAt,
|
|
settings: this.settings,
|
|
permissions: this.permissions,
|
|
librariesAccessible: [...this.librariesAccessible],
|
|
itemTagsAccessible: [...this.itemTagsAccessible]
|
|
}
|
|
}
|
|
|
|
toJSONForBrowser() {
|
|
return {
|
|
id: this.id,
|
|
username: this.username,
|
|
type: this.type,
|
|
token: this.token,
|
|
libraryItemProgress: this.libraryItemProgress ? this.libraryItemProgress.map(li => li.toJSON()) : [],
|
|
bookmarks: this.bookmarks ? this.bookmarks.map(b => b.toJSON()) : [],
|
|
isActive: this.isActive,
|
|
isLocked: this.isLocked,
|
|
lastSeen: this.lastSeen,
|
|
createdAt: this.createdAt,
|
|
settings: this.settings,
|
|
permissions: this.permissions,
|
|
librariesAccessible: [...this.librariesAccessible],
|
|
itemTagsAccessible: [...this.itemTagsAccessible]
|
|
}
|
|
}
|
|
|
|
// Data broadcasted
|
|
toJSONForPublic(sessions, libraryItems) {
|
|
var session = sessions ? sessions.find(s => s.userId === this.id) : null
|
|
return {
|
|
id: this.id,
|
|
username: this.username,
|
|
type: this.type,
|
|
session: session ? session.toJSONForClient() : null,
|
|
mostRecent: this.getMostRecentItemProgress(libraryItems),
|
|
lastSeen: this.lastSeen,
|
|
createdAt: this.createdAt
|
|
}
|
|
}
|
|
|
|
construct(user) {
|
|
this.id = user.id
|
|
this.username = user.username
|
|
this.pash = user.pash
|
|
this.type = user.type
|
|
this.token = user.token
|
|
|
|
this.libraryItemProgress = []
|
|
if (user.libraryItemProgress) {
|
|
this.libraryItemProgress = user.libraryItemProgress.map(li => new LibraryItemProgress(li)).filter(lip => lip.id)
|
|
}
|
|
|
|
this.bookmarks = []
|
|
if (user.bookmarks) {
|
|
this.bookmarks = user.bookmarks.filter(bm => typeof bm.libraryItemId == 'string').map(bm => new AudioBookmark(bm))
|
|
}
|
|
|
|
this.isActive = (user.isActive === undefined || user.type === 'root') ? true : !!user.isActive
|
|
this.isLocked = user.type === 'root' ? false : !!user.isLocked
|
|
this.lastSeen = user.lastSeen || null
|
|
this.createdAt = user.createdAt || Date.now()
|
|
this.settings = user.settings || this.getDefaultUserSettings()
|
|
this.permissions = user.permissions || this.getDefaultUserPermissions()
|
|
// Upload permission added v1.1.13, make sure root user has upload permissions
|
|
if (this.type === 'root' && !this.permissions.upload) this.permissions.upload = true
|
|
|
|
// Library restriction permissions added v1.4.14, defaults to all libraries
|
|
if (this.permissions.accessAllLibraries === undefined) this.permissions.accessAllLibraries = true
|
|
// Library restriction permissions added v2.0, defaults to all libraries
|
|
if (this.permissions.accessAllTags === undefined) this.permissions.accessAllTags = true
|
|
|
|
this.librariesAccessible = [...(user.librariesAccessible || [])]
|
|
this.itemTagsAccessible = [...(user.itemTagsAccessible || [])]
|
|
}
|
|
|
|
update(payload) {
|
|
var hasUpdates = false
|
|
// Update the following keys:
|
|
const keysToCheck = ['pash', 'type', 'username', 'isActive']
|
|
keysToCheck.forEach((key) => {
|
|
if (payload[key] !== undefined) {
|
|
if (key === 'isActive' || payload[key]) { // pash, type, username must evaluate to true (cannot be null or empty)
|
|
if (payload[key] !== this[key]) {
|
|
hasUpdates = true
|
|
this[key] = payload[key]
|
|
}
|
|
}
|
|
}
|
|
})
|
|
// And update permissions
|
|
if (payload.permissions) {
|
|
for (const key in payload.permissions) {
|
|
if (payload.permissions[key] !== this.permissions[key]) {
|
|
hasUpdates = true
|
|
this.permissions[key] = payload.permissions[key]
|
|
}
|
|
}
|
|
}
|
|
// Update accessible libraries
|
|
if (payload.librariesAccessible !== undefined) {
|
|
if (payload.librariesAccessible.length) {
|
|
if (payload.librariesAccessible.join(',') !== this.librariesAccessible.join(',')) {
|
|
hasUpdates = true
|
|
this.librariesAccessible = [...payload.librariesAccessible]
|
|
}
|
|
} else if (this.librariesAccessible.length > 0) {
|
|
hasUpdates = true
|
|
this.librariesAccessible = []
|
|
}
|
|
}
|
|
|
|
// Update accessible libraries
|
|
if (payload.itemTagsAccessible !== undefined) {
|
|
if (payload.itemTagsAccessible.length) {
|
|
if (payload.itemTagsAccessible.join(',') !== this.itemTagsAccessible.join(',')) {
|
|
hasUpdates = true
|
|
this.itemTagsAccessible = [...payload.itemTagsAccessible]
|
|
}
|
|
} else if (this.itemTagsAccessible.length > 0) {
|
|
hasUpdates = true
|
|
this.itemTagsAccessible = []
|
|
}
|
|
}
|
|
return hasUpdates
|
|
}
|
|
|
|
getMostRecentItemProgress(libraryItems) {
|
|
if (!this.libraryItemProgress.length) return null
|
|
var lip = this.libraryItemProgress.map(lip => lip.toJSON())
|
|
lip.sort((a, b) => b.lastUpdate - a.lastUpdate)
|
|
var mostRecentWithLip = lip.find(li => libraryItems.find(_li => _li.id === li.id))
|
|
if (!mostRecentWithLip) return null
|
|
var libraryItem = libraryItems.find(li => li.id === mostRecentWithLip.id)
|
|
return {
|
|
...mostRecentWithLip,
|
|
media: libraryItem.media.toJSONExpanded()
|
|
}
|
|
}
|
|
|
|
getLibraryItemProgress(libraryItemId) {
|
|
if (!this.libraryItemProgress) return null
|
|
return this.libraryItemProgress.find(lip => lip.id === libraryItemId)
|
|
}
|
|
|
|
createUpdateLibraryItemProgress(libraryItem, updatePayload) {
|
|
var itemProgress = this.libraryItemProgress.find(li => li.id === libraryItem.id)
|
|
if (!itemProgress) {
|
|
var newItemProgress = new LibraryItemProgress()
|
|
|
|
var mediaEntity = null
|
|
if (updatePayload.mediaEntityId) mediaEntity = libraryItem.media.getMediaEntityById(updatePayload.mediaEntityId)
|
|
if (!mediaEntity) mediaEntity = libraryItem.media.getPlaybackMediaEntity()
|
|
if (!mediaEntity) {
|
|
Logger.error(`[User] createUpdateLibraryItemProgress invalid library item has no playback media entity "${libraryItem.id}"`)
|
|
return false
|
|
}
|
|
|
|
newItemProgress.setData(libraryItem.id, mediaEntity.id, updatePayload)
|
|
this.libraryItemProgress.push(newItemProgress)
|
|
return true
|
|
}
|
|
var wasUpdated = itemProgress.update(updatePayload)
|
|
return wasUpdated
|
|
}
|
|
|
|
removeLibraryItemProgress(libraryItemId) {
|
|
if (!this.libraryItemProgress.some(lip => lip.id == libraryItemId)) return false
|
|
this.libraryItemProgress = this.libraryItemProgress.filter(lip => lip.id != libraryItemId)
|
|
return true
|
|
}
|
|
|
|
// Returns Boolean If update was made
|
|
updateSettings(settings) {
|
|
if (!this.settings) {
|
|
this.settings = { ...settings }
|
|
return true
|
|
}
|
|
var madeUpdates = false
|
|
|
|
for (const key in this.settings) {
|
|
if (settings[key] !== undefined && this.settings[key] !== settings[key]) {
|
|
this.settings[key] = settings[key]
|
|
madeUpdates = true
|
|
}
|
|
}
|
|
|
|
// Check if new settings update has keys not currently in user settings
|
|
for (const key in settings) {
|
|
if (settings[key] !== undefined && this.settings[key] === undefined) {
|
|
this.settings[key] = settings[key]
|
|
madeUpdates = true
|
|
}
|
|
}
|
|
|
|
return madeUpdates
|
|
}
|
|
|
|
checkCanAccessLibrary(libraryId) {
|
|
if (this.permissions.accessAllLibraries) return true
|
|
if (!this.librariesAccessible) return false
|
|
return this.librariesAccessible.includes(libraryId)
|
|
}
|
|
|
|
checkCanAccessLibraryItemWithTags(tags) {
|
|
if (this.permissions.accessAllTags || !tags || !tags.length) return true
|
|
return this.itemTagsAccessible.some(tag => tags.includes(tag))
|
|
}
|
|
|
|
findBookmark(libraryItemId, time) {
|
|
return this.bookmarks.find(bm => bm.libraryItemId === libraryItemId && bm.time == time)
|
|
}
|
|
|
|
createBookmark(libraryItemId, time, title) {
|
|
var existingBookmark = this.findBookmark(libraryItemId, time)
|
|
if (existingBookmark) {
|
|
Logger.warn('[User] Create Bookmark already exists for this time')
|
|
existingBookmark.title = title
|
|
return existingBookmark
|
|
}
|
|
var newBookmark = new AudioBookmark()
|
|
newBookmark.setData(libraryItemId, time, title)
|
|
this.bookmarks.push(newBookmark)
|
|
return newBookmark
|
|
}
|
|
|
|
updateBookmark(libraryItemId, time, title) {
|
|
var bookmark = this.findBookmark(libraryItemId, time)
|
|
if (!bookmark) {
|
|
Logger.error(`[User] updateBookmark not found`)
|
|
return null
|
|
}
|
|
bookmark.title = title
|
|
return bookmark
|
|
}
|
|
|
|
removeBookmark(libraryItemId, time) {
|
|
this.bookmarks = this.bookmarks.filter(bm => (bm.libraryItemId !== libraryItemId || bm.time !== time))
|
|
}
|
|
|
|
syncLocalUserAudiobookData(localUserAudiobookData, audiobook) {
|
|
if (!localUserAudiobookData || !localUserAudiobookData.audiobookId) {
|
|
Logger.error(`[User] Invalid local user audiobook data`, localUserAudiobookData)
|
|
return false
|
|
}
|
|
if (!this.audiobooks) this.audiobooks = {}
|
|
|
|
if (!this.audiobooks[localUserAudiobookData.audiobookId]) {
|
|
this.audiobooks[localUserAudiobookData.audiobookId] = new UserAudiobookData(localUserAudiobookData)
|
|
return true
|
|
}
|
|
|
|
var userAbD = this.audiobooks[localUserAudiobookData.audiobookId]
|
|
if (userAbD.lastUpdate >= localUserAudiobookData.lastUpdate) {
|
|
// Server audiobook data is more recent
|
|
return false
|
|
}
|
|
|
|
// Local Data More recent
|
|
var wasUpdated = this.audiobooks[localUserAudiobookData.audiobookId].update(localUserAudiobookData)
|
|
if (wasUpdated) {
|
|
Logger.debug(`[User] syncLocalUserAudiobookData local data was more recent for "${audiobook.title}"`)
|
|
}
|
|
return wasUpdated
|
|
}
|
|
}
|
|
module.exports = User |