Added ability to request all songs not in the songs db yet but are in playlists, and added ability to clear all station queues

backend/logic/actions/playlists.js

@@ -1571,5 +1571,40 @@ export default {
 				return cb({ status: "success", message: "Success" });
 			}
 		);
+	}),
+
+	/**
+	 * Requests orpahned playlist songs
+	 *
+	 * @param {object} session - the session object automatically added by socket.io
+	 * @param {Function} cb - gets called with the result
+	 */
+	requestOrphanedPlaylistSongs: isAdminRequired(async function index(session, cb) {
+		async.waterfall(
+			[
+				next => {
+					SongsModule.runJob("REQUEST_ORPHANED_PLAYLIST_SONGS", {}, this)
+						.then(() => next())
+						.catch(next);
+				}
+			],
+			async err => {
+				if (err) {
+					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
+					this.log(
+						"ERROR",
+						"REQUEST_ORPHANED_PLAYLIST_SONGS",
+						`Requesting orphaned playlist songs failed. "${err}"`
+					);
+					return cb({ status: "failure", message: err });
+				}
+				this.log(
+					"SUCCESS",
+					"REQUEST_ORPHANED_PLAYLIST_SONGS",
+					"Requesting orphaned playlist songs was successfull."
+				);
+				return cb({ status: "success", message: "Success" });
+			}
+		);
 	})
 };

backend/logic/actions/songs.js

@@ -533,70 +533,8 @@ export default {
 	 * @param {Function} cb - gets called with the result
 	 */
 	request: isLoginRequired(async function add(session, songId, cb) {
-		const requestedAt = Date.now();
-		const SongModel = await DBModule.runJob("GET_MODEL", { modelName: "song" }, this);
-		const UserModel = await DBModule.runJob("GET_MODEL", { modelName: "user" }, this);
-
-		async.waterfall(
-			[
-				next => {
-					SongModel.findOne({ songId }, next);
-				},
-
-				// Get YouTube data from id
-				(song, next) => {
-					if (song) return next("This song is already in the database.");
-					// TODO Add err object as first param of callback
-					return YouTubeModule.runJob("GET_SONG", { songId }, this)
-						.then(response => {
-							const { song } = response;
-							song.duration = -1;
-							song.artists = [];
-							song.genres = [];
-							song.skipDuration = 0;
-							song.thumbnail = `${config.get("domain")}/assets/notes.png`;
-							song.explicit = false;
-							song.requestedBy = session.userId;
-							song.requestedAt = requestedAt;
-							song.verified = false;
-							next(null, song);
-						})
-						.catch(next);
-				},
-				(newSong, next) => {
-					const song = new SongModel(newSong);
-					song.save({ validateBeforeSave: false }, err => {
-						if (err) return next(err, song);
-						return next(null, song);
-					});
-				},
-				(song, next) => {
-					UserModel.findOne({ _id: session.userId }, (err, user) => {
-						if (err) return next(err);
-
-						user.statistics.songsRequested += 1;
-
-						return user.save(err => {
-							if (err) return next(err);
-							return next(null, song);
-						});
-					});
-				}
-			],
-			async (err, song) => {
-				if (err) {
-					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
-					this.log(
-						"ERROR",
-						"SONGS_REQUEST",
-						`Requesting song "${songId}" failed for user ${session.userId}. "${err}"`
-					);
-					return cb({ status: "failure", message: err });
-				}
-				CacheModule.runJob("PUB", {
-					channel: "song.newUnverifiedSong",
-					value: song._id
-				});
+		SongsModule.runJob("REQUEST_SONG", { songId, userId: session.userId }, this)
+			.then(() => {
 				this.log(
 					"SUCCESS",
 					"SONGS_REQUEST",
@@ -606,8 +544,16 @@ export default {
 					status: "success",
 					message: "Successfully requested that song"
 				});
-			}
-		);
+			})
+			.catch(async err => {
+				err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
+				this.log(
+					"ERROR",
+					"SONGS_REQUEST",
+					`Requesting song "${songId}" failed for user ${session.userId}. "${err}"`
+				);
+				return cb({ status: "failure", message: err });
+			});
 	}),
 
 	/**

backend/logic/actions/stations.js

@@ -1,7 +1,7 @@
 import async from "async";
 import mongoose from "mongoose";
 
-import { isLoginRequired, isOwnerRequired } from "./hooks";
+import { isLoginRequired, isOwnerRequired, isAdminRequired } from "./hooks";
 
 import moduleManager from "../../index";
 
@@ -14,7 +14,6 @@ const CacheModule = moduleManager.modules.cache;
 const NotificationsModule = moduleManager.modules.notifications;
 const StationsModule = moduleManager.modules.stations;
 const ActivitiesModule = moduleManager.modules.activities;
-const YouTubeModule = moduleManager.modules.youtube;
 
 CacheModule.runJob("SUB", {
 	channel: "station.updateUsers",
@@ -3329,5 +3328,32 @@ export default {
 				});
 			}
 		);
+	}),
+
+	/**
+	 * Clears every station queue
+	 *
+	 * @param {object} session - the session object automatically added by socket.io
+	 * @param {Function} cb - gets called with the result
+	 */
+	clearEveryStationQueue: isAdminRequired(async function clearEveryStationQueue(session, cb) {
+		async.waterfall(
+			[
+				next => {
+					StationsModule.runJob("CLEAR_EVERY_STATION_QUEUE", {}, this)
+						.then(() => next())
+						.catch(next);
+				}
+			],
+			async err => {
+				if (err) {
+					err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
+					this.log("ERROR", "CLEAR_EVERY_STATION_QUEUE", `Clearing every station queue failed. "${err}"`);
+					return cb({ status: "failure", message: err });
+				}
+				this.log("SUCCESS", "CLEAR_EVERY_STATION_QUEUE", "Clearing every station queue was successfull.");
+				return cb({ status: "success", message: "Success" });
+			}
+		);
 	})
 };

