karaoke-eternal 1.0.0

package/server/Media/router.js

@@ -0,0 +1,99 @@
+const { promisify } = require('util')
+const fs = require('fs')
+const stat = promisify(fs.stat)
+const path = require('path')
+const log = require('../lib/Log')('Media')
+const getCdgName = require('../lib/getCdgName')
+const KoaRouter = require('koa-router')
+const router = KoaRouter({ prefix: '/api/media' })
+const Library = require('../Library')
+const Media = require('./Media')
+const Prefs = require('../Prefs')
+const Queue = require('../Queue')
+const Rooms = require('../Rooms')
+const {
+  LIBRARY_PUSH_SONG,
+  QUEUE_PUSH
+} = require('../../shared/actionTypes')
+
+// stream a media file
+router.get('/:mediaId', async (ctx, next) => {
+  const { type } = ctx.query
+
+  if (!ctx.user.isAdmin) {
+    ctx.throw(401)
+  }
+
+  const mediaId = parseInt(ctx.params.mediaId, 10)
+
+  if (Number.isNaN(mediaId) || !type) {
+    ctx.throw(422, 'invalid mediaId or type')
+  }
+
+  // get media info
+  const res = await Media.search({ mediaId })
+
+  if (!res.result.length) {
+    ctx.throw(404, 'mediaId not found')
+  }
+
+  const { pathId, relPath } = res.entities[mediaId]
+
+  // get base path
+  const { paths } = await Prefs.get()
+  const basePath = paths.entities[pathId].path
+
+  let file = path.join(basePath, relPath)
+
+  if (type === 'cdg') {
+    file = await getCdgName(file)
+
+    if (!file) {
+      ctx.throw(404, 'The .cdg file could not be found')
+    }
+  }
+
+  // get file info
+  const stats = await stat(file)
+  ctx.length = stats.size
+  ctx.type = Media.mimeTypes[path.extname(file).replace('.', '').toLowerCase()]
+
+  if (typeof ctx.type === 'undefined') {
+    ctx.throw(404, `Unknown mime type for extension: ${path.extname(file)}`)
+  }
+
+  log.verbose('streaming %s (%sMB): %s', ctx.type, (ctx.length / 1000000).toFixed(2), file)
+  ctx.body = fs.createReadStream(file)
+})
+
+// set isPreferred flag
+router.all('/:mediaId/prefer', async (ctx, next) => {
+  if (!ctx.user.isAdmin) {
+    ctx.throw(401)
+  }
+
+  const mediaId = parseInt(ctx.params.mediaId, 10)
+
+  if (Number.isNaN(mediaId) || (ctx.request.method !== 'PUT' && ctx.request.method !== 'DELETE')) {
+    ctx.throw(422)
+  }
+
+  const songId = await Media.setPreferred(mediaId, ctx.request.method === 'PUT')
+  ctx.status = 200
+
+  // emit (potentially) updated queues to each room
+  for (const { room, roomId } of Rooms.getActive(ctx.io)) {
+    ctx.io.to(room).emit('action', {
+      type: QUEUE_PUSH,
+      payload: await Queue.get(roomId),
+    })
+  }
+
+  // emit (potentially) new duration
+  ctx.io.emit('action', {
+    type: LIBRARY_PUSH_SONG,
+    payload: await Library.getSong(songId),
+  })
+})
+
+module.exports = router

package/server/Player/socket.js

