Adding download tab and download manager, ffmpeg in worker thread

server/objects/AudioFile.js

@@ -0,0 +1,146 @@
+class AudioFile {
+  constructor(data) {
+    this.index = null
+    this.ino = null
+    this.filename = null
+    this.ext = null
+    this.path = null
+    this.fullPath = null
+    this.addedAt = null
+
+    this.trackNumFromMeta = null
+    this.trackNumFromFilename = null
+
+    this.format = null
+    this.duration = null
+    this.size = null
+    this.bitRate = null
+    this.language = null
+    this.codec = null
+    this.timeBase = null
+    this.channels = null
+    this.channelLayout = null
+
+    this.tagAlbum = null
+    this.tagArtist = null
+    this.tagGenre = null
+    this.tagTitle = null
+    this.tagTrack = null
+
+    this.manuallyVerified = false
+    this.invalid = false
+    this.error = null
+
+    if (data) {
+      this.construct(data)
+    }
+  }
+
+  toJSON() {
+    return {
+      index: this.index,
+      ino: this.ino,
+      filename: this.filename,
+      ext: this.ext,
+      path: this.path,
+      fullPath: this.fullPath,
+      addedAt: this.addedAt,
+      trackNumFromMeta: this.trackNumFromMeta,
+      trackNumFromFilename: this.trackNumFromFilename,
+      manuallyVerified: !!this.manuallyVerified,
+      invalid: !!this.invalid,
+      error: this.error || null,
+      format: this.format,
+      duration: this.duration,
+      size: this.size,
+      bitRate: this.bitRate,
+      language: this.language,
+      timeBase: this.timeBase,
+      channels: this.channels,
+      channelLayout: this.channelLayout,
+      tagAlbum: this.tagAlbum,
+      tagArtist: this.tagArtist,
+      tagGenre: this.tagGenre,
+      tagTitle: this.tagTitle,
+      tagTrack: this.tagTrack
+    }
+  }
+
+  construct(data) {
+    this.index = data.index
+    this.ino = data.ino
+    this.filename = data.filename
+    this.ext = data.ext
+    this.path = data.path
+    this.fullPath = data.fullPath
+    this.addedAt = data.addedAt
+    this.manuallyVerified = !!data.manuallyVerified
+    this.invalid = !!data.invalid
+    this.error = data.error || null
+
+    this.trackNumFromMeta = data.trackNumFromMeta || null
+    this.trackNumFromFilename = data.trackNumFromFilename || null
+
+    this.format = data.format
+    this.duration = data.duration
+    this.size = data.size
+    this.bitRate = data.bitRate
+    this.language = data.language
+    this.codec = data.codec
+    this.timeBase = data.timeBase
+    this.channels = data.channels
+    this.channelLayout = data.channelLayout
+
+    this.tagAlbum = data.tagAlbum
+    this.tagArtist = data.tagArtist
+    this.tagGenre = data.tagGenre
+    this.tagTitle = data.tagTitle
+    this.tagTrack = data.tagTrack
+  }
+
+  setData(data) {
+    this.index = data.index || null
+    this.ino = data.ino || null
+    this.filename = data.filename
+    this.ext = data.ext
+    this.path = data.path
+    this.fullPath = data.fullPath
+    this.addedAt = Date.now()
+
+    this.trackNumFromMeta = data.trackNumFromMeta || null
+    this.trackNumFromFilename = data.trackNumFromFilename || null
+
+    this.manuallyVerified = !!data.manuallyVerified
+    this.invalid = !!data.invalid
+    this.error = data.error || null
+
+    this.format = data.format
+    this.duration = data.duration
+    this.size = data.size
+    this.bitRate = data.bit_rate
+    this.language = data.language
+    this.codec = data.codec
+    this.timeBase = data.time_base
+    this.channels = data.channels
+    this.channelLayout = data.channel_layout
+
+    this.tagAlbum = data.file_tag_album || null
+    this.tagArtist = data.file_tag_artist || null
+    this.tagGenre = data.file_tag_genre || null
+    this.tagTitle = data.file_tag_title || null
+    this.tagTrack = data.file_tag_track || null
+  }
+
+  syncFile(newFile) {
+    var hasUpdates = false
+    var keysToSync = ['path', 'fullPath', 'ext', 'filename']
+    keysToSync.forEach((key) => {
+      if (newFile[key] !== undefined && newFile[key] !== this[key]) {
+        hasUpdates = true
+        this[key] = newFile[key]
+      }
+    })
+    return hasUpdates
+  }
+}
+module.exports = AudioFile

server/objects/AudioTrack.js