backend/logic/songs.js

@@ -1,4 +1,5 @@
 import async from "async";
+import config from "config";
 import mongoose from "mongoose";
 import CoreClass from "../core";
 
@@ -7,8 +8,8 @@ let CacheModule;
 let DBModule;
 let UtilsModule;
 let YouTubeModule;
-let StationModule;
-let PlaylistModule;
+let StationsModule;
+let PlaylistsModule;
 
 class _SongsModule extends CoreClass {
 	// eslint-disable-next-line require-jsdoc
@@ -30,8 +31,8 @@ class _SongsModule extends CoreClass {
 		DBModule = this.moduleManager.modules.db;
 		UtilsModule = this.moduleManager.modules.utils;
 		YouTubeModule = this.moduleManager.modules.youtube;
-		StationModule = this.moduleManager.modules.stations;
-		PlaylistModule = this.moduleManager.modules.playlists;
+		StationsModule = this.moduleManager.modules.stations;
+		PlaylistsModule = this.moduleManager.modules.playlists;
 
 		this.SongModel = await DBModule.runJob("GET_MODEL", { modelName: "song" });
 		this.SongSchemaCache = await CacheModule.runJob("GET_SCHEMA", { schemaName: "song" });
@@ -277,7 +278,7 @@ class _SongsModule extends CoreClass {
 									else
 										playlistModel.find({ "songs._id": song._id }, (err, playlists) => {
 											playlists.forEach(playlist => {
-												PlaylistModule.runJob("UPDATE_PLAYLIST", {
+												PlaylistsModule.runJob("UPDATE_PLAYLIST", {
 													playlistId: playlist._id
 												});
 											});
@@ -303,7 +304,7 @@ class _SongsModule extends CoreClass {
 									else
 										stationModel.find({ "queue._id": song._id }, (err, stations) => {
 											stations.forEach(station => {
-												StationModule.runJob("UPDATE_STATION", { stationId: station._id });
+												StationsModule.runJob("UPDATE_STATION", { stationId: station._id });
 											});
 										});
 								}
@@ -470,6 +471,207 @@ class _SongsModule extends CoreClass {
 			)
 		);
 	}
+
+	// runjob songs GET_ORPHANED_PLAYLIST_SONGS {}
+
+	/**
+	 * Gets a orphaned playlist songs
+	 *
+	 * @returns {Promise} - returns promise (reject, resolve)
+	 */
+	GET_ORPHANED_PLAYLIST_SONGS() {
+		return new Promise((resolve, reject) => {
+			DBModule.runJob("GET_MODEL", { modelName: "playlist" }, this).then(playlistModel => {
+				playlistModel.find({}, (err, playlists) => {
+					if (err) reject(new Error(err));
+					else {
+						SongsModule.SongModel.find({}, { _id: true }, (err, songs) => {
+							if (err) reject(new Error(err));
+							else {
+								const songIds = songs.map(song => song._id.toString());
+								const orphanedSongIds = [];
+								async.eachLimit(
+									playlists,
+									1,
+									(playlist, next) => {
+										playlist.songs.forEach(song => {
+											if (
+												songIds.indexOf(song._id.toString()) === -1 &&
+												orphanedSongIds.indexOf(song.songId) === -1
+											) {
+												orphanedSongIds.push(song.songId);
+											}
+										});
+										next();
+									},
+									() => {
+										resolve({ songIds: orphanedSongIds });
+									}
+								);
+							}
+						});
+					}
+				});
+			});
+		});
+	}
+
+	/**
+	 * Requests a song, adding it to the DB
+	 *
+	 * @param {object} payload - The payload
+	 * @param {string} payload.songId - The YouTube song id of the song
+	 * @param {string} payload.userId - The user id of the person requesting the song
+	 * @returns {Promise} - returns promise (reject, resolve)
+	 */
+	REQUEST_SONG(payload) {
+		return new Promise((resolve, reject) => {
+			const { songId, userId } = payload;
+			const requestedAt = Date.now();
+
+			async.waterfall(
+				[
+					next => {
+						SongsModule.SongModel.findOne({ songId }, next);
+					},
+
+					// Get YouTube data from id
+					(song, next) => {
+						if (song) return next("This song is already in the database.");
+						// TODO Add err object as first param of callback
+						return YouTubeModule.runJob("GET_SONG", { songId }, this)
+							.then(response => {
+								const { song } = response;
+								song.artists = [];
+								song.genres = [];
+								song.skipDuration = 0;
+								song.explicit = false;
+								song.requestedBy = userId;
+								song.requestedAt = requestedAt;
+								song.verified = false;
+								next(null, song);
+							})
+							.catch(next);
+					},
+					(newSong, next) => {
+						const song = new SongsModule.SongModel(newSong);
+						song.save({ validateBeforeSave: false }, err => {
+							if (err) return next(err, song);
+							return next(null, song);
+						});
+					},
+					(song, next) => {
+						DBModule.runJob("GET_MODEL", { modelName: "user" }, this)
+							.then(UserModel => {
+								UserModel.findOne({ _id: userId }, (err, user) => {
+									if (err) return next(err);
+									if (!user) return next(null, song);
+
+									user.statistics.songsRequested += 1;
+
+									return user.save(err => {
+										if (err) return next(err);
+										return next(null, song);
+									});
+								});
+							})
+							.catch(next);
+					}
+				],
+				async (err, song) => {
+					if (err) reject(err);
+
+					CacheModule.runJob("PUB", {
+						channel: "song.newUnverifiedSong",
+						value: song._id
+					});
+
+					resolve();
+				}
+			);
+		});
+	}
+
+	// runjob songs REQUEST_ORPHANED_PLAYLIST_SONGS {}
+
+	/**
+	 * Requests all orphaned playlist songs, adding them to the database
+	 *
+	 * @returns {Promise} - returns promise (reject, resolve)
+	 */
+	REQUEST_ORPHANED_PLAYLIST_SONGS() {
+		return new Promise((resolve, reject) => {
+			DBModule.runJob("GET_MODEL", { modelName: "playlist" })
+				.then(playlistModel => {
+					SongsModule.runJob("GET_ORPHANED_PLAYLIST_SONGS", {}, this).then(response => {
+						const { songIds } = response;
+						async.eachLimit(
+							songIds,
+							1,
+							(songId, next) => {
+								async.waterfall(
+									[
+										next => {
+											SongsModule.runJob("ENSURE_SONG_EXISTS_BY_SONG_ID", { songId }, this)
+												.then(() => next())
+												.catch(next);
+											// SongsModule.runJob("REQUEST_SONG", { songId, userId: null }, this)
+											// 	.then(() => {
+											// 		next();
+											// 	})
+											// 	.catch(next);
+										},
+
+										next => {
+											SongsModule.SongModel.findOne({ songId }, next);
+										},
+
+										(song, next) => {
+											const { _id, title, artists, thumbnail, duration, verified } = song;
+											const trimmedSong = {
+												_id,
+												songId,
+												title,
+												artists,
+												thumbnail,
+												duration,
+												verified
+											};
+											playlistModel.updateMany(
+												{ "songs.songId": song.songId },
+												{ $set: { "songs.$": trimmedSong } },
+												err => {
+													next(err, song);
+												}
+											);
+										},
+
+										(song, next) => {
+											playlistModel.find({ "songs._id": song._id }, next);
+										},
+
+										(playlists, next) => {
+											playlists.forEach(playlist => {
+												PlaylistsModule.runJob("UPDATE_PLAYLIST", {
+													playlistId: playlist._id
+												});
+											});
+											next();
+										}
+									],
+									next
+								);
+							},
+							err => {
+								if (err) reject(err);
+								else resolve();
+							}
+						);
+					});
+				})
+				.catch(reject);
+		});
+	}
 }
 
 export default new _SongsModule();

backend/logic/stations.js

@@ -1590,6 +1590,54 @@ class _StationsModule extends CoreClass {
 			});
 		});
 	}