@@ -0,0 +1,78 @@
+const Rooms = require('../Rooms')
+const {
+  PLAYER_CMD_OPTIONS,
+  PLAYER_CMD_NEXT,
+  PLAYER_CMD_PAUSE,
+  PLAYER_CMD_PLAY,
+  PLAYER_CMD_VOLUME,
+  PLAYER_EMIT_STATUS,
+  PLAYER_EMIT_LEAVE,
+  PLAYER_REQ_OPTIONS,
+  PLAYER_REQ_NEXT,
+  PLAYER_REQ_PLAY,
+  PLAYER_REQ_PAUSE,
+  PLAYER_REQ_VOLUME,
+  PLAYER_STATUS,
+  PLAYER_LEAVE,
+} = require('../../shared/actionTypes')
+
+// ------------------------------------
+// Action Handlers
+// ------------------------------------
+const ACTION_HANDLERS = {
+  [PLAYER_REQ_OPTIONS]: async (sock, { payload }) => {
+    // @todo: emit to players only
+    sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+      type: PLAYER_CMD_OPTIONS,
+      payload,
+    })
+  },
+  [PLAYER_REQ_NEXT]: async (sock, { payload }) => {
+    // @todo: emit to players only
+    sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+      type: PLAYER_CMD_NEXT,
+    })
+  },
+  [PLAYER_REQ_PAUSE]: async (sock, { payload }) => {
+    // @todo: emit to players only
+    sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+      type: PLAYER_CMD_PAUSE,
+    })
+  },
+  [PLAYER_REQ_PLAY]: async (sock, { payload }) => {
+    // @todo: emit to players only
+    sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+      type: PLAYER_CMD_PLAY,
+    })
+  },
+  [PLAYER_REQ_VOLUME]: async (sock, { payload }) => {
+    // @todo: emit to players only
+    sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+      type: PLAYER_CMD_VOLUME,
+      payload,
+    })
+  },
+  [PLAYER_EMIT_STATUS]: async (sock, { payload }) => {
+    // so we can tell the room when players leave and
+    // relay last known player status on client join
+    sock._lastPlayerStatus = payload
+
+    sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+      type: PLAYER_STATUS,
+      payload,
+    })
+  },
+  [PLAYER_EMIT_LEAVE]: async (sock, { payload }) => {
+    sock._lastPlayerStatus = null
+
+    // any players left in room?
+    if (!Rooms.isPlayerPresent(sock.server, sock.user.roomId)) {
+      sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+        type: PLAYER_LEAVE,
+        payload: { socketId: sock.id },
+      })
+    }
+  },
+}
+
+module.exports = ACTION_HANDLERS

package/server/Prefs/Prefs.js