@@ -0,0 +1,126 @@
+var { bytesPretty } = require('../utils/fileUtils')
+
+class AudioTrack {
+  constructor(audioTrack = null) {
+    this.index = null
+    this.ino = null
+
+    this.path = null
+    this.fullPath = null
+    this.ext = null
+    this.filename = null
+
+    this.format = null
+    this.duration = null
+    this.size = null
+    this.bitRate = null
+    this.language = null
+    this.codec = null
+    this.timeBase = null
+    this.channels = null
+    this.channelLayout = null
+
+    this.tagAlbum = null
+    this.tagArtist = null
+    this.tagGenre = null
+    this.tagTitle = null
+    this.tagTrack = null
+
+    if (audioTrack) {
+      this.construct(audioTrack)
+    }
+  }
+
+  construct(audioTrack) {
+    this.index = audioTrack.index
+    this.ino = audioTrack.ino || null
+
+    this.path = audioTrack.path
+    this.fullPath = audioTrack.fullPath
+    this.ext = audioTrack.ext
+    this.filename = audioTrack.filename
+
+    this.format = audioTrack.format
+    this.duration = audioTrack.duration
+    this.size = audioTrack.size
+    this.bitRate = audioTrack.bitRate
+    this.language = audioTrack.language
+    this.codec = audioTrack.codec
+    this.timeBase = audioTrack.timeBase
+    this.channels = audioTrack.channels
+    this.channelLayout = audioTrack.channelLayout
+
+    this.tagAlbum = audioTrack.tagAlbum
+    this.tagArtist = audioTrack.tagArtist
+    this.tagGenre = audioTrack.tagGenre
+    this.tagTitle = audioTrack.tagTitle
+    this.tagTrack = audioTrack.tagTrack
+  }
+
+  get name() {
+    return `${String(this.index).padStart(3, '0')}: ${this.filename} (${bytesPretty(this.size)}) [${this.duration}]`
+  }
+
+  toJSON() {
+    return {
+      index: this.index,
+      ino: this.ino,
+      path: this.path,
+      fullPath: this.fullPath,
+      ext: this.ext,
+      filename: this.filename,
+      format: this.format,
+      duration: this.duration,
+      size: this.size,
+      bitRate: this.bitRate,
+      language: this.language,
+      timeBase: this.timeBase,
+      channels: this.channels,
+      channelLayout: this.channelLayout,
+      tagAlbum: this.tagAlbum,
+      tagArtist: this.tagArtist,
+      tagGenre: this.tagGenre,
+      tagTitle: this.tagTitle,
+      tagTrack: this.tagTrack
+    }
+  }
+
+  setData(probeData) {
+    this.index = probeData.index
+    this.ino = probeData.ino || null
+
+    this.path = probeData.path
+    this.fullPath = probeData.fullPath
+    this.ext = probeData.ext
+    this.filename = probeData.filename
+
+    this.format = probeData.format
+    this.duration = probeData.duration
+    this.size = probeData.size
+    this.bitRate = probeData.bit_rate
+    this.language = probeData.language
+    this.codec = probeData.codec
+    this.timeBase = probeData.time_base
+    this.channels = probeData.channels
+    this.channelLayout = probeData.channel_layout
+
+    this.tagAlbum = probeData.file_tag_album || null
+    this.tagArtist = probeData.file_tag_artist || null
+    this.tagGenre = probeData.file_tag_genre || null
+    this.tagTitle = probeData.file_tag_title || null
+    this.tagTrack = probeData.file_tag_track || null
+  }
+
+  syncFile(newFile) {
+    var hasUpdates = false
+    var keysToSync = ['path', 'fullPath', 'ext', 'filename']
+    keysToSync.forEach((key) => {
+      if (newFile[key] !== undefined && newFile[key] !== this[key]) {
+        hasUpdates = true
+        this[key] = newFile[key]
+      }
+    })
+    return hasUpdates
+  }
+}
+module.exports = AudioTrack

server/objects/Audiobook.js