+
+	/**
+	 * Clears every queue
+	 *
+	 * @returns {Promise} - returns a promise (resolve, reject)
+	 */
+	CLEAR_EVERY_STATION_QUEUE() {
+		return new Promise((resolve, reject) => {
+			async.waterfall(
+				[
+					next => {
+						StationsModule.stationModel.updateMany({}, { $set: { queue: [] } }, err => {
+							if (err) next(err);
+							else {
+								StationsModule.stationModel.find({}, (err, stations) => {
+									if (err) next(err);
+									else {
+										async.eachLimit(
+											stations,
+											1,
+											(station, next) => {
+												StationsModule.runJob("UPDATE_STATION", {
+													stationId: station._id
+												})
+													.then(() => next())
+													.catch(next);
+												CacheModule.runJob("PUB", {
+													channel: "station.queueUpdate",
+													value: station._id
+												})
+													.then()
+													.catch();
+											},
+											next
+										);
+									}
+								});
+							}
+						});
+					}
+				],
+				err => {
+					if (err) reject(err);
+					else resolve();
+				}
+			);
+		});
+	}
 }
 
 export default new _StationsModule();

frontend/src/pages/Admin/tabs/Playlists.vue

@@ -14,6 +14,12 @@
 			>
 				Delete orphaned genre playlists
 			</button>