@@ -0,0 +1,165 @@
+const path = require('path')
+const db = require('../lib/Database').db
+const sql = require('sqlate')
+const crypto = require('crypto')
+const log = require('../lib/Log')('Prefs')
+
+class Prefs {
+  /**
+   * Gets prefs (includes media paths, does not inlcude JWT secret key)
+   * @return {Promise} Prefs object
+   */
+  static async get () {
+    const prefs = {
+      paths: { result: [], entities: {} }
+    }
+
+    {
+      const query = sql`
+        SELECT * FROM prefs
+        WHERE key != "jwtKey"
+      `
+      const rows = await db.all(String(query), query.parameters)
+
+      // json-decode key/val pairs
+      rows.forEach(row => {
+        prefs[row.key] = JSON.parse(row.data)
+      })
+    }
+
+    // include media paths
+    {
+      const query = sql`
+        SELECT * FROM paths
+        ORDER BY priority
+      `
+      const rows = await db.all(String(query), query.parameters)
+
+      for (const row of rows) {
+        prefs.paths.entities[row.pathId] = row
+        prefs.paths.result.push(row.pathId)
+      }
+    }
+
+    return prefs
+  }
+
+  /**
+   * Set a preference key
+   * @param  {string}  key  Prefs key name
+   * @param  {any}     data to be JSON encoded
+   * @return {Promise}      Success/fail boolean
+   */
+  static async set (key, data) {
+    const query = sql`
+      REPLACE INTO prefs (key, data)
+      VALUES (${key}, ${JSON.stringify(data)})
+    `
+    const res = await db.run(String(query), query.parameters)
+    return res.changes === 1
+  }
+
+  /**
+   * Add media path
+   * @param  {string}  dir Absolute path
+   * @return {Promise}     pathId (Number) of newly-added path
+   */
+  static async addPath (dir) {
+    const prefs = await Prefs.get()
+    const { result, entities } = prefs.paths
+
+    // is it a subfolder of an already-added folder?
+    if (result.some(pathId => (dir + path.sep).indexOf(entities[pathId].path + path.sep) === 0)) {
+      throw new Error('Folder has already been added')
+    }
+
+    const fields = new Map()
+    fields.set('path', dir)
+    // priority defaults to one higher than current highest
+    fields.set('priority', result.length ? entities[result[result.length - 1]].priority + 1 : 0)
+
+    const query = sql`
+      INSERT INTO paths ${sql.tuple(Array.from(fields.keys()).map(sql.column))}
+      VALUES ${sql.tuple(Array.from(fields.values()))}
+    `
+    const res = await db.run(String(query), query.parameters)
+
+    if (!Number.isInteger(res.lastID)) {
+      throw new Error('invalid lastID from path insert')
+    }
+
+    return res.lastID
+  }
+
+  /**
+   * Remove media path
+   * @param  {Number}  pathId
+   * @return {Promise}
+   */
+  static async removePath (pathId) {
+    const query = sql`
+      DELETE FROM paths
+      WHERE pathId = ${pathId}
+    `
+    await db.run(String(query), query.parameters)
+  }
+
+  /**
+   * Set media path priorities
+   * @param  {Array}  pathIds
+   * @return {Promise}
+   */
+  static async setPathPriority (pathIds) {
+    if (!Array.isArray(pathIds)) {
+      throw new Error('pathIds must be an array')
+    }
+
+    const query = sql`
+      UPDATE paths
+        SET priority = CASE pathId
+          ${sql.concat(pathIds.map((pathId, i) => sql`WHEN ${pathId} THEN ${i} `))}
+        END
+      WHERE pathId IN ${sql.tuple(pathIds)}
+      `
+    await db.run(String(query), query.parameters)
+  }
+
+  /**
+   * Get JWT secret key from db
+   * @return {Promise}  jwtKey (string)
+   */
+  static async getJwtKey (forceRotate = false) {
+    if (forceRotate) return this.rotateJwtKey()
+
+    const query = sql`
+      SELECT * FROM prefs
+      WHERE key = "jwtKey"
+    `
+    const row = await db.get(String(query), query.parameters)
+
+    if (row && row.data) {
+      const jwtKey = JSON.parse(row.data)
+      if (jwtKey.length === 64) return jwtKey
+    }
+
+    return this.rotateJwtKey()
+  }
+
+  /**
+   * Create or rotate JWT secret key
+   * @return {Promise}  jwtKey (string)
+   */
+  static async rotateJwtKey () {
+    const jwtKey = crypto.randomBytes(48).toString('base64') // 64 char
+    log.info('Rotating JWT secret key (length=%s)', jwtKey.length)
+
+    const query = sql`
+      REPLACE INTO prefs (key, data)
+      VALUES ("jwtKey", ${JSON.stringify(jwtKey)})
+    `
+    const res = await db.run(String(query), query.parameters)
+    if (res.changes) return jwtKey
+  }
+}
+
+module.exports = Prefs

package/server/Prefs/index.js

@@ -0,0 +1,3 @@
+const Prefs = require('./Prefs')
+
+module.exports = Prefs

package/server/Prefs/router.js