@@ -0,0 +1,394 @@
+const Path = require('path')
+const { bytesPretty, elapsedPretty } = require('../utils/fileUtils')
+const { comparePaths, getIno } = require('../utils/index')
+const Logger = require('../Logger')
+const Book = require('./Book')
+const AudioTrack = require('./AudioTrack')
+const AudioFile = require('./AudioFile')
+const AudiobookFile = require('./AudiobookFile')
+
+class Audiobook {
+  constructor(audiobook = null) {
+    this.id = null
+    this.ino = null // Inode
+
+    this.path = null
+    this.fullPath = null
+
+    this.addedAt = null
+    this.lastUpdate = null
+
+    this.tracks = []
+    this.missingParts = []
+
+    this.audioFiles = []
+    this.otherFiles = []
+
+    this.tags = []
+    this.book = null
+
+    if (audiobook) {
+      this.construct(audiobook)
+    }
+  }
+
+  construct(audiobook) {
+    this.id = audiobook.id
+    this.ino = audiobook.ino || null
+
+    this.path = audiobook.path
+    this.fullPath = audiobook.fullPath
+    this.addedAt = audiobook.addedAt
+    this.lastUpdate = audiobook.lastUpdate || this.addedAt
+
+    this.tracks = audiobook.tracks.map(track => new AudioTrack(track))
+    this.missingParts = audiobook.missingParts
+
+    this.audioFiles = audiobook.audioFiles.map(file => new AudioFile(file))
+    this.otherFiles = audiobook.otherFiles.map(file => new AudiobookFile(file))
+
+    this.tags = audiobook.tags
+    if (audiobook.book) {
+      this.book = new Book(audiobook.book)
+    }
+  }
+
+  get title() {
+    return this.book ? this.book.title : 'No Title'
+  }
+
+  get cover() {
+    return this.book ? this.book.cover : ''
+  }
+
+  get author() {
+    return this.book ? this.book.author : 'Unknown'
+  }
+
+  get authorLF() {
+    return this.book ? this.book.authorLF : null
+  }
+
+  get genres() {
+    return this.book ? this.book.genres || [] : []
+  }
+
+  get totalDuration() {
+    var total = 0
+    this.tracks.forEach((track) => total += track.duration)
+    return total
+  }
+
+  get totalSize() {
+    var total = 0
+    this.tracks.forEach((track) => total += track.size)
+    return total
+  }
+
+  get sizePretty() {
+    return bytesPretty(this.totalSize)
+  }
+
+  get durationPretty() {
+    return elapsedPretty(this.totalDuration)
+  }
+
+  get invalidParts() {
+    return (this.audioFiles || []).filter(af => af.invalid).map(af => ({ filename: af.filename, error: af.error || 'Unknown Error' }))
+  }
+
+  bookToJSON() {
+    return this.book ? this.book.toJSON() : null
+  }
+
+  tracksToJSON() {
+    if (!this.tracks || !this.tracks.length) return []
+    return this.tracks.map(t => t.toJSON())
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      ino: this.ino,
+      title: this.title,
+      author: this.author,
+      cover: this.cover,
+      path: this.path,
+      fullPath: this.fullPath,
+      addedAt: this.addedAt,
+      lastUpdate: this.lastUpdate,
+      missingParts: this.missingParts,
+      tags: this.tags,
+      book: this.bookToJSON(),
+      tracks: this.tracksToJSON(),
+      audioFiles: (this.audioFiles || []).map(audioFile => audioFile.toJSON()),
+      otherFiles: (this.otherFiles || []).map(otherFile => otherFile.toJSON())
+    }
+  }
+
+  toJSONMinified() {
+    return {
+      id: this.id,
+      ino: this.ino,
+      book: this.bookToJSON(),
+      tags: this.tags,
+      path: this.path,
+      fullPath: this.fullPath,
+      addedAt: this.addedAt,
+      lastUpdate: this.lastUpdate,
+      duration: this.totalDuration,
+      size: this.totalSize,
+      hasBookMatch: !!this.book,
+      hasMissingParts: this.missingParts ? this.missingParts.length : 0,
+      hasInvalidParts: this.invalidParts ? this.invalidParts.length : 0,
+      numTracks: this.tracks.length
+    }
+  }
+
+  toJSONExpanded() {
+    return {
+      id: this.id,
+      path: this.path,
+      fullPath: this.fullPath,
+      addedAt: this.addedAt,
+      lastUpdate: this.lastUpdate,
+      duration: this.totalDuration,
+      durationPretty: this.durationPretty,
+      size: this.totalSize,
+      sizePretty: this.sizePretty,
+      missingParts: this.missingParts,
+      invalidParts: this.invalidParts,
+      audioFiles: (this.audioFiles || []).map(audioFile => audioFile.toJSON()),
+      otherFiles: (this.otherFiles || []).map(otherFile => otherFile.toJSON()),
+      tags: this.tags,
+      book: this.bookToJSON(),
+      tracks: this.tracksToJSON()
+    }
+  }
+
+  // Scanner had a bug that was saving a file path as the audiobook path.
+  // audiobook path should be a directory.
+  // fixing this before a scan prevents audiobooks being removed and re-added
+  fixRelativePath(abRootPath) {
+    var pathExt = Path.extname(this.path)
+    if (pathExt) {
+      this.path = Path.dirname(this.path)
+      this.fullPath = Path.join(abRootPath, this.path)
+      Logger.warn('Audiobook path has extname', pathExt, 'fixed path:', this.path)
+      return true
+    }
+    return false
+  }
+
+  // Update was made to add ino values, ensure they are set
+  async checkUpdateInos() {
+    var hasUpdates = false
+    if (!this.ino) {
+      this.ino = await getIno(this.fullPath)
+      hasUpdates = true
+    }
+    for (let i = 0; i < this.audioFiles.length; i++) {
+      var af = this.audioFiles[i]
+      if (!af.ino || af.ino === this.ino) {
+        af.ino = await getIno(af.fullPath)
+        if (!af.ino) {
+          Logger.error('[Audiobook] checkUpdateInos: Failed to set ino for audio file', af.fullPath)
+        } else {
+          var track = this.tracks.find(t => comparePaths(t.path, af.path))
+          if (track) {
+            track.ino = af.ino
+          }
+        }
+        hasUpdates = true
+      }
+    }
+    return hasUpdates
+  }
+
+  setData(data) {
+    this.id = (Math.trunc(Math.random() * 1000) + Date.now()).toString(36)
+    this.ino = data.ino || null
+
+    this.path = data.path
+    this.fullPath = data.fullPath
+    this.addedAt = Date.now()
+    this.lastUpdate = this.addedAt
+
+    if (data.otherFiles) {
+      data.otherFiles.forEach((file) => {
+        this.addOtherFile(file)
+      })
+    }
+
+    this.setBook(data)
+  }
+
+  setBook(data) {
+    this.book = new Book()
+    this.book.setData(data)
+  }
+
+  addTrack(trackData) {
+    var track = new AudioTrack()
+    track.setData(trackData)
+    this.tracks.push(track)
+    return track
+  }
+
+  addAudioFile(audioFileData) {
+    var audioFile = new AudioFile()
+    audioFile.setData(audioFileData)
+    this.audioFiles.push(audioFile)
+    return audioFile
+  }
+
+  addOtherFile(fileData) {
+    var file = new AudiobookFile()
+    file.setData(fileData)
+    this.otherFiles.push(file)
+    return file
+  }
+
+  update(payload) {
+    var hasUpdates = false
+
+    if (payload.tags && payload.tags.join(',') !== this.tags.join(',')) {
+      this.tags = payload.tags
+      hasUpdates = true
+    }
+
+    if (payload.book) {
+      if (!this.book) {
+        this.setBook(payload.book)
+        hasUpdates = true
+      } else if (this.book.update(payload.book)) {
+        hasUpdates = true
+      }
+    }
+
+    if (hasUpdates) {
+      this.lastUpdate = Date.now()
+    }
+
+    return hasUpdates
+  }
+
+  updateAudioTracks(files) {
+    var index = 1
+    this.audioFiles = files.map((file) => {
+      file.manuallyVerified = true
+      file.invalid = false
+      file.error = null
+      file.index = index++
+      return new AudioFile(file)
+    })
+    this.tracks = []
+    this.missingParts = []
+    this.audioFiles.forEach((file) => {
+      this.addTrack(file)
+    })
+    this.lastUpdate = Date.now()
+  }
+
+  removeAudioFile(audioFile) {
+    this.tracks = this.tracks.filter(t => t.ino !== audioFile.ino)
+    this.audioFiles = this.audioFiles.filter(f => f.ino !== audioFile.ino)
+  }
+
+  checkUpdateMissingParts() {
+    var currMissingParts = (this.missingParts || []).join(',') || ''
+
+    var current_index = 1
+    var missingParts = []
+    for (let i = 0; i < this.tracks.length; i++) {
+      var _track = this.tracks[i]
+      if (_track.index > current_index) {
+        var num_parts_missing = _track.index - current_index
+        for (let x = 0; x < num_parts_missing; x++) {
+          missingParts.push(current_index + x)
+        }
+      }
+      current_index = _track.index + 1
+    }
+
+    this.missingParts = missingParts
+
+    var newMissingParts = (this.missingParts || []).join(',') || ''
+    var wasUpdated = newMissingParts !== currMissingParts
+    if (wasUpdated && this.missingParts.length) {
+      Logger.info(`[Audiobook] "${this.title}" has ${missingParts.length} missing parts`)
+    }
+
+    return wasUpdated
+  }
+
+  // On scan check other files found with other files saved
+  syncOtherFiles(newOtherFiles) {
+    var currOtherFileNum = this.otherFiles.length
+
+    var newOtherFilePaths = newOtherFiles.map(f => f.path)
+    this.otherFiles = this.otherFiles.filter(f => newOtherFilePaths.includes(f.path))
+
+    newOtherFiles.forEach((file) => {
+      var existingOtherFile = this.otherFiles.find(f => f.path === file.path)
+      if (!existingOtherFile) {
+        Logger.debug(`[Audiobook] New other file found on sync ${file.filename}/${file.filetype} | "${this.title}"`)
+        this.addOtherFile(file)
+      }
+    })
+
+    var hasUpdates = currOtherFileNum !== this.otherFiles.length
+
+    // Check if cover was a local image and that it still exists
+    var imageFiles = this.otherFiles.filter(f => f.filetype === 'image')
+    if (this.book.cover && this.book.cover.substr(1).startsWith('local')) {
+      var coverStillExists = imageFiles.find(f => comparePaths(f.path, this.book.cover.substr('/local/'.length)))
+      if (!coverStillExists) {
+        Logger.info(`[Audiobook] Local cover was removed | "${this.title}"`)
+        this.book.cover = null
+        hasUpdates = true
+      }
+    }
+
+    // If no cover set and image file exists then use it
+    if (!this.book.cover && imageFiles.length) {
+      this.book.cover = Path.join('/local', imageFiles[0].path)
+      Logger.info(`[Audiobook] Local cover was set | "${this.title}"`)
+      hasUpdates = true
+    }
+    return hasUpdates
+  }
+
+  syncAudioFile(audioFile, fileScanData) {
+    var hasUpdates = audioFile.syncFile(fileScanData)
+    var track = this.tracks.find(t => t.ino === audioFile.ino)
+    if (track && track.syncFile(fileScanData)) {
+      hasUpdates = true
+    }
+    return hasUpdates
+  }
+
+  syncPaths(audiobookData) {
+    var hasUpdates = false
+    var keysToSync = ['path', 'fullPath']
+    keysToSync.forEach((key) => {
+      if (audiobookData[key] !== undefined && audiobookData[key] !== this[key]) {
+        hasUpdates = true
+        this[key] = audiobookData[key]
+      }
+    })
+    if (hasUpdates) {
+      this.book.syncPathsUpdated(audiobookData)
+    }
+    return hasUpdates
+  }
+
+  isSearchMatch(search) {
+    return this.book.isSearchMatch(search.toLowerCase().trim())
+  }
+
+  getAudioFileByIno(ino) {
+    return this.audioFiles.find(af => af.ino === ino)
+  }
+}
+module.exports = Audiobook