+			<button
+				class="button is-primary"
+				@click="requestOrphanedPlaylistSongs()"
+			>
+				Request orphaned playlist songs
+			</button>
 			<br />
 			<br />
 			<table class="table is-striped">
@@ -181,6 +187,24 @@ export default {
 				}
 			);
 		},
+		requestOrphanedPlaylistSongs() {
+			this.socket.dispatch(
+				"playlists.requestOrphanedPlaylistSongs",
+				res => {
+					if (res.status === "success") {
+						new Toast({
+							content: `${res.message}`,
+							timeout: 4000
+						});
+					} else {
+						new Toast({
+							content: `Error: ${res.message}`,
+							timeout: 8000
+						});
+					}
+				}
+			);
+		},
 		...mapActions("modalVisibility", ["openModal"]),
 		...mapActions("user/playlists", ["editPlaylist"])
 	}

frontend/src/pages/Admin/tabs/Stations.vue

@@ -2,6 +2,11 @@
 	<div>
 		<metadata title="Admin | Stations" />
 		<div class="container">
+			<button class="button is-primary" @click="clearEveryStationQueue()">
+				Clear every station queue
+			</button>
+			<br />
+			<br />
 			<table class="table is-striped">
 				<thead>
 					<tr>
@@ -339,6 +344,21 @@ export default {
 		removeBlacklistedGenre(index) {
 			this.newStation.blacklistedGenres.splice(index, 1);
 		},
+		clearEveryStationQueue() {
+			this.socket.dispatch("stations.clearEveryStationQueue", res => {
+				if (res.status === "success") {
+					new Toast({
+						content: `${res.message}`,
+						timeout: 4000
+					});
+				} else {
+					new Toast({
+						content: `Error: ${res.message}`,
+						timeout: 8000
+					});
+				}
+			});
+		},
 		init() {
 			this.socket.dispatch("stations.index", data => {
 				this.loadStations(data.stations);