karaoke-eternal 1.0.0

package/server/Queue/Queue.js

@@ -0,0 +1,208 @@
+const path = require('path')
+const db = require('../lib/Database').db
+const sql = require('sqlate')
+
+class Queue {
+  /**
+   * Add a songId to a room's queue
+   *
+   * @param  {object}      roomId, songId, userId
+   * @return {Promise}
+   */
+  static async add ({ roomId, songId, userId }) {
+    const fields = new Map()
+    fields.set('roomId', roomId)
+    fields.set('songId', songId)
+    fields.set('userId', userId)
+    fields.set('prevQueueId', sql`(
+      SELECT queueId
+      FROM queue
+      WHERE roomId = ${roomId} AND queueId NOT IN (
+        SELECT prevQueueId
+        FROM queue
+        WHERE prevQueueId IS NOT NULL
+      )
+    )`)
+
+    const query = sql`
+      INSERT INTO queue ${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 (res.changes !== 1) {
+      throw new Error('Could not add song to queue')
+    }
+  }
+
+  /**
+   * Get queued items for a given room
+   *
+   * @param  {Number}  roomId
+   * @return {Promise}
+   */
+  static async get (roomId) {
+    const result = []
+    const entities = {}
+    const map = new Map()
+    let curQueueId = null
+
+    const query = sql`
+      SELECT queueId, songId, userId, prevQueueId,
+        media.mediaId, media.relPath, media.rgTrackGain, media.rgTrackPeak,
+        users.name AS userDisplayName, users.dateUpdated,
+        MAX(isPreferred) AS isPreferred
+      FROM queue
+        INNER JOIN users USING(userId)
+        INNER JOIN media USING(songId)
+        INNER JOIN paths USING(pathId)
+      WHERE roomId = ${roomId}
+      GROUP BY queueId
+      ORDER BY queueId, paths.priority ASC
+    `
+    const rows = await db.all(String(query), query.parameters)
+
+    for (const row of rows) {
+      entities[row.queueId] = row
+      entities[row.queueId].mediaType = this.getType(row.relPath)
+
+      // don't send over the wire
+      delete entities[row.queueId].relPath
+      delete entities[row.queueId].isPreferred
+
+      if (row.prevQueueId === null) {
+        // found the first item
+        result.push(row.queueId)
+        curQueueId = row.queueId
+      } else {
+        // map indexed by prevQueueId
+        map.set(row.prevQueueId, row.queueId)
+      }
+    }
+
+    while (result.length < rows.length) {
+      // get the item whose prevQueueId references the current one
+      const nextQueueId = entities[map.get(curQueueId)].queueId
+      result.push(nextQueueId)
+      curQueueId = nextQueueId
+    }
+
+    return { result, entities }
+  }
+
+  /**
+   * Move a queue item
+   * @param  {object}      prevQueueId, queueId, roomId
+   * @return {Promise}     undefined
+   */
+  static async move ({ prevQueueId, queueId, roomId }) {
+    if (queueId === prevQueueId) {
+      throw new Error('Invalid prevQueueId')
+    }
+
+    if (prevQueueId === -1) prevQueueId = null
+
+    const query = sql`
+      UPDATE queue
+      SET prevQueueId = CASE
+        WHEN queueId = newChild THEN ${queueId}
+        WHEN queueId = curChild AND curParent IS NOT NULL AND newChild IS NOT NULL THEN curParent
+        WHEN queueId = ${queueId} THEN ${prevQueueId}
+        ELSE queue.prevQueueId
+      END
+      FROM (SELECT
+        (
+          SELECT prevQueueId
+          FROM queue
+          WHERE queueId = ${queueId}
+        ) AS curParent,
+        (
+          SELECT queueId
+          FROM queue
+          WHERE prevQueueId = ${queueId}
+        ) AS curChild,
+        (
+          SELECT queueId
+          FROM queue
+          WHERE queueId != ${queueId}
+            AND prevQueueId ${prevQueueId === null ? sql`IS NULL` : sql`= ${prevQueueId}`}
+            AND roomId = ${roomId}
+        ) AS newChild
+      )
+      WHERE roomId = ${roomId}
+    `
+    await db.run(String(query), query.parameters)
+  }
+
+  /**
+   * Delete a queue item
+   *
+   * We could DELETE first and get the deleted item's prevQueueId using
+   * RETURNING, but the DELETE and UPDATE need to be wrapped in a transaction
+   * (so the prevQueueId foreign key check is deferred). Also, v0.9 betas didn't
+   * have prevQueueId DEFFERABLE, and so will still error at DELETE (do we care?)
+   *
+   * @param  {object}      queueId, userId
+   * @return {Promise}     undefined
+   */
+  static async remove (queueId) {
+    // close the soon-to-be gap first
+    const updateQuery = sql`
+      UPDATE queue
+      SET prevQueueId = curParent
+      FROM (
+        SELECT
+          (
+            SELECT prevQueueId
+            FROM queue
+            WHERE queueId = ${queueId}
+          ) AS curParent,
+          (
+            SELECT queueId
+            FROM queue
+            WHERE prevQueueId = ${queueId}
+          ) AS curChild
+      )
+      WHERE queueId = curChild
+    `
+    await db.run(String(updateQuery), updateQuery.parameters)
+
+    // delete item
+    const deleteQuery = sql`
+      DELETE FROM queue
+      WHERE queueId = ${queueId}
+    `
+    const deleteRes = await db.run(String(deleteQuery), deleteQuery.parameters)
+
+    if (!deleteRes.changes) {
+      throw new Error(`Could not remove queueId: ${queueId}`)
+    }
+  }
+
+  /**
+   * Check if a user owns a queue item
+   * @param  {number} userId
+   * @param  {number} queueId
+   * @return {boolean}
+   */
+  static async isOwner (userId, queueId) {
+    const query = sql`
+      SELECT COUNT(*) AS count
+      FROM queue
+      WHERE userId = ${userId} AND queueId = ${queueId}
+    `
+    const res = await db.get(String(query), query.parameters)
+    return res.count === 1
+  }
+
+  /**
+   * Get media type from file extension
+   * @param  {string} file filename
+   * @return {string}      player component
+   */
+  static getType (file) {
+    return /\.mp4/i.test(path.extname(file)) ? 'mp4' : 'cdg'
+  }
+}
+
+module.exports = Queue

package/server/Queue/index.js

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

package/server/Queue/socket.js

@@ -0,0 +1,99 @@
+const Queue = require('./Queue')
+const Rooms = require('../Rooms')
+
+const {
+  QUEUE_ADD,
+  QUEUE_MOVE,
+  QUEUE_REMOVE,
+  QUEUE_PUSH,
+} = require('../../shared/actionTypes')
+
+// ------------------------------------
+// Action Handlers
+// ------------------------------------
+const ACTION_HANDLERS = {
+  [QUEUE_ADD]: async (sock, { payload }, acknowledge) => {
+    const { songId } = payload
+
+    try {
+      await Rooms.validate(sock.user.roomId, null, { validatePassword: false })
+    } catch (err) {
+      return acknowledge({
+        type: QUEUE_ADD + '_ERROR',
+        error: err.message,
+      })
+    }
+
+    await Queue.add({
+      roomId: sock.user.roomId,
+      songId,
+      userId: sock.user.userId,
+    })
+
+    // success
+    acknowledge({ type: QUEUE_ADD + '_SUCCESS' })
+
+    // to all in room
+    sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+      type: QUEUE_PUSH,
+      payload: await Queue.get(sock.user.roomId)
+    })
+  },
+  [QUEUE_MOVE]: async (sock, { payload }, acknowledge) => {
+    const { queueId, prevQueueId } = payload
+
+    try {
+      await Rooms.validate(sock.user.roomId, null, { validatePassword: false })
+    } catch (err) {
+      return acknowledge({
+        type: QUEUE_MOVE + '_ERROR',
+        error: err.message,
+      })
+    }
+
+    if (!sock.user.isAdmin && !await Queue.isOwner(sock.user.userId, queueId)) {
+      return acknowledge({
+        type: QUEUE_MOVE + '_ERROR',
+        error: 'Cannot move another user\'s song',
+      })
+    }
+
+    await Queue.move({
+      prevQueueId,
+      queueId,
+      roomId: sock.user.roomId,
+    })
+
+    // success
+    acknowledge({ type: QUEUE_MOVE + '_SUCCESS' })
+
+    // tell room
+    sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+      type: QUEUE_PUSH,
+      payload: await Queue.get(sock.user.roomId)
+    })
+  },
+  [QUEUE_REMOVE]: async (sock, { payload }, acknowledge) => {
+    const { queueId } = payload
+
+    if (!sock.user.isAdmin && !await Queue.isOwner(sock.user.userId, queueId)) {
+      return acknowledge({
+        type: QUEUE_REMOVE + '_ERROR',
+        error: 'Cannot remove another user\'s song',
+      })
+    }
+
+    await Queue.remove(queueId)
+
+    // success
+    acknowledge({ type: QUEUE_REMOVE + '_SUCCESS' })
+
+    // tell room
+    sock.server.to(Rooms.prefix(sock.user.roomId)).emit('action', {
+      type: QUEUE_PUSH,
+      payload: await Queue.get(sock.user.roomId)
+    })
+  },
+}
+
+module.exports = ACTION_HANDLERS

package/server/Rooms/Rooms.js

@@ -0,0 +1,114 @@
+const bcrypt = require('../lib/bcrypt')
+const db = require('../lib/Database').db
+const sql = require('sqlate')
+
+class Rooms {
+  /**
+   * Get all rooms
+   *
+   * @param  {Boolean}  closed  Whether to include rooms with status "closed"
+   * @return {Promise}
+   */
+  static async get (closed = false) {
+    const result = []
+    const entities = {}
+    const whereClause = closed ? sql`true` : sql`status = "open"`
+
+    const query = sql`
+      SELECT * FROM rooms
+      WHERE ${whereClause}
+      ORDER BY dateCreated DESC
+    `
+    const res = await db.all(String(query), query.parameters)
+
+    res.forEach(row => {
+      row.dateCreated = row.dateCreated.substring(0, 10)
+      row.hasPassword = !!row.password
+      delete row.password
+
+      result.push(row.roomId)
+      entities[row.roomId] = row
+    })
+
+    return { result, entities }
+  }
+
+  /**
+   * Validate a room against optional criteria
+   *
+   * @param  {Number}    roomId
+   * @param  {[String]}  password      Room password
+   * @param  {[Object]}  opts          (bool) isOpen, (bool) validatePassword
+   * @return {Promise}                 True if validated, otherwise throws an error
+   */
+  static async validate (roomId, password, { isOpen = true, validatePassword = true } = {}) {
+    const query = sql`
+      SELECT * FROM rooms
+      WHERE roomId = ${roomId}
+    `
+    const room = await db.get(String(query), query.parameters)
+
+    if (!room) {
+      throw new Error('Room not found')
+    }
+
+    if (isOpen && room.status !== 'open') {
+      throw new Error('Room is no longer open')
+    }
+
+    if (validatePassword && room.password) {
+      if (!password) {
+        throw new Error('Room password is required')
+      }
+
+      if (!await bcrypt.compare(password, room.password)) {
+        throw new Error('Incorrect room password')
+      }
+    }
+
+    return true
+  }
+
+  static prefix (roomId = '') {
+    return `ROOM_ID_${roomId}`
+  }
+
+  /**
+   * Utility method to list active rooms on a socket.io instance
+   *
+   * @param  {Object}  io  The socket.io instance
+   * @return {Array}       Array of objects as { room, roomId }
+   */
+  static getActive (io) {
+    const rooms = []
+
+    for (const room of io.sockets.adapter.rooms.keys()) {
+      // ignore auto-generated per-user rooms
+      if (room.startsWith(Rooms.prefix())) {
+        const roomId = parseInt(room.substring(Rooms.prefix().length), 10)
+        rooms.push({ room, roomId })
+      }
+    }
+
+    return rooms
+  }
+
+  /**
+   * Utility method to determine if a player is in a room
+   *
+   * @param  {Object}  io  The socket.io instance
+   * @param  {Object}  roomId  Room to check
+   * @return {Boolean}
+   */
+  static isPlayerPresent (io, roomId) {
+    for (const sock of io.of('/').sockets.values()) {
+      if (sock.user && sock.user.roomId === roomId && sock._lastPlayerStatus) {
+        return true
+      }
+    }
+
+    return false
+  }
+}
+
+module.exports = Rooms

package/server/Rooms/index.js

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

package/server/Rooms/router.js

@@ -0,0 +1,146 @@
+const bcrypt = require('../lib/bcrypt')
+const db = require('../lib/Database').db
+const sql = require('sqlate')
+const KoaRouter = require('koa-router')
+const router = KoaRouter({ prefix: '/api' })
+const log = require('../lib/Log')('Rooms')
+const Rooms = require('../Rooms')
+
+const BCRYPT_ROUNDS = 12
+const NAME_MIN_LENGTH = 1
+const NAME_MAX_LENGTH = 50
+const PASSWORD_MIN_LENGTH = 5
+const STATUSES = ['open', 'closed']
+
+// list rooms
+router.get('/rooms', async (ctx, next) => {
+  // non-admins can only see open rooms
+  const res = await Rooms.get(ctx.user.isAdmin)
+
+  res.result.forEach(roomId => {
+    const room = ctx.io.sockets.adapter.rooms.get(Rooms.prefix(roomId))
+    res.entities[roomId].numUsers = room ? room.size : 0
+  })
+
+  ctx.body = res
+})
+
+// create room
+router.post('/rooms', async (ctx, next) => {
+  if (!ctx.user.isAdmin) {
+    ctx.throw(401)
+  }
+
+  const { name, password, status } = ctx.request.body
+
+  if (!name || !name.trim() || name.length < NAME_MIN_LENGTH || name.length > NAME_MAX_LENGTH) {
+    ctx.throw(400, `Room name must have ${NAME_MIN_LENGTH}-${NAME_MAX_LENGTH} characters`)
+  }
+
+  if (password && password.length < PASSWORD_MIN_LENGTH) {
+    ctx.throw(400, `Room password must have at least ${PASSWORD_MIN_LENGTH} characters`)
+  }
+
+  if (!status || !STATUSES.includes(status)) {
+    ctx.throw(400, 'Invalid room status')
+  }
+
+  const fields = new Map()
+  fields.set('name', name.trim())
+  fields.set('password', password ? await bcrypt.hash(password, BCRYPT_ROUNDS) : null)
+  fields.set('status', status)
+  fields.set('dateCreated', Math.floor(Date.now() / 1000))
+
+  const query = sql`
+    INSERT INTO rooms ${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 (res.changes) {
+    log.verbose('%s created room "%s" (roomId: %s)', ctx.user.name, name, res.lastID)
+  }
+
+  // send updated room list
+  ctx.body = await Rooms.get(true)
+})
+
+// update room
+router.put('/rooms/:roomId', async (ctx, next) => {
+  if (!ctx.user.isAdmin) {
+    ctx.throw(401)
+  }
+
+  const { name, password, status } = ctx.request.body
+  const roomId = parseInt(ctx.params.roomId, 10)
+
+  if (!name || !name.trim() || name.length < NAME_MIN_LENGTH || name.length > NAME_MAX_LENGTH) {
+    ctx.throw(400, `Room name must have ${NAME_MIN_LENGTH}-${NAME_MAX_LENGTH} characters`)
+  }
+
+  if (password && password.length < PASSWORD_MIN_LENGTH) {
+    ctx.throw(400, `Room password must have at least ${PASSWORD_MIN_LENGTH} characters`)
+  }
+
+  if (!status || !STATUSES.includes(status)) {
+    ctx.throw(400, 'Invalid room status')
+  }
+
+  const fields = new Map()
+  fields.set('name', name.trim())
+  fields.set('status', status)
+  fields.set('roomId', roomId)
+
+  // falsey value will unset password
+  if (typeof password !== 'undefined') {
+    fields.set('password', password ? await bcrypt.hash(password, BCRYPT_ROUNDS) : null)
+  }
+
+  const query = sql`
+    UPDATE rooms
+    SET ${sql.tuple(Array.from(fields.keys()).map(sql.column))} = ${sql.tuple(Array.from(fields.values()))}
+    WHERE roomId = ${roomId}
+  `
+  const res = await db.run(String(query), query.parameters)
+
+  if (res.changes) {
+    log.verbose('%s updated roomId %s', ctx.user.name, ctx.params.roomId)
+  }
+
+  // send updated room list
+  ctx.body = await Rooms.get(true)
+})
+
+// remove room
+router.delete('/rooms/:roomId', async (ctx, next) => {
+  if (!ctx.user.isAdmin) {
+    ctx.throw(401)
+  }
+
+  const roomId = parseInt(ctx.params.roomId, 10)
+
+  if (typeof roomId !== 'number') {
+    ctx.throw(422, 'Invalid roomId')
+  }
+
+  // remove room's queue first
+  const queueQuery = sql`
+    DELETE FROM queue
+    WHERE roomId = ${roomId}
+  `
+  await db.run(String(queueQuery), queueQuery.parameters)
+
+  // remove room
+  const roomQuery = sql`
+    DELETE FROM rooms
+    WHERE roomId = ${roomId}
+  `
+  await db.run(String(roomQuery), roomQuery.parameters)
+
+  log.verbose('%s deleted roomId %s', ctx.user.name, roomId)
+
+  // send updated room list
+  ctx.body = await Rooms.get(true)
+})
+
+module.exports = router