server/objects/AudiobookFile.js

@@ -0,0 +1,48 @@
+class AudiobookFile {
+  constructor(data) {
+    this.ino = null
+    this.filetype = null
+    this.filename = null
+    this.ext = null
+    this.path = null
+    this.fullPath = null
+    this.addedAt = null
+
+    if (data) {
+      this.construct(data)
+    }
+  }
+
+  toJSON() {
+    return {
+      ino: this.ino || null,
+      filetype: this.filetype,
+      filename: this.filename,
+      ext: this.ext,
+      path: this.path,
+      fullPath: this.fullPath,
+      addedAt: this.addedAt
+    }
+  }
+
+  construct(data) {
+    this.ino = data.ino || null
+    this.filetype = data.filetype
+    this.filename = data.filename
+    this.ext = data.ext
+    this.path = data.path
+    this.fullPath = data.fullPath
+    this.addedAt = data.addedAt
+  }
+
+  setData(data) {
+    this.ino = data.ino || null
+    this.filetype = data.filetype
+    this.filename = data.filename
+    this.ext = data.ext
+    this.path = data.path
+    this.fullPath = data.fullPath
+    this.addedAt = Date.now()
+  }
+}
+module.exports = AudiobookFile

server/objects/Book.js

@@ -0,0 +1,157 @@
+const Path = require('path')
+const Logger = require('../Logger')
+const parseAuthors = require('../utils/parseAuthors')
+
+class Book {
+  constructor(book = null) {
+    this.olid = null
+    this.title = null
+    this.author = null
+    this.authorFL = null
+    this.authorLF = null
+    this.series = null
+    this.volumeNumber = null
+    this.publishYear = null
+    this.publisher = null
+    this.description = null
+    this.cover = null
+    this.genres = []
+
+    if (book) {
+      this.construct(book)
+    }
+  }
+
+  get _title() { return this.title || '' }
+  get _author() { return this.author || '' }
+  get _series() { return this.series || '' }
+
+  construct(book) {
+    this.olid = book.olid
+    this.title = book.title
+    this.author = book.author
+    this.authorFL = book.authorFL || null
+    this.authorLF = book.authorLF || null
+    this.series = book.series
+    this.volumeNumber = book.volumeNumber || null
+    this.publishYear = book.publishYear
+    this.publisher = book.publisher
+    this.description = book.description
+    this.cover = book.cover
+    this.genres = book.genres
+  }
+
+  toJSON() {
+    return {
+      olid: this.olid,
+      title: this.title,
+      author: this.author,
+      authorFL: this.authorFL,
+      authorLF: this.authorLF,
+      series: this.series,
+      volumeNumber: this.volumeNumber,
+      publishYear: this.publishYear,
+      publisher: this.publisher,
+      description: this.description,
+      cover: this.cover,
+      genres: this.genres
+    }
+  }
+
+  setParseAuthor(author) {
+    if (!author) {
+      var hasUpdated = this.authorFL || this.authorLF
+      this.authorFL = null
+      this.authorLF = null
+      return hasUpdated
+    }
+    try {
+      var { authorLF, authorFL } = parseAuthors(author)
+      var hasUpdated = authorLF !== this.authorLF || authorFL !== this.authorFL
+      this.authorFL = authorFL || null
+      this.authorLF = authorLF || null
+      return hasUpdated
+    } catch (err) {
+      Logger.error('[Book] Parse authors failed', err)
+      return false
+    }
+  }
+
+  setData(data) {
+    this.olid = data.olid || null
+    this.title = data.title || null
+    this.author = data.author || null
+    this.series = data.series || null
+    this.volumeNumber = data.volumeNumber || null
+    this.publishYear = data.publishYear || null
+    this.description = data.description || null
+    this.cover = data.cover || null
+    this.genres = data.genres || []
+
+    if (data.author) {
+      this.setParseAuthor(this.author)
+    }
+
+    // Use first image file as cover
+    if (data.otherFiles && data.otherFiles.length) {
+      var imageFile = data.otherFiles.find(f => f.filetype === 'image')
+      if (imageFile) {
+        this.cover = Path.normalize(Path.join('/local', imageFile.path))
+      }
+    }
+  }
+
+  update(payload) {
+    var hasUpdates = false
+
+    if (payload.cover) {
+      // If updating to local cover then normalize path
+      if (!payload.cover.startsWith('http:') && !payload.cover.startsWith('https:')) {
+        payload.cover = Path.normalize(payload.cover)
+      }
+    }
+
+    for (const key in payload) {
+      if (payload[key] === undefined) continue;
+
+      if (key === 'genres') {
+        if (payload['genres'] === null && this.genres !== null) {
+          this.genres = []
+          hasUpdates = true
+        } else if (payload['genres'].join(',') !== this.genres.join(',')) {
+          this.genres = payload['genres']
+          hasUpdates = true
+        }
+      } else if (key === 'author') {
+        if (this.author !== payload.author) {
+          this.author = payload.author || null
+          hasUpdates = true
+        }
+        if (this.setParseAuthor(this.author)) {
+          hasUpdates = true
+        }
+      } else if (this[key] !== undefined && payload[key] !== this[key]) {
+        this[key] = payload[key]
+        hasUpdates = true
+      }
+    }
+    return hasUpdates
+  }
+
+  // If audiobook directory path was changed, check and update properties set from dirnames
+  // May be worthwhile checking if these were manually updated and not override manual updates
+  syncPathsUpdated(audiobookData) {
+    var keysToSync = ['author', 'title', 'series', 'publishYear']
+    var syncPayload = {}
+    keysToSync.forEach((key) => {
+      if (audiobookData[key]) syncPayload[key] = audiobookData[key]
+    })
+    if (!Object.keys(syncPayload).length) return false
+    return this.update(syncPayload)
+  }
+
+  isSearchMatch(search) {
+    return this._title.toLowerCase().includes(search) || this._author.toLowerCase().includes(search) || this._series.toLowerCase().includes(search)
+  }
+}
+module.exports = Book