@@ -0,0 +1,124 @@
+const path = require('path')
+const log = require('../lib/Log')('Prefs')
+const KoaRouter = require('koa-router')
+const router = KoaRouter({ prefix: '/api/prefs' })
+const getFolders = require('../lib/getFolders')
+const getWindowsDrives = require('../lib/getWindowsDrives')
+const Prefs = require('./Prefs')
+
+// start media scan
+router.get('/scan', async (ctx, next) => {
+  if (!ctx.user.isAdmin) {
+    ctx.throw(401)
+  }
+
+  ctx.status = 200
+  ctx.startScanner()
+})
+
+// stop media scan
+router.get('/scan/stop', async (ctx, next) => {
+  if (!ctx.user.isAdmin) {
+    ctx.throw(401)
+  }
+
+  ctx.status = 200
+  ctx.stopScanner()
+})
+
+// get preferences and media paths
+router.get('/', async (ctx, next) => {
+  const prefs = await Prefs.get()
+
+  // must be admin or firstrun
+  if (prefs.isFirstRun || ctx.user.isAdmin) {
+    ctx.body = prefs
+    return
+  }
+
+  // there are no non-admin prefs but we don't want to
+  // trigger a fetch error on the frontend
+  ctx.body = {}
+})
+
+// add media file path
+router.post('/path', async (ctx, next) => {
+  const dir = decodeURIComponent(ctx.query.dir)
+
+  if (!ctx.user.isAdmin) {
+    ctx.throw(401)
+  }
+
+  // required
+  if (!dir) {
+    ctx.throw(422, 'Invalid path')
+  }
+
+  await Prefs.addPath(dir)
+
+  // respond with updated prefs
+  ctx.body = await Prefs.get()
+
+  // update library
+  ctx.startScanner()
+})
+
+// remove media file path
+router.delete('/path/:pathId', async (ctx, next) => {
+  if (!ctx.user.isAdmin) {
+    ctx.throw(401)
+  }
+
+  const pathId = parseInt(ctx.params.pathId, 10)
+
+  if (isNaN(pathId)) {
+    ctx.throw(422, 'Invalid pathId')
+  }
+
+  await Prefs.removePath(pathId)
+
+  // respond with updated prefs
+  ctx.body = await Prefs.get()
+
+  // update library
+  ctx.startScanner()
+})
+
+// get folder listing for path browser
+router.get('/path/ls', async (ctx, next) => {
+  if (!ctx.user.isAdmin) {
+    ctx.throw(401)
+  }
+
+  const dir = decodeURIComponent(ctx.query.dir)
+
+  // windows is a special snowflake and gets an
+  // extra top level of available drive letters
+  if (dir === '' && process.platform === 'win32') {
+    const drives = await getWindowsDrives()
+
+    ctx.body = {
+      current: '',
+      parent: false,
+      children: drives,
+    }
+  } else {
+    const current = path.resolve(dir)
+    const parent = path.resolve(dir, '../')
+
+    const list = await getFolders(dir)
+    log.verbose('%s listed path: %s', ctx.user.name, current)
+
+    ctx.body = {
+      current,
+      // if at root, windows gets a special top level
+      parent: parent === current ? (process.platform === 'win32' ? '' : false) : parent,
+      children: list.map(p => ({
+        path: p,
+        label: p.replace(current + path.sep, '')
+      })).filter(c => !(c.label.startsWith('.') || c.label.startsWith('/.')))
+    }
+  }
+})
+
+module.exports = router

package/server/Prefs/socket.js

@@ -0,0 +1,68 @@
+const log = require('../lib/Log')(`server[${process.pid}]`)
+const Library = require('../Library')
+const Prefs = require('./Prefs')
+const {
+  LIBRARY_PUSH,
+  PREFS_SET_PATH_PRIORITY,
+  PREFS_PUSH,
+  PREFS_SET,
+  _ERROR,
+} = require('../../shared/actionTypes')
+
+const ACTION_HANDLERS = {
+  [PREFS_SET]: async (sock, { payload }, acknowledge) => {
+    if (!sock.user.isAdmin) {
+      acknowledge({
+        type: PREFS_SET + _ERROR,
+        error: 'Unauthorized',
+      })
+    }
+
+    await Prefs.set(payload.key, payload.data)
+    log.info('%s (%s) set pref %s = %s', sock.user.name, sock.id, payload.key, payload.data)
+
+    await pushPrefs(sock)
+  },
+  [PREFS_SET_PATH_PRIORITY]: async (sock, { payload }, acknowledge) => {
+    if (!sock.user.isAdmin) {
+      acknowledge({
+        type: PREFS_SET_PATH_PRIORITY + _ERROR,
+        error: 'Unauthorized',
+      })
+    }
+
+    await Prefs.setPathPriority(payload)
+    log.info('%s re-prioritized media folders; pushing library to all', sock.user.name)
+
+    await pushPrefs(sock)
+
+    // invalidate cache
+    Library.cache.version = null
+
+    sock.server.emit('action', {
+      type: LIBRARY_PUSH,
+      payload: await Library.get(),
+    })
+  },
+}
+
+// helper to push prefs to admins
+const pushPrefs = async (sock) => {
+  const admins = []
+
+  for (const s of sock.server.sockets.sockets.values()) {
+    if (s.user && s.user.isAdmin) {
+      admins.push(s.id)
+      sock.server.to(s.id)
+    }
+  }
+
+  if (admins.length) {
+    sock.server.emit('action', {
+      type: PREFS_PUSH,
+      payload: await Prefs.get(),
+    })
+  }
+}
+
+module.exports = ACTION_HANDLERS