playlists.js 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552
  1. 'use strict';
  2. const db = require('../db');
  3. const io = require('../io');
  4. const cache = require('../cache');
  5. const utils = require('../utils');
  6. const logger = require('../logger');
  7. const hooks = require('./hooks');
  8. const async = require('async');
  9. const playlists = require('../playlists');
  10. const songs = require('../songs');
  11. cache.sub('playlist.create', playlistId => {
  12. playlists.getPlaylist(playlistId, (err, playlist) => {
  13. if (!err) {
  14. utils.socketsFromUser(playlist.createdBy, (sockets) => {
  15. sockets.forEach((socket) => {
  16. socket.emit('event:playlist.create', playlist);
  17. });
  18. });
  19. }
  20. });
  21. });
  22. cache.sub('playlist.delete', res => {
  23. utils.socketsFromUser(res.userId, (sockets) => {
  24. sockets.forEach((socket) => {
  25. socket.emit('event:playlist.delete', res.playlistId);
  26. });
  27. });
  28. });
  29. cache.sub('playlist.moveSongToTop', res => {
  30. utils.socketsFromUser(res.userId, (sockets) => {
  31. sockets.forEach((socket) => {
  32. socket.emit('event:playlist.moveSongToTop', {playlistId: res.playlistId, songId: res.songId});
  33. });
  34. });
  35. });
  36. cache.sub('playlist.moveSongToBottom', res => {
  37. utils.socketsFromUser(res.userId, (sockets) => {
  38. sockets.forEach((socket) => {
  39. socket.emit('event:playlist.moveSongToBottom', {playlistId: res.playlistId, songId: res.songId});
  40. });
  41. });
  42. });
  43. cache.sub('playlist.addSong', res => {
  44. utils.socketsFromUser(res.userId, (sockets) => {
  45. sockets.forEach((socket) => {
  46. socket.emit('event:playlist.addSong', { playlistId: res.playlistId, song: res.song });
  47. });
  48. });
  49. });
  50. cache.sub('playlist.removeSong', res => {
  51. utils.socketsFromUser(res.userId, (sockets) => {
  52. sockets.forEach((socket) => {
  53. socket.emit('event:playlist.removeSong', { playlistId: res.playlistId, songId: res.songId });
  54. });
  55. });
  56. });
  57. cache.sub('playlist.updateDisplayName', res => {
  58. utils.socketsFromUser(res.userId, (sockets) => {
  59. sockets.forEach((socket) => {
  60. socket.emit('event:playlist.updateDisplayName', { playlistId: res.playlistId, displayName: res.displayName });
  61. });
  62. });
  63. });
  64. let lib = {
  65. /**
  66. * Gets the first song from a private playlist
  67. *
  68. * @param {Object} session - the session object automatically added by socket.io
  69. * @param {String} playlistId - the id of the playlist we are getting the first song from
  70. * @param {Function} cb - gets called with the result
  71. * @param {String} userId - the userId automatically added by hooks
  72. */
  73. getFirstSong: hooks.loginRequired((session, playlistId, cb, userId) => {
  74. async.waterfall([
  75. (next) => {
  76. playlists.getPlaylist(playlistId, next);
  77. },
  78. (playlist, next) => {
  79. if (!playlist || playlist.createdBy !== userId) return next('Playlist not found.');
  80. next(null, playlist.songs[0]);
  81. }
  82. ], (err, song) => {
  83. if (err) {
  84. err = utils.getError(err);
  85. logger.error("PLAYLIST_GET_FIRST_SONG", `Getting the first song of playlist "${playlistId}" failed for user "${userId}". "${err}"`);
  86. return cb({ status: 'failure', message: err});
  87. }
  88. logger.success("PLAYLIST_GET_FIRST_SONG", `Successfully got the first song of playlist "${playlistId}" for user "${userId}".`);
  89. cb({
  90. status: 'success',
  91. song: song
  92. });
  93. });
  94. }),
  95. /**
  96. * Gets all playlists for the user requesting it
  97. *
  98. * @param {Object} session - the session object automatically added by socket.io
  99. * @param {Function} cb - gets called with the result
  100. * @param {String} userId - the userId automatically added by hooks
  101. */
  102. indexForUser: hooks.loginRequired((session, cb, userId) => {
  103. async.waterfall([
  104. (next) => {
  105. db.models.playlist.find({ createdBy: userId }, next);
  106. }
  107. ], (err, playlists) => {
  108. if (err) {
  109. err = utils.getError(err);
  110. logger.error("PLAYLIST_INDEX_FOR_USER", `Indexing playlists for user "${userId}" failed. "${err}"`);
  111. return cb({ status: 'failure', message: err});
  112. }
  113. logger.success("PLAYLIST_INDEX_FOR_USER", `Successfully indexed playlists for user "${userId}".`);
  114. cb({
  115. status: 'success',
  116. data: playlists
  117. });
  118. });
  119. }),
  120. /**
  121. * Creates a new private playlist
  122. *
  123. * @param {Object} session - the session object automatically added by socket.io
  124. * @param {Object} data - the data for the new private playlist
  125. * @param {Function} cb - gets called with the result
  126. * @param {String} userId - the userId automatically added by hooks
  127. */
  128. create: hooks.loginRequired((session, data, cb, userId) => {
  129. async.waterfall([
  130. (next) => {
  131. return (data) ? next() : cb({ 'status': 'failure', 'message': 'Invalid data' });
  132. },
  133. (next) => {
  134. const { displayName, songs } = data;
  135. db.models.playlist.create({
  136. displayName,
  137. songs,
  138. createdBy: userId,
  139. createdAt: Date.now()
  140. }, next);
  141. }
  142. ], (err, playlist) => {
  143. if (err) {
  144. err = utils.getError(err);
  145. logger.error("PLAYLIST_CREATE", `Creating private playlist failed for user "${userId}". "${err}"`);
  146. return cb({ status: 'failure', message: err});
  147. }
  148. cache.pub('playlist.create', playlist._id);
  149. logger.success("PLAYLIST_CREATE", `Successfully created private playlist for user "${userId}".`);
  150. cb({ 'status': 'success', 'message': 'Successfully created playlist' });
  151. });
  152. }),
  153. /**
  154. * Gets a playlist from id
  155. *
  156. * @param {Object} session - the session object automatically added by socket.io
  157. * @param {String} playlistId - the id of the playlist we are getting
  158. * @param {Function} cb - gets called with the result
  159. * @param {String} userId - the userId automatically added by hooks
  160. */
  161. getPlaylist: hooks.loginRequired((session, playlistId, cb, userId) => {
  162. async.waterfall([
  163. (next) => {
  164. playlists.getPlaylist(playlistId, next);
  165. },
  166. (playlist, next) => {
  167. if (!playlist || playlist.createdBy !== userId) return next('Playlist not found');
  168. next(null, playlist);
  169. }
  170. ], (err, playlist) => {
  171. if (err) {
  172. err = utils.getError(err);
  173. logger.error("PLAYLIST_GET", `Getting private playlist "${playlistId}" failed for user "${userId}". "${err}"`);
  174. return cb({ status: 'failure', message: err});
  175. }
  176. logger.success("PLAYLIST_GET", `Successfully got private playlist "${playlistId}" for user "${userId}".`);
  177. cb({
  178. status: 'success',
  179. data: playlist
  180. });
  181. });
  182. }),
  183. //TODO Remove this
  184. /**
  185. * Updates a private playlist
  186. *
  187. * @param {Object} session - the session object automatically added by socket.io
  188. * @param {String} playlistId - the id of the playlist we are updating
  189. * @param {Object} playlist - the new private playlist object
  190. * @param {Function} cb - gets called with the result
  191. * @param {String} userId - the userId automatically added by hooks
  192. */
  193. update: hooks.loginRequired((session, playlistId, playlist, cb, userId) => {
  194. async.waterfall([
  195. (next) => {
  196. db.models.playlist.update({ _id: playlistId, createdBy: userId }, playlist, {runValidators: true}, next);
  197. },
  198. (res, next) => {
  199. playlists.updatePlaylist(playlistId, next)
  200. }
  201. ], (err, playlist) => {
  202. if (err) {
  203. err = utils.getError(err);
  204. logger.error("PLAYLIST_UPDATE", `Updating private playlist "${playlistId}" failed for user "${userId}". "${err}"`);
  205. return cb({ status: 'failure', message: err});
  206. }
  207. logger.success("PLAYLIST_UPDATE", `Successfully updated private playlist "${playlistId}" for user "${userId}".`);
  208. cb({
  209. status: 'success',
  210. data: playlist
  211. });
  212. });
  213. }),
  214. /**
  215. * Adds a song to a private playlist
  216. *
  217. * @param {Object} session - the session object automatically added by socket.io
  218. * @param {String} songId - the id of the song we are trying to add
  219. * @param {String} playlistId - the id of the playlist we are adding the song to
  220. * @param {Function} cb - gets called with the result
  221. * @param {String} userId - the userId automatically added by hooks
  222. */
  223. addSongToPlaylist: hooks.loginRequired((session, songId, playlistId, cb, userId) => {
  224. async.waterfall([
  225. (next) => {
  226. playlists.getPlaylist(playlistId, (err, playlist) => {
  227. if (err || !playlist || playlist.createdBy !== userId) return next('Something went wrong when trying to get the playlist');
  228. async.each(playlist.songs, (song, next) => {
  229. if (song.songId === songId) return next('That song is already in the playlist');
  230. next();
  231. }, next);
  232. });
  233. },
  234. (next) => {
  235. songs.getSong(songId, (err, song) => {
  236. if (err) {
  237. utils.getSongFromYouTube(songId, (song) => {
  238. next(null, song);
  239. });
  240. } else {
  241. next(null, {
  242. _id: song._id,
  243. songId: songId,
  244. title: song.title,
  245. duration: song.duration
  246. });
  247. }
  248. });
  249. },
  250. (newSong, next) => {
  251. db.models.playlist.update({_id: playlistId}, {$push: {songs: newSong}}, {runValidators: true}, (err) => {
  252. if (err) return next(err);
  253. playlists.updatePlaylist(playlistId, (err, playlist) => {
  254. next(err, playlist, newSong);
  255. });
  256. });
  257. }
  258. ],
  259. (err, playlist, newSong) => {
  260. if (err) {
  261. err = utils.getError(err);
  262. logger.error("PLAYLIST_ADD_SONG", `Adding song "${songId}" to private playlist "${playlistId}" failed for user "${userId}". "${err}"`);
  263. return cb({ status: 'failure', message: err});
  264. }
  265. logger.success("PLAYLIST_ADD_SONG", `Successfully added song "${songId}" to private playlist "${playlistId}" for user "${userId}".`);
  266. cache.pub('playlist.addSong', { playlistId: playlist._id, song: newSong, userId: userId });
  267. return cb({ status: 'success', message: 'Song has been successfully added to the playlist', data: playlist.songs });
  268. });
  269. }),
  270. /**
  271. * Adds a set of songs to a private playlist
  272. *
  273. * @param {Object} session - the session object automatically added by socket.io
  274. * @param {String} url - the url of the the YouTube playlist
  275. * @param {String} playlistId - the id of the playlist we are adding the set of songs to
  276. * @param {Function} cb - gets called with the result
  277. * @param {String} userId - the userId automatically added by hooks
  278. */
  279. addSetToPlaylist: hooks.loginRequired((session, url, playlistId, cb, userId) => {
  280. async.waterfall([
  281. (next) => {
  282. utils.getPlaylistFromYouTube(url, songs => {
  283. next(null, songs);
  284. });
  285. },
  286. (songs, next) => {
  287. let processed = 0;
  288. function checkDone() {
  289. if (processed === songs.length) next();
  290. }
  291. for (let s = 0; s < songs.length; s++) {
  292. lib.addSongToPlaylist(session, songs[s].contentDetails.videoId, playlistId, () => {
  293. processed++;
  294. checkDone();
  295. });
  296. }
  297. },
  298. (next) => {
  299. playlists.getPlaylist(playlistId, next);
  300. },
  301. (playlist, next) => {
  302. if (!playlist || playlist.createdBy !== userId) return next('Playlist not found.');
  303. next(null, playlist);
  304. }
  305. ], (err, playlist) => {
  306. if (err) {
  307. err = utils.getError(err);
  308. logger.error("PLAYLIST_IMPORT", `Importing a YouTube playlist to private playlist "${playlistId}" failed for user "${userId}". "${err}"`);
  309. return cb({ status: 'failure', message: err});
  310. }
  311. logger.success("PLAYLIST_IMPORT", `Successfully imported a YouTube playlist to private playlist "${playlistId}" for user "${userId}".`);
  312. cb({ status: 'success', message: 'Playlist has been successfully imported.', data: playlist.songs });
  313. });
  314. }),
  315. /**
  316. * Removes a song from a private playlist
  317. *
  318. * @param {Object} session - the session object automatically added by socket.io
  319. * @param {String} songId - the id of the song we are removing from the private playlist
  320. * @param {String} playlistId - the id of the playlist we are removing the song from
  321. * @param {Function} cb - gets called with the result
  322. * @param {String} userId - the userId automatically added by hooks
  323. */
  324. removeSongFromPlaylist: hooks.loginRequired((session, songId, playlistId, cb, userId) => {
  325. async.waterfall([
  326. (next) => {
  327. if (!songId || typeof songId !== 'string') return next('Invalid song id.');
  328. if (!playlistId || typeof playlistId !== 'string') return next('Invalid playlist id.');
  329. next();
  330. },
  331. (next) => {
  332. playlists.getPlaylist(playlistId, next);
  333. },
  334. (playlist, next) => {
  335. if (!playlist || playlist.createdBy !== userId) return next('Playlist not found');
  336. db.models.playlist.update({_id: playlistId}, {$pull: {songs: {songId: songId}}}, next);
  337. },
  338. (res, next) => {
  339. playlists.updatePlaylist(playlistId, next);
  340. }
  341. ], (err, playlist) => {
  342. if (err) {
  343. err = utils.getError(err);
  344. logger.error("PLAYLIST_REMOVE_SONG", `Removing song "${songId}" from private playlist "${playlistId}" failed for user "${userId}". "${err}"`);
  345. return cb({ status: 'failure', message: err});
  346. }
  347. logger.success("PLAYLIST_REMOVE_SONG", `Successfully removed song "${songId}" from private playlist "${playlistId}" for user "${userId}".`);
  348. cache.pub('playlist.removeSong', {playlistId: playlist._id, songId: songId, userId: userId});
  349. return cb({ status: 'success', message: 'Song has been successfully removed from playlist', data: playlist.songs });
  350. });
  351. }),
  352. /**
  353. * Updates the displayName of a private playlist
  354. *
  355. * @param {Object} session - the session object automatically added by socket.io
  356. * @param {String} playlistId - the id of the playlist we are updating the displayName for
  357. * @param {Function} cb - gets called with the result
  358. * @param {String} userId - the userId automatically added by hooks
  359. */
  360. updateDisplayName: hooks.loginRequired((session, playlistId, displayName, cb, userId) => {
  361. async.waterfall([
  362. (next) => {
  363. db.models.playlist.update({ _id: playlistId, createdBy: userId }, { $set: { displayName } }, {runValidators: true}, next);
  364. },
  365. (res, next) => {
  366. playlists.updatePlaylist(playlistId, next);
  367. }
  368. ], (err, playlist) => {
  369. if (err) {
  370. err = utils.getError(err);
  371. logger.error("PLAYLIST_UPDATE_DISPLAY_NAME", `Updating display name to "${displayName}" for private playlist "${playlistId}" failed for user "${userId}". "${err}"`);
  372. return cb({ status: 'failure', message: err});
  373. }
  374. logger.success("PLAYLIST_UPDATE_DISPLAY_NAME", `Successfully updated display name to "${displayName}" for private playlist "${playlistId}" for user "${userId}".`);
  375. cache.pub('playlist.updateDisplayName', {playlistId: playlistId, displayName: displayName, userId: userId});
  376. return cb({ status: 'success', message: 'Playlist has been successfully updated' });
  377. });
  378. }),
  379. /**
  380. * Moves a song to the top of the list in a private playlist
  381. *
  382. * @param {Object} session - the session object automatically added by socket.io
  383. * @param {String} playlistId - the id of the playlist we are moving the song to the top from
  384. * @param {String} songId - the id of the song we are moving to the top of the list
  385. * @param {Function} cb - gets called with the result
  386. * @param {String} userId - the userId automatically added by hooks
  387. */
  388. moveSongToTop: hooks.loginRequired((session, playlistId, songId, cb, userId) => {
  389. async.waterfall([
  390. (next) => {
  391. playlists.getPlaylist(playlistId, next);
  392. },
  393. (playlist, next) => {
  394. if (!playlist || playlist.createdBy !== userId) return next('Playlist not found');
  395. async.each(playlist.songs, (song, next) => {
  396. if (song.songId === songId) return next(song);
  397. next();
  398. }, (err) => {
  399. if (err && err.songId) return next(null, err);
  400. next('Song not found');
  401. });
  402. },
  403. (song, next) => {
  404. db.models.playlist.update({_id: playlistId}, {$pull: {songs: {songId}}}, (err) => {
  405. if (err) return next(err);
  406. return next(null, song);
  407. });
  408. },
  409. (song, next) => {
  410. db.models.playlist.update({_id: playlistId}, {
  411. $push: {
  412. songs: {
  413. $each: [song],
  414. $position: 0
  415. }
  416. }
  417. }, next);
  418. },
  419. (res, next) => {
  420. playlists.updatePlaylist(playlistId, next);
  421. }
  422. ], (err, playlist) => {
  423. if (err) {
  424. err = utils.getError(err);
  425. logger.error("PLAYLIST_MOVE_SONG_TO_TOP", `Moving song "${songId}" to the top for private playlist "${playlistId}" failed for user "${userId}". "${err}"`);
  426. return cb({ status: 'failure', message: err});
  427. }
  428. logger.success("PLAYLIST_MOVE_SONG_TO_TOP", `Successfully moved song "${songId}" to the top for private playlist "${playlistId}" for user "${userId}".`);
  429. cache.pub('playlist.moveSongToTop', {playlistId, songId, userId: userId});
  430. return cb({ status: 'success', message: 'Playlist has been successfully updated' });
  431. });
  432. }),
  433. /**
  434. * Moves a song to the bottom of the list in a private playlist
  435. *
  436. * @param {Object} session - the session object automatically added by socket.io
  437. * @param {String} playlistId - the id of the playlist we are moving the song to the bottom from
  438. * @param {String} songId - the id of the song we are moving to the bottom of the list
  439. * @param {Function} cb - gets called with the result
  440. * @param {String} userId - the userId automatically added by hooks
  441. */
  442. moveSongToBottom: hooks.loginRequired((session, playlistId, songId, cb, userId) => {
  443. async.waterfall([
  444. (next) => {
  445. playlists.getPlaylist(playlistId, next);
  446. },
  447. (playlist, next) => {
  448. if (!playlist || playlist.createdBy !== userId) return next('Playlist not found');
  449. async.each(playlist.songs, (song, next) => {
  450. if (song.songId === songId) return next(song);
  451. next();
  452. }, (err) => {
  453. if (err && err.songId) return next(null, err);
  454. next('Song not found');
  455. });
  456. },
  457. (song, next) => {
  458. db.models.playlist.update({_id: playlistId}, {$pull: {songs: {songId}}}, (err) => {
  459. if (err) return next(err);
  460. return next(null, song);
  461. });
  462. },
  463. (song, next) => {
  464. db.models.playlist.update({_id: playlistId}, {
  465. $push: {
  466. songs: song
  467. }
  468. }, next);
  469. },
  470. (res, next) => {
  471. playlists.updatePlaylist(playlistId, next);
  472. }
  473. ], (err, playlist) => {
  474. if (err) {
  475. err = utils.getError(err);
  476. logger.error("PLAYLIST_MOVE_SONG_TO_BOTTOM", `Moving song "${songId}" to the bottom for private playlist "${playlistId}" failed for user "${userId}". "${err}"`);
  477. return cb({ status: 'failure', message: err});
  478. }
  479. logger.success("PLAYLIST_MOVE_SONG_TO_BOTTOM", `Successfully moved song "${songId}" to the bottom for private playlist "${playlistId}" for user "${userId}".`);
  480. cache.pub('playlist.moveSongToBottom', {playlistId, songId, userId: userId});
  481. return cb({ status: 'success', message: 'Playlist has been successfully updated' });
  482. });
  483. }),
  484. /**
  485. * Removes a private playlist
  486. *
  487. * @param {Object} session - the session object automatically added by socket.io
  488. * @param {String} playlistId - the id of the playlist we are moving the song to the top from
  489. * @param {Function} cb - gets called with the result
  490. * @param {String} userId - the userId automatically added by hooks
  491. */
  492. remove: hooks.loginRequired((session, playlistId, cb, userId) => {
  493. async.waterfall([
  494. (next) => {
  495. playlists.deletePlaylist(playlistId, next);
  496. }
  497. ], (err) => {
  498. if (err) {
  499. err = utils.getError(err);
  500. logger.error("PLAYLIST_REMOVE", `Removing private playlist "${playlistId}" failed for user "${userId}". "${err}"`);
  501. return cb({ status: 'failure', message: err});
  502. }
  503. logger.success("PLAYLIST_REMOVE", `Successfully removed private playlist "${playlistId}" for user "${userId}".`);
  504. cache.pub('playlist.delete', {userId: userId, playlistId});
  505. return cb({ status: 'success', message: 'Playlist successfully removed' });
  506. });
  507. })
  508. };
  509. module.exports = lib;