server/objects/Download.js

@@ -0,0 +1,107 @@
+const DEFAULT_EXPIRATION = 1000 * 60 * 10 // 10 minutes
+
+class Download {
+  constructor(download) {
+    this.id = null
+    this.audiobookId = null
+    this.type = null
+    this.options = {}
+
+    this.dirpath = null
+    this.fullPath = null
+    this.ext = null
+    this.filename = null
+    this.size = 0
+
+    this.userId = null
+    this.socket = null // Socket to notify when complete
+    this.isReady = false
+
+    this.startedAt = null
+    this.finishedAt = null
+    this.expiresAt = null
+
+    this.expirationTimeMs = 0
+
+    if (download) {
+      this.construct(download)
+    }
+  }
+
+  get mimeType() {
+    if (this.ext === '.mp3' || this.ext === '.m4b' || this.ext === '.m4a') {
+      return 'audio/mpeg'
+    } else if (this.ext === '.mp4') {
+      return 'audio/mp4'
+    } else if (this.ext === '.ogg') {
+      return 'audio/ogg'
+    } else if (this.ext === '.aac' || this.ext === '.m4p') {
+      return 'audio/aac'
+    }
+    return 'audio/mpeg'
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      audiobookId: this.audiobookId,
+      type: this.type,
+      options: this.options,
+      dirpath: this.dirpath,
+      fullPath: this.fullPath,
+      ext: this.ext,
+      filename: this.filename,
+      size: this.size,
+      userId: this.userId,
+      isReady: this.isReady,
+      startedAt: this.startedAt,
+      finishedAt: this.finishedAt,
+      expirationSeconds: this.expirationSeconds
+    }
+  }
+
+  construct(download) {
+    this.id = download.id
+    this.audiobookId = download.audiobookId
+    this.type = download.type
+    this.options = { ...download.options }
+
+    this.dirpath = download.dirpath
+    this.fullPath = download.fullPath
+    this.ext = download.ext
+    this.filename = download.filename
+    this.size = download.size || 0
+
+    this.userId = download.userId
+    this.socket = download.socket || null
+    this.isReady = !!download.isReady
+
+    this.startedAt = download.startedAt
+    this.finishedAt = download.finishedAt || null
+
+    this.expirationTimeMs = download.expirationTimeMs || DEFAULT_EXPIRATION
+    this.expiresAt = download.expiresAt || null
+  }
+
+  setData(downloadData) {
+    downloadData.startedAt = Date.now()
+    downloadData.isProcessing = true
+    this.construct(downloadData)
+  }
+
+  setComplete(fileSize) {
+    this.finishedAt = Date.now()
+    this.size = fileSize
+    this.isReady = true
+    this.expiresAt = this.finishedAt + this.expirationTimeMs
+  }
+
+  setExpirationTimer(callback) {
+    setTimeout(() => {
+      if (callback) {
+        callback(this)
+      }
+    }, this.expirationTimeMs)
+  }
+}
+module.exports = Download

server/objects/Stream.js

@@ -0,0 +1,349 @@
+const Ffmpeg = require('fluent-ffmpeg')
+const EventEmitter = require('events')
+const Path = require('path')
+const fs = require('fs-extra')
+const Logger = require('../Logger')
+const { secondsToTimestamp } = require('../utils/fileUtils')
+const { writeConcatFile } = require('../utils/ffmpegHelpers')
+const hlsPlaylistGenerator = require('../utils/hlsPlaylistGenerator')
+
+class Stream extends EventEmitter {
+  constructor(streamPath, client, audiobook) {
+    super()
+
+    this.id = (Date.now() + Math.trunc(Math.random() * 1000)).toString(36)
+    this.client = client
+    this.audiobook = audiobook
+
+    this.segmentLength = 6
+    this.segmentBasename = 'output-%d.ts'
+    this.streamPath = Path.join(streamPath, this.id)
+    this.concatFilesPath = Path.join(this.streamPath, 'files.txt')
+    this.playlistPath = Path.join(this.streamPath, 'output.m3u8')
+    this.finalPlaylistPath = Path.join(this.streamPath, 'final-output.m3u8')
+    this.startTime = 0
+
+    this.ffmpeg = null
+    this.loop = null
+    this.isResetting = false
+    this.isClientInitialized = false
+    this.isTranscodeComplete = false
+    this.segmentsCreated = new Set()
+    this.furthestSegmentCreated = 0
+    this.clientCurrentTime = 0
+
+    this.init()
+  }
+
+  get socket() {
+    return this.client.socket
+  }
+
+  get audiobookId() {
+    return this.audiobook.id
+  }
+
+  get totalDuration() {
+    return this.audiobook.totalDuration
+  }
+
+  get segmentStartNumber() {
+    if (!this.startTime) return 0
+    return Math.floor(this.startTime / this.segmentLength)
+  }
+
+  get numSegments() {
+    var numSegs = Math.floor(this.totalDuration / this.segmentLength)
+    if (this.totalDuration - (numSegs * this.segmentLength) > 0) {
+      numSegs++
+    }
+    return numSegs
+  }
+
+  get tracks() {
+    return this.audiobook.tracks
+  }
+
+  get clientPlaylistUri() {
+    return `/hls/${this.id}/output.m3u8`
+  }
+
+  get clientProgress() {
+    if (!this.clientCurrentTime) return 0
+    return Number((this.clientCurrentTime / this.totalDuration).toFixed(3))
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      clientId: this.client.id,
+      userId: this.client.user.id,
+      audiobook: this.audiobook.toJSONMinified(),
+      segmentLength: this.segmentLength,
+      playlistPath: this.playlistPath,
+      clientPlaylistUri: this.clientPlaylistUri,
+      clientCurrentTime: this.clientCurrentTime,
+      startTime: this.startTime,
+      segmentStartNumber: this.segmentStartNumber,
+      isTranscodeComplete: this.isTranscodeComplete
+    }
+  }
+
+  init() {
+    var clientUserAudiobooks = this.client.user ? this.client.user.audiobooks || {} : {}
+    var userAudiobook = clientUserAudiobooks[this.audiobookId] || null
+    if (userAudiobook) {
+      var timeRemaining = this.totalDuration - userAudiobook.currentTime
+      Logger.info('[STREAM] User has progress for audiobook', userAudiobook, `Time Remaining: ${timeRemaining}s`)
+      if (timeRemaining > 15) {
+        this.startTime = userAudiobook.currentTime
+        this.clientCurrentTime = this.startTime
+      }
+    }
+  }
+
+  async checkSegmentNumberRequest(segNum) {
+    var segStartTime = segNum * this.segmentLength
+    if (this.startTime > segStartTime) {
+      Logger.warn(`[STREAM] Segment #${segNum} Request @${secondsToTimestamp(segStartTime)} is before start time (${secondsToTimestamp(this.startTime)}) - Reset Transcode`)
+      await this.reset(segStartTime - (this.segmentLength * 2))
+      return segStartTime
+    } else if (this.isTranscodeComplete) {
+      return false
+    }
+
+    var distanceFromFurthestSegment = segNum - this.furthestSegmentCreated
+    if (distanceFromFurthestSegment > 10) {
+      Logger.info(`Segment #${segNum} requested is ${distanceFromFurthestSegment} segments from latest (${secondsToTimestamp(segStartTime)}) - Reset Transcode`)
+      await this.reset(segStartTime - (this.segmentLength * 2))
+      return segStartTime
+    }
+
+    return false
+  }
+
+  updateClientCurrentTime(currentTime) {
+    Logger.debug('[Stream] Updated client current time', secondsToTimestamp(currentTime))
+    this.clientCurrentTime = currentTime
+  }
+
+  async generatePlaylist() {
+    fs.ensureDirSync(this.streamPath)
+    await hlsPlaylistGenerator(this.playlistPath, 'output', this.totalDuration, this.segmentLength)
+    return this.clientPlaylistUri
+  }
+
+  async checkFiles() {
+    try {
+      var files = await fs.readdir(this.streamPath)
+      files.forEach((file) => {
+        var extname = Path.extname(file)
+        if (extname === '.ts') {
+          var basename = Path.basename(file, extname)
+          var num_part = basename.split('-')[1]
+          var part_num = Number(num_part)
+          this.segmentsCreated.add(part_num)
+        }
+      })
+
+      if (!this.segmentsCreated.size) {
+        Logger.warn('No Segments')
+        return
+      }
+
+      if (this.segmentsCreated.size > 6 && !this.isClientInitialized) {
+        this.isClientInitialized = true
+        Logger.info(`[STREAM] ${this.id} notifying client that stream is ready`)
+        this.socket.emit('stream_open', this.toJSON())
+      }
+
+      var chunks = []
+      var current_chunk = []
+      var last_seg_in_chunk = -1
+
+      var segments = Array.from(this.segmentsCreated).sort((a, b) => a - b);
+      var lastSegment = segments[segments.length - 1]
+      if (lastSegment > this.furthestSegmentCreated) {
+        this.furthestSegmentCreated = lastSegment
+      }
+
+      // console.log('SORT', [...this.segmentsCreated].slice(0, 200).join(', '), segments.slice(0, 200).join(', '))
+      segments.forEach((seg) => {
+        if (!current_chunk.length || last_seg_in_chunk + 1 === seg) {
+          last_seg_in_chunk = seg
+          current_chunk.push(seg)
+        } else {
+          // console.log('Last Seg is not equal to - 1', last_seg_in_chunk, seg)
+          if (current_chunk.length === 1) chunks.push(current_chunk[0])
+          else chunks.push(`${current_chunk[0]}-${current_chunk[current_chunk.length - 1]}`)
+          last_seg_in_chunk = seg
+          current_chunk = [seg]
+        }
+      })
+      if (current_chunk.length) {
+        if (current_chunk.length === 1) chunks.push(current_chunk[0])
+        else chunks.push(`${current_chunk[0]}-${current_chunk[current_chunk.length - 1]}`)
+      }
+
+      var perc = (this.segmentsCreated.size * 100 / this.numSegments).toFixed(2) + '%'
+      Logger.info('[STREAM-CHECK] Check Files', this.segmentsCreated.size, 'of', this.numSegments, perc, `Furthest Segment: ${this.furthestSegmentCreated}`)
+      Logger.info('[STREAM-CHECK] Chunks', chunks.join(', '))
+
+      this.socket.emit('stream_progress', {
+        stream: this.id,
+        percentCreated: perc,
+        chunks,
+        numSegments: this.numSegments
+      })
+    } catch (error) {
+      Logger.error('Failed checkign files', error)
+    }
+  }
+
+  startLoop() {
+    this.socket.emit('stream_progress', { chunks: [], numSegments: 0 })
+    this.loop = setInterval(() => {
+      if (!this.isTranscodeComplete) {
+        this.checkFiles()
+      } else {
+        this.socket.emit('stream_ready')
+        clearTimeout(this.loop)
+      }
+    }, 2000)
+  }
+
+  async start() {
+    Logger.info(`[STREAM] START STREAM - Num Segments: ${this.numSegments}`)
+
+    this.ffmpeg = Ffmpeg()
+
+    var trackStartTime = await writeConcatFile(this.tracks, this.concatFilesPath, this.startTime)
+
+    this.ffmpeg.addInput(this.concatFilesPath)
+    this.ffmpeg.inputFormat('concat')
+    this.ffmpeg.inputOption('-safe 0')
+
+    if (this.startTime > 0) {
+      const shiftedStartTime = this.startTime - trackStartTime
+      Logger.info(`[STREAM] Starting Stream at startTime ${secondsToTimestamp(this.startTime)} and Segment #${this.segmentStartNumber}`)
+      this.ffmpeg.inputOption(`-ss ${shiftedStartTime}`)
+      this.ffmpeg.inputOption('-noaccurate_seek')
+    }
+
+    this.ffmpeg.addOption([
+      '-loglevel warning',
+      '-map 0:a',
+      '-c:a copy'
+    ])
+    this.ffmpeg.addOption([
+      '-f hls',
+      "-copyts",
+      "-avoid_negative_ts disabled",
+      "-max_delay 5000000",
+      "-max_muxing_queue_size 2048",
+      `-hls_time 6`,
+      "-hls_segment_type mpegts",
+      `-start_number ${this.segmentStartNumber}`,
+      "-hls_playlist_type vod",
+      "-hls_list_size 0",
+      "-hls_allow_cache 0"
+    ])
+    var segmentFilename = Path.join(this.streamPath, this.segmentBasename)
+    this.ffmpeg.addOption(`-hls_segment_filename ${segmentFilename}`)
+    this.ffmpeg.output(this.finalPlaylistPath)
+
+    this.ffmpeg.on('start', (command) => {
+      Logger.info('[INFO] FFMPEG transcoding started with command: ' + command)
+      if (this.isResetting) {
+        setTimeout(() => {
+          Logger.info('[STREAM] Clearing isResetting')
+          this.isResetting = false
+        }, 500)
+      }
+      this.startLoop()
+    })
+
+    this.ffmpeg.on('stderr', (stdErrline) => {
+      Logger.info(stdErrline)
+    })
+
+    this.ffmpeg.on('error', (err, stdout, stderr) => {
+      if (err.message && err.message.includes('SIGKILL')) {
+        // This is an intentional SIGKILL
+        Logger.info('[FFMPEG] Transcode Killed')
+        this.ffmpeg = null
+      } else {
+        Logger.error('Ffmpeg Err', err.message)
+      }
+    })
+
+    this.ffmpeg.on('end', (stdout, stderr) => {
+      Logger.info('[FFMPEG] Transcoding ended')
+      // For very small fast load
+      if (!this.isClientInitialized) {
+        this.isClientInitialized = true
+        Logger.info(`[STREAM] ${this.id} notifying client that stream is ready`)
+        this.socket.emit('stream_open', this.toJSON())
+      }
+      this.isTranscodeComplete = true
+      this.ffmpeg = null
+    })
+
+    this.ffmpeg.run()
+  }
+
+  async close() {
+    clearInterval(this.loop)
+
+    Logger.info('Closing Stream', this.id)
+    if (this.ffmpeg) {
+      this.ffmpeg.kill('SIGKILL')
+    }
+
+    await fs.remove(this.streamPath).then(() => {
+      Logger.info('Deleted session data', this.streamPath)
+    }).catch((err) => {
+      Logger.error('Failed to delete session data', err)
+    })
+
+    this.client.socket.emit('stream_closed', this.id)
+
+    this.emit('closed')
+  }
+
+  cancelTranscode() {
+    clearInterval(this.loop)
+    if (this.ffmpeg) {
+      this.ffmpeg.kill('SIGKILL')
+    }
+  }
+
+  async waitCancelTranscode() {
+    for (let i = 0; i < 20; i++) {
+      if (!this.ffmpeg) return true
+      await new Promise((resolve) => setTimeout(resolve, 500))
+    }
+    Logger.error('[STREAM] Transcode never closed...')
+    return false
+  }
+
+  async reset(time) {
+    if (this.isResetting) {
+      return Logger.info(`[STREAM] Stream ${this.id} already resetting`)
+    }
+    time = Math.max(0, time)
+    this.isResetting = true
+
+    if (this.ffmpeg) {
+      this.cancelTranscode()
+      await this.waitCancelTranscode()
+    }
+
+    this.isTranscodeComplete = false
+    this.startTime = time
+    this.clientCurrentTime = this.startTime
+    Logger.info(`Stream Reset New Start Time ${secondsToTimestamp(this.startTime)}`)
+    this.start()
+  }
+}
+module.exports = Stream

server/objects/User.js

@@ -0,0 +1,119 @@
+class User {
+  constructor(user) {
+    this.id = null
+    this.username = null
+    this.pash = null
+    this.type = null
+    this.stream = null
+    this.token = null
+    this.isActive = true
+    this.createdAt = null
+    this.audiobooks = null
+    this.settings = {}
+
+    if (user) {
+      this.construct(user)
+    }
+  }
+
+  getDefaultUserSettings() {
+    return {
+      orderBy: 'book.title',
+      orderDesc: false,
+      filterBy: 'all',
+      playbackRate: 1,
+      bookshelfCoverSize: 120
+    }
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      username: this.username,
+      pash: this.pash,
+      type: this.type,
+      stream: this.stream,
+      token: this.token,
+      audiobooks: this.audiobooks,
+      isActive: this.isActive,
+      createdAt: this.createdAt,
+      settings: this.settings
+    }
+  }
+
+  toJSONForBrowser() {
+    return {
+      id: this.id,
+      username: this.username,
+      type: this.type,
+      stream: this.stream,
+      token: this.token,
+      audiobooks: this.audiobooks,
+      isActive: this.isActive,
+      createdAt: this.createdAt,
+      settings: this.settings
+    }
+  }
+
+  construct(user) {
+    this.id = user.id
+    this.username = user.username
+    this.pash = user.pash
+    this.type = user.type
+    this.stream = user.stream || null
+    this.token = user.token
+    this.audiobooks = user.audiobooks || null
+    this.isActive = (user.isActive === undefined || user.id === 'root') ? true : !!user.isActive
+    this.createdAt = user.createdAt || Date.now()
+    this.settings = user.settings || this.getDefaultUserSettings()
+  }
+
+  updateAudiobookProgress(stream) {
+    if (!this.audiobooks) this.audiobooks = {}
+    if (!this.audiobooks[stream.audiobookId]) {
+      this.audiobooks[stream.audiobookId] = {
+        audiobookId: stream.audiobookId,
+        totalDuration: stream.totalDuration,
+        startedAt: Date.now()
+      }
+    }
+    this.audiobooks[stream.audiobookId].lastUpdate = Date.now()
+    this.audiobooks[stream.audiobookId].progress = stream.clientProgress
+    this.audiobooks[stream.audiobookId].currentTime = stream.clientCurrentTime
+  }
+
+  // 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
+  }
+
+  resetAudiobookProgress(audiobookId) {
+    if (!this.audiobooks || !this.audiobooks[audiobookId]) {
+      return false
+    }
+    delete this.audiobooks[audiobookId]
+    return true
+  }
+}
+module.exports = User