import async from "async";
import mongoose from "mongoose";
import config from "config";
import { isLoginRequired, isOwnerRequired, isAdminRequired } from "./hooks";
import moduleManager from "../../index";
const DBModule = moduleManager.modules.db;
const UtilsModule = moduleManager.modules.utils;
const WSModule = moduleManager.modules.ws;
const SongsModule = moduleManager.modules.songs;
const PlaylistsModule = moduleManager.modules.playlists;
const CacheModule = moduleManager.modules.cache;
const NotificationsModule = moduleManager.modules.notifications;
const StationsModule = moduleManager.modules.stations;
const ActivitiesModule = moduleManager.modules.activities;
CacheModule.runJob("SUB", {
channel: "station.updateUsers",
cb: ({ stationId, usersPerStation }) => {
WSModule.runJob("EMIT_TO_ROOM", {
room: `station.${stationId}`,
args: ["event:station.users.updated", { data: { users: usersPerStation } }]
});
}
});
CacheModule.runJob("SUB", {
channel: "station.updateUserCount",
cb: ({ stationId, usersPerStationCount }) => {
const count = usersPerStationCount || 0;
WSModule.runJob("EMIT_TO_ROOM", {
room: `station.${stationId}`,
args: ["event:station.userCount.updated", { data: { userCount: count } }]
});
StationsModule.runJob("GET_STATION", { stationId }).then(async station => {
if (station.privacy === "public")
WSModule.runJob("EMIT_TO_ROOM", {
room: "home",
args: ["event:station.userCount.updated", { data: { stationId, userCount: count } }]
});
else {
const sockets = await WSModule.runJob("GET_SOCKETS_FOR_ROOM", {
room: "home"
});
sockets.forEach(async socketId => {
const socket = await WSModule.runJob("SOCKET_FROM_SOCKET_ID", { socketId }, this);
if (!socket) return;
const { session } = socket;
if (session.sessionId) {
CacheModule.runJob("HGET", {
table: "sessions",
key: session.sessionId
}).then(session => {
if (session)
DBModule.runJob(
"GET_MODEL",
{
modelName: "user"
},
this
).then(userModel =>
userModel.findOne({ _id: session.userId }, (err, user) => {
if (user && user.role === "admin")
socket.dispatch("event:station.userCount.updated", {
data: { stationId, count }
});
else if (
user &&
station.type === "community" &&
station.owner === session.userId
)
socket.dispatch("event:station.userCount.updated", {
data: { stationId, count }
});
})
);
});
}
});
}
});
}
});
CacheModule.runJob("SUB", {
channel: "station.queueLockToggled",
cb: data => {
const { stationId, locked } = data;
WSModule.runJob("EMIT_TO_ROOM", {
room: `station.${stationId}`,
args: ["event:station.queue.lock.toggled", { data: { locked } }]
});
WSModule.runJob("EMIT_TO_ROOM", {
room: `manage-station.${stationId}`,
args: ["event:station.queue.lock.toggled", { data: { stationId, locked } }]
});
}
});
CacheModule.runJob("SUB", {
channel: "station.updatePartyMode",
cb: data => {
const { stationId, partyMode } = data;
StationsModule.runJob("GET_STATION", { stationId }).then(station => {
WSModule.runJob("EMIT_TO_ROOM", {
room: `station.${stationId}`,
args: ["event:station.partyMode.updated", { data: { partyMode } }]
});
WSModule.runJob("EMIT_TO_ROOM", {
room: `manage-station.${stationId}`,
args: ["event:station.partyMode.updated", { data: { stationId, partyMode } }]
});
StationsModule.runJob("GET_SOCKETS_THAT_CAN_KNOW_ABOUT_STATION", {
room: `home`,
station
}).then(response => {
const { socketsThatCan } = response;
socketsThatCan.forEach(socket => {
socket.dispatch("event:station.partyMode.updated", { data: { stationId, partyMode } });
});
});
});
}
});
CacheModule.runJob("SUB", {
channel: "station.newPlayMode",
cb: data => {
const { stationId, playMode } = data;
WSModule.runJob("EMIT_TO_ROOM", {
room: `station.${stationId}`,
args: ["event:station.playMode.updated", { data: { playMode } }]
});
WSModule.runJob("EMIT_TO_ROOM", {
room: `manage-station.${stationId}`,
args: ["event:station.playMode.updated", { data: { stationId, playMode } }]
});
}
});
CacheModule.runJob("SUB", {
channel: "station.includedPlaylist",
cb: data => {
const { stationId, playlistId } = data;
PlaylistsModule.runJob("GET_PLAYLIST", { playlistId }).then(playlist =>
WSModule.runJob("EMIT_TO_ROOMS", {
rooms: [`station.${stationId}`, `manage-station.${stationId}`],
args: ["event:station.includedPlaylist", { data: { stationId, playlist } }]
})
);
}
});
CacheModule.runJob("SUB", {
channel: "station.excludedPlaylist",
cb: data => {
const { stationId, playlistId } = data;
PlaylistsModule.runJob("GET_PLAYLIST", { playlistId }).then(playlist =>
WSModule.runJob("EMIT_TO_ROOMS", {
rooms: [`station.${stationId}`, `manage-station.${stationId}`],
args: ["event:station.excludedPlaylist", { data: { stationId, playlist } }]
})
);
}
});
CacheModule.runJob("SUB", {
channel: "station.removedIncludedPlaylist",
cb: data => {
const { stationId, playlistId } = data;
WSModule.runJob("EMIT_TO_ROOMS", {
rooms: [`station.${stationId}`, `manage-station.${stationId}`],
args: ["event:station.removedIncludedPlaylist", { data: { stationId, playlistId } }]
});
}
});
CacheModule.runJob("SUB", {
channel: "station.removedExcludedPlaylist",
cb: data => {
const { stationId, playlistId } = data;
WSModule.runJob("EMIT_TO_ROOMS", {
rooms: [`station.${stationId}`, `manage-station.${stationId}`],
args: ["event:station.removedExcludedPlaylist", { data: { stationId, playlistId } }]
});
}
});
CacheModule.runJob("SUB", {
channel: "station.pause",
cb: stationId => {
StationsModule.runJob("GET_STATION", { stationId }).then(station => {
WSModule.runJob("EMIT_TO_ROOM", {
room: `station.${stationId}`,
args: ["event:station.pause", { data: { pausedAt: station.pausedAt } }]
});
WSModule.runJob("EMIT_TO_ROOM", {
room: `manage-station.${stationId}`,
args: ["event:station.pause", { data: { stationId, pausedAt: station.pausedAt } }]
});
StationsModule.runJob("GET_SOCKETS_THAT_CAN_KNOW_ABOUT_STATION", {
room: `home`,
station
}).then(response => {
const { socketsThatCan } = response;
socketsThatCan.forEach(socket => {
socket.dispatch("event:station.pause", { data: { stationId } });
});
});
});
}
});
CacheModule.runJob("SUB", {
channel: "station.resume",
cb: stationId => {
StationsModule.runJob("GET_STATION", { stationId }).then(station => {
WSModule.runJob("EMIT_TO_ROOM", {
room: `station.${stationId}`,
args: ["event:station.resume", { data: { timePaused: station.timePaused } }]
});
WSModule.runJob("EMIT_TO_ROOM", {
room: `manage-station.${stationId}`,
args: ["event:station.resume", { data: { stationId, timePaused: station.timePaused } }]
});
StationsModule.runJob("GET_SOCKETS_THAT_CAN_KNOW_ABOUT_STATION", {
room: `home`,
station
})
.then(response => {
const { socketsThatCan } = response;
socketsThatCan.forEach(socket => {
socket.dispatch("event:station.resume", { data: { stationId } });
});
})
.catch(console.log);
});
}
});
CacheModule.runJob("SUB", {
channel: "station.privacyUpdate",
cb: response => {
const { stationId, previousPrivacy } = response;
StationsModule.runJob("GET_STATION", { stationId }).then(station => {
if (previousPrivacy !== station.privacy) {
if (station.privacy === "public") {
// Station became public
WSModule.runJob("EMIT_TO_ROOM", {
room: "home",
args: ["event:station.created", { data: { station } }]
});
} else if (previousPrivacy === "public") {
// Station became hidden
StationsModule.runJob("GET_SOCKETS_THAT_CAN_KNOW_ABOUT_STATION", {
room: `home`,
station
}).then(response => {
const { socketsThatCan, socketsThatCannot } = response;
socketsThatCan.forEach(socket => {
socket.dispatch("event:station.privacy.updated", {
data: { stationId, privacy: station.privacy }
});
});
socketsThatCannot.forEach(socket => {
socket.dispatch("event:station.deleted", { data: { stationId } });
});
});
} else {
// Station was hidden and is still hidden
StationsModule.runJob("GET_SOCKETS_THAT_CAN_KNOW_ABOUT_STATION", {
room: `home`,
station
}).then(response => {
const { socketsThatCan } = response;
socketsThatCan.forEach(socket => {
socket.dispatch("event:station.privacy.updated", {
data: { stationId, privacy: station.privacy }
});
});
});
}
}
WSModule.runJob("EMIT_TO_ROOM", {
room: `station.${stationId}`,
args: ["event:station.privacy.updated", { data: { privacy: station.privacy } }]
});
WSModule.runJob("EMIT_TO_ROOM", {
room: `manage-station.${stationId}`,
args: ["event:station.privacy.updated", { data: { stationId, privacy: station.privacy } }]
});
});
}
});
CacheModule.runJob("SUB", {
channel: "station.nameUpdate",
cb: res => {
const { stationId, name } = res;
StationsModule.runJob("GET_STATION", { stationId }).then(station => {
StationsModule.runJob("GET_SOCKETS_THAT_CAN_KNOW_ABOUT_STATION", {
room: `home`,
station
}).then(response => {
const { socketsThatCan } = response;
socketsThatCan.forEach(socket =>
socket.dispatch("event:station.name.updated", { data: { stationId, name } })
);
});
});
WSModule.runJob("EMIT_TO_ROOMS", {
rooms: [`station.${stationId}`, `manage-station.${stationId}`],
args: ["event:station.name.updated", { data: { stationId, name } }]
});
}
});
CacheModule.runJob("SUB", {
channel: "station.displayNameUpdate",
cb: response => {
const { stationId, displayName } = response;
StationsModule.runJob("GET_STATION", { stationId }).then(station =>
StationsModule.runJob("GET_SOCKETS_THAT_CAN_KNOW_ABOUT_STATION", {
room: `home`,
station
}).then(response => {
const { socketsThatCan } = response;
socketsThatCan.forEach(socket =>
socket.dispatch("event:station.displayName.updated", { data: { stationId, displayName } })
);
})
);
WSModule.runJob("EMIT_TO_ROOMS", {
rooms: [`station.${stationId}`, `manage-station.${stationId}`],
args: ["event:station.displayName.updated", { data: { stationId, displayName } }]
});
}
});
CacheModule.runJob("SUB", {
channel: "station.descriptionUpdate",
cb: response => {
const { stationId, description } = response;
StationsModule.runJob("GET_STATION", { stationId }).then(station =>
StationsModule.runJob("GET_SOCKETS_THAT_CAN_KNOW_ABOUT_STATION", {
room: `home`,
station
}).then(response => {
const { socketsThatCan } = response;
socketsThatCan.forEach(socket =>
socket.dispatch("event:station.description.updated", { data: { stationId, description } })
);
})
);
WSModule.runJob("EMIT_TO_ROOMS", {
rooms: [`station.${stationId}`, `manage-station.${stationId}`],
args: ["event:station.description.updated", { data: { stationId, description } }]
});
}
});
CacheModule.runJob("SUB", {
channel: "station.themeUpdate",
cb: res => {
const { stationId } = res;
StationsModule.runJob("GET_STATION", { stationId }).then(station => {
WSModule.runJob("EMIT_TO_ROOM", {
room: `station.${stationId}`,
args: ["event:station.theme.updated", { data: { theme: station.theme } }]
});
WSModule.runJob("EMIT_TO_ROOM", {
room: `manage-station.${stationId}`,
args: ["event:station.theme.updated", { data: { stationId, theme: station.theme } }]
});
StationsModule.runJob("GET_SOCKETS_THAT_CAN_KNOW_ABOUT_STATION", {
room: `home`,
station
}).then(res => {
const { socketsThatCan } = res;
socketsThatCan.forEach(socket => {
socket.dispatch("event:station.theme.updated", { data: { stationId, theme: station.theme } });
});
});
});
}
});
CacheModule.runJob("SUB", {
channel: "station.queueUpdate",
cb: stationId => {
StationsModule.runJob("GET_STATION", { stationId }).then(station => {
WSModule.runJob("EMIT_TO_ROOM", {
room: `station.${stationId}`,
args: ["event:station.queue.updated", { data: { queue: station.queue } }]
});
WSModule.runJob("EMIT_TO_ROOM", {
room: `manage-station.${stationId}`,
args: ["event:manageStation.queue.updated", { data: { stationId, queue: station.queue } }]
});
});
}
});
CacheModule.runJob("SUB", {
channel: "station.repositionSongInQueue",
cb: res => {
WSModule.runJob("EMIT_TO_ROOM", {
room: `station.${res.stationId}`,
args: ["event:station.queue.song.repositioned", { data: { song: res.song } }]
});
WSModule.runJob("EMIT_TO_ROOM", {
room: `manage-station.${res.stationId}`,
args: [
"event:manageStation.queue.song.repositioned",
{ data: { stationId: res.stationId, song: res.song } }
]
});
}
});
CacheModule.runJob("SUB", {
channel: "station.voteSkipSong",
cb: stationId => {
WSModule.runJob("EMIT_TO_ROOM", {
room: `station.${stationId}`,
args: ["event:station.voteSkipSong"]
});
}
});
CacheModule.runJob("SUB", {
channel: "station.remove",
cb: stationId => {
WSModule.runJob("EMIT_TO_ROOM", {
room: `station.${stationId}`,
args: ["event:station.deleted"]
});
WSModule.runJob("EMIT_TO_ROOM", {
room: `manage-station.${stationId}`,
args: ["event:station.deleted"]
});
WSModule.runJob("EMIT_TO_ROOM", {
room: `home`,
args: ["event:station.deleted", { data: { stationId } }]
});
WSModule.runJob("EMIT_TO_ROOM", {
room: "admin.stations",
args: ["event:admin.station.deleted", { data: { stationId } }]
});
}
});
CacheModule.runJob("SUB", {
channel: "station.create",
cb: async stationId => {
const userModel = await DBModule.runJob("GET_MODEL", { modelName: "user" });
StationsModule.runJob("INITIALIZE_STATION", { stationId }).then(async res => {
const { station } = res;
station.userCount = StationsModule.usersPerStationCount[stationId] || 0;
WSModule.runJob("EMIT_TO_ROOM", {
room: "admin.stations",
args: ["event:admin.station.created", { data: { station } }]
});
if (station.privacy === "public")
WSModule.runJob("EMIT_TO_ROOM", {
room: "home",
args: ["event:station.created", { data: { station } }]
});
else {
const sockets = await WSModule.runJob("GET_SOCKETS_FOR_ROOM", {
room: "home"
});
sockets.forEach(async socketId => {
const socket = await WSModule.runJob("SOCKET_FROM_SOCKET_ID", { socketId }, this);
if (!socket) return;
const { session } = socket;
if (session.sessionId) {
CacheModule.runJob("HGET", {
table: "sessions",
key: session.sessionId
}).then(session => {
if (session) {
userModel.findOne({ _id: session.userId }, (err, user) => {
if (user && user.role === "admin")
socket.dispatch("event:station.created", { data: { station } });
else if (user && station.type === "community" && station.owner === session.userId)
socket.dispatch("event:station.created", { data: { station } });
});
}
});
}
});
}
});
}
});
CacheModule.runJob("SUB", {
channel: "station.updated",
cb: async data => {
const stationModel = await DBModule.runJob("GET_MODEL", {
modelName: "station"
});
stationModel.findOne(
{ _id: data.stationId },
["_id", "name", "displayName", "description", "type", "privacy", "owner", "partyMode", "playMode", "theme"],
(err, station) => {
WSModule.runJob("EMIT_TO_ROOMS", {
rooms: ["admin.stations"],
args: ["event:admin.station.updated", { data: { station } }]
});
}
);
}
});
export default {
/**
* Get a list of all the stations
*
* @param {object} session - user session
* @param {Function} cb - callback
*/
async index(session, cb) {
const userModel = await DBModule.runJob("GET_MODEL", { modelName: "user" });
async.waterfall(
[
// get array of the ids of the user's favorite stations
next => {
if (session.userId)
return userModel.findById(session.userId).select({ favoriteStations: -1 }).exec(next);
return next(null, { favoriteStations: [] });
},
(user, next) => {
const favoriteStations = user ? user.favoriteStations : [];
CacheModule.runJob("HGETALL", { table: "stations" }, this).then(stations =>
next(null, stations, favoriteStations)
);
},
(stations, favorited, next) => {
const filteredStations = [];
async.eachLimit(
stations,
1,
(station, nextStation) => {
async.waterfall(
[
callback => {
// only relevant if user logged in
if (session.userId) {
if (favorited.indexOf(station._id) !== -1) station.isFavorited = true;
return callback();
}
return callback();
},
callback => {
StationsModule.runJob(
"CAN_USER_VIEW_STATION",
{
station,
userId: session.userId,
hideUnlisted: true
},
this
)
.then(exists => callback(null, exists))
.catch(callback);
}
],
(err, exists) => {
if (err) return this.log("ERROR", "STATIONS_INDEX", err);
station.userCount = StationsModule.usersPerStationCount[station._id] || 0;
if (exists) filteredStations.push(station);
return nextStation();
}
);
},
() => next(null, filteredStations, favorited)
);
}
],
async (err, stations, favorited) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log("ERROR", "STATIONS_INDEX", `Indexing stations failed. "${err}"`);
return cb({ status: "error", message: err });
}
this.log("SUCCESS", "STATIONS_INDEX", `Indexing stations successful.`, false);
return cb({ status: "success", data: { stations, favorited } });
}
);
},
/**
* Gets stations, used in the admin stations page by the AdvancedTable component
*
* @param {object} session - the session object automatically added by the websocket
* @param page - the page
* @param pageSize - the size per page
* @param properties - the properties to return for each station
* @param sort - the sort object
* @param queries - the queries array
* @param operator - the operator for queries
* @param cb
*/
getData: isAdminRequired(async function getSet(session, page, pageSize, properties, sort, queries, operator, cb) {
async.waterfall(
[
next => {
DBModule.runJob(
"GET_DATA",
{
page,
pageSize,
properties,
sort,
queries,
operator,
modelName: "station",
blacklistedProperties: [],
specialProperties: {
owner: [
{
$addFields: {
ownerOID: {
$convert: {
input: "$owner",
to: "objectId",
onError: "unknown",
onNull: "unknown"
}
}
}
},
{
$lookup: {
from: "users",
localField: "ownerOID",
foreignField: "_id",
as: "ownerUser"
}
},
{
$unwind: {
path: "$ownerUser",
preserveNullAndEmptyArrays: true
}
},
{
$addFields: {
ownerUsername: {
$cond: [
{ $eq: [{ $type: "$owner" }, "string"] },
{ $ifNull: ["$ownerUser.username", "unknown"] },
"none"
]
}
}
},
{
$project: {
ownerOID: 0,
ownerUser: 0
}
}
]
},
specialQueries: {
owner: newQuery => ({ $or: [newQuery, { ownerUsername: newQuery.owner }] })
}
},
this
)
.then(response => {
next(null, response);
})
.catch(err => {
next(err);
});
}
],
async (err, response) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log("ERROR", "STATIONS_GET_DATA", `Failed to get data from stations. "${err}"`);
return cb({ status: "error", message: err });
}
this.log("SUCCESS", "STATIONS_GET_DATA", `Got data from stations successfully.`);
return cb({ status: "success", message: "Successfully got data from stations.", data: response });
}
);
}),
/**
* Obtains basic metadata of a station in order to format an activity
*
* @param {object} session - user session
* @param {string} stationId - the station id
* @param {Function} cb - callback
*/
getStationForActivity(session, stationId, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
}
],
async (err, station) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_GET_STATION_FOR_ACTIVITY",
`Failed to obtain metadata of station ${stationId} for activity formatting. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_GET_STATION_FOR_ACTIVITY",
`Obtained metadata of station ${stationId} for activity formatting successfully.`
);
return cb({
status: "success",
data: {
title: station.displayName,
thumbnail: station.currentSong ? station.currentSong.thumbnail : ""
}
});
}
);
},
/**
* Verifies that a station exists from its name
*
* @param {object} session - user session
* @param {string} stationName - the station name
* @param {Function} cb - callback
*/
existsByName(session, stationName, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION_BY_NAME", { stationName }, this)
.then(station => next(null, station))
.catch(next);
},
(station, next) => {
if (!station) return next(null, false);
return StationsModule.runJob("CAN_USER_VIEW_STATION", { station, userId: session.userId }, this)
.then(exists => next(null, exists))
.catch(next);
}
],
async (err, exists) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATION_EXISTS_BY_NAME",
`Checking if station "${stationName}" exists failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATION_EXISTS_BY_NAME",
`Station "${stationName}" exists successfully.` /* , false */
);
return cb({ status: "success", data: { exists } });
}
);
},
/**
* Verifies that a station exists from its id
*
* @param {object} session - user session
* @param {string} stationId - the station id
* @param {Function} cb - callback
*/
existsById(session, stationId, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
},
(station, next) => {
if (!station) return next(null, false);
return StationsModule.runJob("CAN_USER_VIEW_STATION", { station, userId: session.userId }, this)
.then(exists => next(null, exists))
.catch(next);
}
],
async (err, exists) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATION_EXISTS_BY_ID",
`Checking if station "${stationId}" exists failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATION_EXISTS_BY_ID",
`Station "${stationId}" exists successfully.` /* , false */
);
return cb({ status: "success", data: { exists } });
}
);
},
/**
* Gets the official playlist for a station
*
* @param {object} session - user session
* @param {string} stationId - the station id
* @param {Function} cb - callback
*/
getPlaylist(session, stationId, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
},
(station, next) => {
StationsModule.runJob(
"CAN_USER_VIEW_STATION",
{
station,
userId: session.userId
},
this
)
.then(canView => {
if (canView) return next(null, station);
return next("Insufficient permissions.");
})
.catch(err => next(err));
},
(station, next) => {
if (!station) return next("Station not found.");
if (station.type !== "official") return next("This is not an official station.");
return next();
},
next => {
CacheModule.runJob(
"HGET",
{
table: "officialPlaylists",
key: stationId
},
this
)
.then(playlist => {
next(null, playlist);
})
.catch(next);
},
(playlist, next) => {
if (!playlist) return next("Playlist not found.");
return next(null, playlist);
}
],
async (err, playlist) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_GET_PLAYLIST",
`Getting playlist for station "${stationId}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_GET_PLAYLIST",
`Got playlist for station "${stationId}" successfully.`,
false
);
return cb({ status: "success", data: { songs: playlist.songs } });
}
);
},
/**
* Joins the station by its name
*
* @param {object} session - user session
* @param {string} stationIdentifier - the station name or station id
* @param {Function} cb - callback
*/
join(session, stationIdentifier, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION_BY_NAME", { stationName: stationIdentifier }, this)
.then(station => next(null, station))
.catch(() =>
// station identifier may be using stationid instead
StationsModule.runJob("GET_STATION", { stationId: stationIdentifier }, this)
.then(station => next(null, station))
.catch(next)
);
},
(station, next) => {
if (!station) return next("Station not found.");
return StationsModule.runJob("CAN_USER_VIEW_STATION", { station, userId: session.userId }, this)
.then(canView => {
if (!canView) next("Not allowed to join station.");
else next(null, station);
})
.catch(err => next(err));
},
(station, next) => {
WSModule.runJob("SOCKET_JOIN_ROOM", {
socketId: session.socketId,
room: `station.${station._id}`
});
const data = {
_id: station._id,
type: station.type,
currentSong: station.currentSong,
startedAt: station.startedAt,
paused: station.paused,
timePaused: station.timePaused,
pausedAt: station.pausedAt,
description: station.description,
displayName: station.displayName,
name: station.name,
privacy: station.privacy,
locked: station.locked,
partyMode: station.partyMode,
playMode: station.playMode,
owner: station.owner,
includedPlaylists: station.includedPlaylists,
excludedPlaylists: station.excludedPlaylists,
theme: station.theme
};
StationsModule.userList[session.socketId] = station._id;
next(null, data);
},
(data, next) => {
data = JSON.parse(JSON.stringify(data));
data.userCount = StationsModule.usersPerStationCount[data._id] || 0;
data.users = StationsModule.usersPerStation[data._id] || [];
if (!data.currentSong || !data.currentSong.title) return next(null, data);
WSModule.runJob("SOCKET_JOIN_SONG_ROOM", {
socketId: session.socketId,
room: `song.${data.currentSong.youtubeId}`
});
data.currentSong.skipVotes = data.currentSong.skipVotes.length;
return SongsModule.runJob(
"GET_SONG_FROM_YOUTUBE_ID",
{ youtubeId: data.currentSong.youtubeId },
this
)
.then(response => {
const { song } = response;
if (song) {
data.currentSong.likes = song.likes;
data.currentSong.dislikes = song.dislikes;
} else {
data.currentSong.likes = -1;
data.currentSong.dislikes = -1;
}
})
.catch(() => {
data.currentSong.likes = -1;
data.currentSong.dislikes = -1;
})
.finally(() => next(null, data));
},
(data, next) => {
// only relevant if user logged in
if (session.userId) {
return StationsModule.runJob(
"HAS_USER_FAVORITED_STATION",
{
userId: session.userId,
stationId: data._id
},
this
)
.then(isStationFavorited => {
data.isFavorited = isStationFavorited;
return next(null, data);
})
.catch(err => next(err));
}
return next(null, data);
}
],
async (err, data) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log("ERROR", "STATIONS_JOIN", `Joining station "${stationIdentifier}" failed. "${err}"`);
return cb({ status: "error", message: err });
}
this.log("SUCCESS", "STATIONS_JOIN", `Joined station "${data._id}" successfully.`);
return cb({ status: "success", data });
}
);
},
/**
* Gets a station by id
*
* @param {object} session - user session
* @param {string} stationId - the station id
* @param {Function} cb - callback
*/
getStationById(session, stationId, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
return StationsModule.runJob(
"CAN_USER_VIEW_STATION",
{
station,
userId: session.userId
},
this
)
.then(canView => {
if (!canView) next("Not allowed to get station.");
else next(null, station);
})
.catch(err => next(err));
},
(station, next) => {
const data = {
_id: station._id,
type: station.type,
description: station.description,
displayName: station.displayName,
name: station.name,
privacy: station.privacy,
locked: station.locked,
partyMode: station.partyMode,
playMode: station.playMode,
owner: station.owner,
theme: station.theme,
paused: station.paused,
currentSong: station.currentSong
};
next(null, data);
}
],
async (err, data) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log("ERROR", "GET_STATION_BY_ID", `Getting station "${stationId}" failed. "${err}"`);
return cb({ status: "error", message: err });
}
this.log("SUCCESS", "GET_STATION_BY_ID", `Got station "${stationId}" successfully.`);
return cb({ status: "success", data: { station: data } });
}
);
},
getStationIncludedPlaylistsById(session, stationId, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
return StationsModule.runJob(
"CAN_USER_VIEW_STATION",
{
station,
userId: session.userId
},
this
)
.then(canView => {
if (!canView) next("Not allowed to get station.");
else next(null, station);
})
.catch(err => next(err));
},
(station, next) => {
const playlists = [];
async.eachLimit(
station.includedPlaylists,
1,
(playlistId, next) => {
PlaylistsModule.runJob("GET_PLAYLIST", { playlistId }, this)
.then(playlist => {
playlists.push(playlist);
next();
})
.catch(() => {
playlists.push(null);
next();
});
},
err => {
next(err, playlists);
}
);
}
],
async (err, playlists) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"GET_STATION_INCLUDED_PLAYLISTS_BY_ID",
`Getting station "${stationId}"'s included playlists failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"GET_STATION_INCLUDED_PLAYLISTS_BY_ID",
`Got station "${stationId}"'s included playlists successfully.`
);
return cb({ status: "success", data: { playlists } });
}
);
},
getStationExcludedPlaylistsById(session, stationId, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
return StationsModule.runJob(
"CAN_USER_VIEW_STATION",
{
station,
userId: session.userId
},
this
)
.then(canView => {
if (!canView) next("Not allowed to get station.");
else next(null, station);
})
.catch(err => next(err));
},
(station, next) => {
const playlists = [];
async.eachLimit(
station.excludedPlaylists,
1,
(playlistId, next) => {
PlaylistsModule.runJob("GET_PLAYLIST", { playlistId }, this)
.then(playlist => {
playlists.push(playlist);
next();
})
.catch(() => {
playlists.push(null);
next();
});
},
err => {
next(err, playlists);
}
);
}
],
async (err, playlists) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"GET_STATION_EXCLUDED_PLAYLISTS_BY_ID",
`Getting station "${stationId}"'s excluded playlists failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"GET_STATION_EXCLUDED_PLAYLISTS_BY_ID",
`Got station "${stationId}"'s excluded playlists successfully.`
);
return cb({ status: "success", data: { playlists } });
}
);
},
/**
* Toggles if a station is locked
*
* @param session
* @param stationId - the station id
* @param cb
*/
toggleLock: isOwnerRequired(async function toggleLock(session, stationId, cb) {
const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
},
(station, next) => {
stationModel.updateOne({ _id: stationId }, { $set: { locked: !station.locked } }, next);
},
(res, next) => {
StationsModule.runJob("UPDATE_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
}
],
async (err, station) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_UPDATE_LOCKED_STATUS",
`Toggling the queue lock for station "${stationId}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_UPDATE_LOCKED_STATUS",
`Toggled the queue lock for station "${stationId}" successfully to "${station.locked}".`
);
CacheModule.runJob("PUB", {
channel: "station.queueLockToggled",
value: {
stationId,
locked: station.locked
}
});
CacheModule.runJob("PUB", {
channel: "station.updated",
value: { stationId }
});
return cb({ status: "success", data: { locked: station.locked } });
}
);
}),
/**
* Votes to skip a station
*
* @param session
* @param stationId - the station id
* @param cb
*/
voteSkip: isLoginRequired(async function voteSkip(session, stationId, cb) {
const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);
let skipVotes = 0;
let shouldSkip = false;
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
return StationsModule.runJob("CAN_USER_VIEW_STATION", { station, userId: session.userId }, this)
.then(canView => {
if (canView) return next(null, station);
return next("Insufficient permissions.");
})
.catch(err => next(err));
},
(station, next) => {
if (!station.currentSong) return next("There is currently no song to skip.");
if (station.currentSong.skipVotes.indexOf(session.userId) !== -1)
return next("You have already voted to skip this song.");
return next(null, station);
},
(station, next) => {
stationModel.updateOne(
{ _id: stationId },
{ $push: { "currentSong.skipVotes": session.userId } },
next
);
},
(res, next) => {
StationsModule.runJob("UPDATE_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
return next(null, station);
},
(station, next) => {
skipVotes = station.currentSong.skipVotes.length;
WSModule.runJob("GET_SOCKETS_FOR_ROOM", { room: `station.${stationId}` }, this)
.then(sockets => next(null, sockets))
.catch(next);
},
(sockets, next) => {
if (sockets.length <= skipVotes) {
shouldSkip = true;
return next();
}
const users = [];
return async.each(
sockets,
(socketId, next) => {
WSModule.runJob("SOCKET_FROM_SOCKET_ID", { socketId }, this)
.then(socket => {
if (socket && socket.session && socket.session.userId) {
if (!users.includes(socket.session.userId)) users.push(socket.session.userId);
}
return next();
})
.catch(next);
},
err => {
if (err) return next(err);
if (users.length <= skipVotes) shouldSkip = true;
return next();
}
);
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log("ERROR", "STATIONS_VOTE_SKIP", `Vote skipping station "${stationId}" failed. "${err}"`);
return cb({ status: "error", message: err });
}
this.log("SUCCESS", "STATIONS_VOTE_SKIP", `Vote skipping "${stationId}" successful.`);
CacheModule.runJob("PUB", {
channel: "station.voteSkipSong",
value: stationId
});
if (shouldSkip) {
StationsModule.runJob("SKIP_STATION", { stationId, natural: false });
}
return cb({
status: "success",
message: "Successfully voted to skip the song."
});
}
);
}),
/**
* Force skips a station
*
* @param session
* @param stationId - the station id
* @param cb
*/
forceSkip: isOwnerRequired(function forceSkip(session, stationId, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
return next();
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log("ERROR", "STATIONS_FORCE_SKIP", `Force skipping station "${stationId}" failed. "${err}"`);
return cb({ status: "error", message: err });
}
StationsModule.runJob("SKIP_STATION", { stationId, natural: false });
this.log("SUCCESS", "STATIONS_FORCE_SKIP", `Force skipped station "${stationId}" successfully.`);
return cb({
status: "success",
message: "Successfully skipped station."
});
}
);
}),
/**
* Leaves the user's current station
*
* @param {object} session - user session
* @param {string} stationId - id of station to leave
* @param {Function} cb - callback
*/
leave(session, stationId, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
return next();
}
],
async (err, userCount) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log("ERROR", "STATIONS_LEAVE", `Leaving station "${stationId}" failed. "${err}"`);
return cb({ status: "error", message: err });
}
this.log("SUCCESS", "STATIONS_LEAVE", `Left station "${stationId}" successfully.`);
WSModule.runJob("SOCKET_LEAVE_ROOM", { socketId: session.socketId, room: `station.${stationId}` });
WSModule.runJob("SOCKETS_LEAVE_SONG_ROOMS", { sockets: [session.socketId] });
delete StationsModule.userList[session.socketId];
return cb({
status: "success",
message: "Successfully left station.",
data: { userCount }
});
}
);
},
/**
* Updates a station's name
*
* @param session
* @param stationId - the station id
* @param newName - the new station name
* @param cb
*/
updateName: isOwnerRequired(async function updateName(session, stationId, newName, cb) {
const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);
async.waterfall(
[
next => {
stationModel.updateOne(
{ _id: stationId },
{ $set: { name: newName } },
{ runValidators: true },
next
);
},
(res, next) => {
StationsModule.runJob("UPDATE_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
}
],
async (err, station) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_UPDATE_NAME",
`Updating station "${stationId}" name to "${newName}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_UPDATE_NAME",
`Updated station "${stationId}" name to "${newName}" successfully.`
);
CacheModule.runJob("PUB", {
channel: "station.nameUpdate",
value: { stationId, name: newName }
});
CacheModule.runJob("PUB", {
channel: "station.updated",
value: { stationId }
});
ActivitiesModule.runJob("ADD_ACTIVITY", {
userId: session.userId,
type: "station__edit_name",
payload: {
message: `Changed name of station ${station.displayName} to ${newName}`,
stationId
}
});
return cb({
status: "success",
message: "Successfully updated the name."
});
}
);
}),
/**
* Updates a station's display name
*
* @param session
* @param stationId - the station id
* @param newDisplayName - the new station display name
* @param cb
*/
updateDisplayName: isOwnerRequired(async function updateDisplayName(session, stationId, newDisplayName, cb) {
const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);
const playlistModel = await DBModule.runJob("GET_MODEL", { modelName: "playlist" }, this);
async.waterfall(
[
next => {
stationModel.updateOne(
{ _id: stationId },
{ $set: { displayName: newDisplayName } },
{ runValidators: true },
next
);
},
(res, next) => {
StationsModule.runJob("UPDATE_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
},
(station, next) => {
playlistModel.updateOne(
{ _id: station.playlist },
{ $set: { displayName: `Station - ${station.displayName}` } },
err => {
next(err, station);
}
);
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_UPDATE_DISPLAY_NAME",
`Updating station "${stationId}" displayName to "${newDisplayName}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_UPDATE_DISPLAY_NAME",
`Updated station "${stationId}" displayName to "${newDisplayName}" successfully.`
);
CacheModule.runJob("PUB", {
channel: "station.displayNameUpdate",
value: { stationId, displayName: newDisplayName }
});
CacheModule.runJob("PUB", {
channel: "station.updated",
value: { stationId }
});
ActivitiesModule.runJob("ADD_ACTIVITY", {
userId: session.userId,
type: "station__edit_display_name",
payload: {
message: `Changed display name of station ${newDisplayName}`,
stationId
}
});
return cb({
status: "success",
message: "Successfully updated the display name."
});
}
);
}),
/**
* Updates a station's description
*
* @param session
* @param stationId - the station id
* @param newDescription - the new station description
* @param cb
*/
updateDescription: isOwnerRequired(async function updateDescription(session, stationId, newDescription, cb) {
const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);
async.waterfall(
[
next => {
stationModel.updateOne(
{ _id: stationId },
{ $set: { description: newDescription } },
{ runValidators: true },
next
);
},
(res, next) => {
StationsModule.runJob("UPDATE_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
}
],
async (err, station) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_UPDATE_DESCRIPTION",
`Updating station "${stationId}" description to "${newDescription}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_UPDATE_DESCRIPTION",
`Updated station "${stationId}" description to "${newDescription}" successfully.`
);
ActivitiesModule.runJob("ADD_ACTIVITY", {
userId: session.userId,
type: "station__edit_description",
payload: {
message: `Changed description of station ${station.displayName} to ${newDescription}`,
stationId
}
});
CacheModule.runJob("PUB", {
channel: "station.descriptionUpdate",
value: { stationId, description: newDescription }
});
CacheModule.runJob("PUB", {
channel: "station.updated",
value: { stationId }
});
return cb({
status: "success",
message: "Successfully updated the description."
});
}
);
}),
/**
* Updates a station's privacy
*
* @param session
* @param stationId - the station id
* @param newPrivacy - the new station privacy
* @param cb
*/
updatePrivacy: isOwnerRequired(async function updatePrivacy(session, stationId, newPrivacy, cb) {
const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);
let previousPrivacy = null;
async.waterfall(
[
next => {
stationModel.findOne({ _id: stationId }, next);
},
(station, next) => {
if (!station) next("No station found.");
else {
previousPrivacy = station.privacy;
next();
}
},
next => {
stationModel.updateOne(
{ _id: stationId },
{ $set: { privacy: newPrivacy } },
{ runValidators: true },
next
);
},
(res, next) => {
StationsModule.runJob("UPDATE_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
}
],
async (err, station) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_UPDATE_PRIVACY",
`Updating station "${stationId}" privacy to "${newPrivacy}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_UPDATE_PRIVACY",
`Updated station "${stationId}" privacy to "${newPrivacy}" successfully.`
);
CacheModule.runJob("PUB", {
channel: "station.privacyUpdate",
value: { stationId, previousPrivacy }
});
CacheModule.runJob("PUB", {
channel: "station.updated",
value: { stationId }
});
ActivitiesModule.runJob("ADD_ACTIVITY", {
userId: session.userId,
type: "station__edit_privacy",
payload: {
message: `Changed privacy of station ${station.displayName} to ${newPrivacy}`,
stationId
}
});
return cb({
status: "success",
message: "Successfully updated the privacy."
});
}
);
}),
/**
* Updates a station's genres
*
* @param session
* @param stationId - the station id
* @param newGenres - the new station genres
* @param cb
*/
updateGenres: isOwnerRequired(async function updateGenres(session, stationId, newGenres, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
},
(station, next) => {
const playlists = [];
async.eachLimit(
newGenres,
1,
(genre, next) => {
PlaylistsModule.runJob("GET_GENRE_PLAYLIST", { genre, includeSongs: false }, this)
.then(response => {
playlists.push(response.playlist);
next();
})
.catch(err => {
if (err.message === "Playlist not found")
next(
`The genre playlist for "${genre}" was not found. Please ensure that this genre playlist exists.`
);
else next(err);
});
},
err => {
next(
err,
station,
playlists.map(playlist => playlist._id.toString())
);
}
);
},
(station, playlists, next) => {
const playlistsToRemoveFromExcluded = playlists.filter(
playlistId => station.excludedPlaylists.indexOf(playlistId) !== -1
);
console.log(
`playlistsToRemoveFromExcluded: ${playlistsToRemoveFromExcluded.length}`,
playlistsToRemoveFromExcluded
);
async.eachLimit(
playlistsToRemoveFromExcluded,
1,
(playlistId, next) => {
StationsModule.runJob("REMOVE_EXCLUDED_PLAYLIST", { stationId, playlistId }, this)
.then(() => {
next();
})
.catch(next);
},
err => {
next(err, station, playlists);
}
);
},
(station, playlists, next) => {
const playlistsToRemoveFromIncluded = station.includedPlaylists.filter(
playlistId => playlists.indexOf(playlistId) === -1
);
console.log(
`playlistsToRemoveFromIncluded: ${playlistsToRemoveFromIncluded.length}`,
playlistsToRemoveFromIncluded
);
async.eachLimit(
playlistsToRemoveFromIncluded,
1,
(playlistId, next) => {
StationsModule.runJob("REMOVE_INCLUDED_PLAYLIST", { stationId, playlistId }, this)
.then(() => {
next();
})
.catch(next);
},
err => {
next(err, station, playlists);
}
);
},
(station, playlists, next) => {
const playlistsToAddToIncluded = playlists.filter(
playlistId => station.includedPlaylists.indexOf(playlistId) === -1
);
console.log(
`playlistsToAddToIncluded: ${playlistsToAddToIncluded.length}`,
playlistsToAddToIncluded
);
async.eachLimit(
playlistsToAddToIncluded,
1,
(playlistId, next) => {
StationsModule.runJob("INCLUDE_PLAYLIST", { stationId, playlistId }, this)
.then(() => {
next();
})
.catch(next);
},
err => {
next(err);
}
);
},
next => {
PlaylistsModule.runJob("AUTOFILL_STATION_PLAYLIST", { stationId }).then().catch();
StationsModule.runJob("UPDATE_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
}
],
async (err, station) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err });
this.log(
"ERROR",
"STATIONS_UPDATE_GENRES",
`Updating station "${stationId}" genres to "${newGenres}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_UPDATE_GENRES",
`Updated station "${stationId}" genres to "${newGenres}" successfully.`
);
if (newGenres.length > 0) {
ActivitiesModule.runJob("ADD_ACTIVITY", {
userId: session.userId,
type: "station__edit_genres",
payload: {
message: `Updated genres of station ${station.displayName} to
${newGenres.join(", ")}`,
stationId
}
});
} else {
ActivitiesModule.runJob("ADD_ACTIVITY", {
userId: session.userId,
type: "station__edit_genres",
payload: {
message: `Removed all genres of station ${station.displayName}`,
stationId
}
});
}
return cb({
status: "success",
message: "Successfully updated the genres."
});
}
);
}),
/**
* Updates a station's blacklisted genres
*
* @param session
* @param stationId - the station id
* @param newBlacklistedGenres - the new station blacklisted genres
* @param cb
*/
updateBlacklistedGenres: isOwnerRequired(async function updateBlacklistedGenres(
session,
stationId,
newBlacklistedGenres,
cb
) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
},
(station, next) => {
const playlists = [];
async.eachLimit(
newBlacklistedGenres,
1,
(genre, next) => {
PlaylistsModule.runJob("GET_GENRE_PLAYLIST", { genre, includeSongs: false }, this)
.then(response => {
playlists.push(response.playlist);
next();
})
.catch(err => {
if (err.message === "Playlist not found")
next(
`The genre playlist for "${genre}" was not found. Please ensure that this genre playlist exists.`
);
else next(err);
});
},
err => {
next(
err,
station,
playlists.map(playlist => playlist._id.toString())
);
}
);
},
(station, playlists, next) => {
const playlistsToRemoveFromIncluded = playlists.filter(
playlistId => station.includedPlaylists.indexOf(playlistId) !== -1
);
console.log(
`playlistsToRemoveFromIncluded: ${playlistsToRemoveFromIncluded.length}`,
playlistsToRemoveFromIncluded
);
async.eachLimit(
playlistsToRemoveFromIncluded,
1,
(playlistId, next) => {
StationsModule.runJob("REMOVE_INCLUDED_PLAYLIST", { stationId, playlistId }, this)
.then(() => {
next();
})
.catch(next);
},
err => {
next(err, station, playlists);
}
);
},
(station, playlists, next) => {
const playlistsToRemoveFromExcluded = station.excludedPlaylists.filter(
playlistId => playlists.indexOf(playlistId) === -1
);
console.log(
`playlistsToRemoveFromExcluded: ${playlistsToRemoveFromExcluded.length}`,
playlistsToRemoveFromExcluded
);
async.eachLimit(
playlistsToRemoveFromExcluded,
1,
(playlistId, next) => {
StationsModule.runJob("REMOVE_EXCLUDED_PLAYLIST", { stationId, playlistId }, this)
.then(() => {
next();
})
.catch(next);
},
err => {
next(err, station, playlists);
}
);
},
(station, playlists, next) => {
const playlistsToAddToExcluded = playlists.filter(
playlistId => station.excludedPlaylists.indexOf(playlistId) === -1
);
console.log(
`playlistsToAddToExcluded: ${playlistsToAddToExcluded.length}`,
playlistsToAddToExcluded
);
async.eachLimit(
playlistsToAddToExcluded,
1,
(playlistId, next) => {
StationsModule.runJob("EXCLUDE_PLAYLIST", { stationId, playlistId }, this)
.then(() => {
next();
})
.catch(next);
},
err => {
next(err);
}
);
},
next => {
PlaylistsModule.runJob("AUTOFILL_STATION_PLAYLIST", { stationId }).then().catch();
StationsModule.runJob("UPDATE_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
}
],
async (err, station) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_UPDATE_BLACKLISTED_GENRES",
`Updating station "${stationId}" blacklisted genres to "${newBlacklistedGenres}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_UPDATE_BLACKLISTED_GENRES",
`Updated station "${stationId}" blacklisted genres to "${newBlacklistedGenres}" successfully.`
);
if (newBlacklistedGenres.length > 0) {
ActivitiesModule.runJob("ADD_ACTIVITY", {
userId: session.userId,
type: "station__edit_blacklisted_genres",
payload: {
message: `Updated blacklisted genres of station ${
station.displayName
} to ${newBlacklistedGenres.join(", ")}`,
stationId
}
});
} else {
ActivitiesModule.runJob("ADD_ACTIVITY", {
userId: session.userId,
type: "station__edit_blacklisted_genres",
payload: {
message: `Removed all blacklisted genres of station ${station.displayName}`,
stationId
}
});
}
return cb({
status: "success",
message: "Successfully updated the blacklisted genres."
});
}
);
}),
/**
* Updates a station's party mode
*
* @param session
* @param stationId - the station id
* @param newPartyMode - the new station party mode
* @param cb
*/
updatePartyMode: isOwnerRequired(async function updatePartyMode(session, stationId, newPartyMode, cb) {
const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
if (station.partyMode === newPartyMode)
return next(`The party mode was already ${newPartyMode ? "enabled." : "disabled."}`);
return stationModel.updateOne(
{ _id: stationId },
{ $set: { partyMode: newPartyMode, queue: [] } },
{ runValidators: true },
next
);
},
(res, next) => {
CacheModule.runJob("PUB", {
channel: "station.queueUpdate",
value: stationId
})
.then(() => {})
.catch(next);
StationsModule.runJob("UPDATE_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_UPDATE_PARTY_MODE",
`Updating station "${stationId}" party mode to "${newPartyMode}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_UPDATE_PARTY_MODE",
`Updated station "${stationId}" party mode to "${newPartyMode}" successfully.`
);
CacheModule.runJob("PUB", {
channel: "station.updatePartyMode",
value: {
stationId,
partyMode: newPartyMode
}
});
CacheModule.runJob("PUB", {
channel: "station.updated",
value: { stationId }
});
StationsModule.runJob("SKIP_STATION", { stationId, natural: false });
return cb({
status: "success",
message: "Successfully updated the party mode."
});
}
);
}),
/**
* Updates a station's play mode
*
* @param session
* @param stationId - the station id
* @param newPlayMode - the new station play mode
* @param cb
*/
updatePlayMode: isOwnerRequired(async function updatePartyMode(session, stationId, newPlayMode, cb) {
const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
if (station.newPlayMode === newPlayMode) return next(`The play mode was already ${newPlayMode}`);
return stationModel.updateOne(
{ _id: stationId },
{ $set: { playMode: newPlayMode, queue: [] } },
{ runValidators: true },
next
);
},
(res, next) => {
CacheModule.runJob("PUB", {
channel: "station.queueUpdate",
value: stationId
})
.then()
.catch();
StationsModule.runJob("UPDATE_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_UPDATE_PLAY_MODE",
`Updating station "${stationId}" play mode to "${newPlayMode}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_UPDATE_PLAY_MODE",
`Updated station "${stationId}" play mode to "${newPlayMode}" successfully.`
);
CacheModule.runJob("PUB", {
channel: "station.newPlayMode",
value: {
stationId,
playMode: newPlayMode
}
});
CacheModule.runJob("PUB", {
channel: "station.updated",
value: { stationId }
});
StationsModule.runJob("SKIP_STATION", { stationId, natural: false });
return cb({
status: "success",
message: "Successfully updated the play mode."
});
}
);
}),
/**
* Updates a station's theme
*
* @param session
* @param stationId - the station id
* @param newTheme - the new station theme
* @param cb
*/
updateTheme: isOwnerRequired(async function updateTheme(session, stationId, newTheme, cb) {
const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
if (station.theme === newTheme) return next("No change in theme.");
return stationModel.updateOne(
{ _id: stationId },
{ $set: { theme: newTheme } },
{ runValidators: true },
next
);
},
(res, next) => {
StationsModule.runJob("UPDATE_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
}
],
async (err, station) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_UPDATE_THEME",
`Updating station "${stationId}" theme to "${newTheme}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_UPDATE_THEME",
`Updated station "${stationId}" theme to "${newTheme}" successfully.`
);
CacheModule.runJob("PUB", {
channel: "station.themeUpdate",
value: { stationId }
});
CacheModule.runJob("PUB", {
channel: "station.updated",
value: { stationId }
});
ActivitiesModule.runJob("ADD_ACTIVITY", {
userId: session.userId,
type: "station__edit_theme",
payload: {
message: `Changed theme of station ${station.displayName} to ${newTheme}`,
stationId
}
});
return cb({
status: "success",
message: "Successfully updated the theme."
});
}
);
}),
/**
* Pauses a station
*
* @param session
* @param stationId - the station id
* @param cb
*/
pause: isOwnerRequired(async function pause(session, stationId, cb) {
const stationModel = await DBModule.runJob(
"GET_MODEL",
{
modelName: "station"
},
this
);
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
if (station.paused) return next("That station was already paused.");
return stationModel.updateOne(
{ _id: stationId },
{ $set: { paused: true, pausedAt: Date.now() } },
next
);
},
(res, next) => {
StationsModule.runJob("UPDATE_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log("ERROR", "STATIONS_PAUSE", `Pausing station "${stationId}" failed. "${err}"`);
return cb({ status: "error", message: err });
}
this.log("SUCCESS", "STATIONS_PAUSE", `Paused station "${stationId}" successfully.`);
CacheModule.runJob("PUB", {
channel: "station.pause",
value: stationId
});
NotificationsModule.runJob("UNSCHEDULE", {
name: `stations.nextSong?id=${stationId}`
});
return cb({
status: "success",
message: "Successfully paused."
});
}
);
}),
/**
* Resumes a station
*
* @param session
* @param stationId - the station id
* @param cb
*/
resume: isOwnerRequired(async function resume(session, stationId, cb) {
const stationModel = await DBModule.runJob(
"GET_MODEL",
{
modelName: "station"
},
this
);
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
if (!station.paused) return next("That station is not paused.");
station.timePaused += Date.now() - station.pausedAt;
return stationModel.updateOne(
{ _id: stationId },
{
$set: { paused: false },
$inc: { timePaused: Date.now() - station.pausedAt }
},
next
);
},
(res, next) => {
StationsModule.runJob("UPDATE_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log("ERROR", "STATIONS_RESUME", `Resuming station "${stationId}" failed. "${err}"`);
return cb({ status: "error", message: err });
}
this.log("SUCCESS", "STATIONS_RESUME", `Resuming station "${stationId}" successfully.`);
CacheModule.runJob("PUB", {
channel: "station.resume",
value: stationId
});
return cb({
status: "success",
message: "Successfully resumed."
});
}
);
}),
/**
* Removes a station
*
* @param session
* @param stationId - the station id
* @param cb
*/
remove: isOwnerRequired(async function remove(session, stationId, cb) {
const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);
const userModel = await DBModule.runJob("GET_MODEL", { modelName: "user" }, this);
async.waterfall(
[
next => {
stationModel.findById(stationId, (err, station) => {
if (err) return next(err);
return next(null, station);
});
},
(station, next) => {
stationModel.deleteOne({ _id: stationId }, err => next(err, station));
},
(station, next) => {
CacheModule.runJob("HDEL", { table: "stations", key: stationId }, this)
.then(() => next(null, station))
.catch(next);
},
// remove the playlist for the station
(station, next) => {
if (station.playlist)
PlaylistsModule.runJob("DELETE_PLAYLIST", { playlistId: station.playlist })
.then(() => {})
.catch(next);
next(null, station);
},
// remove reference to the station id in any array of a user's favorite stations
(station, next) => {
userModel.updateMany(
{ favoriteStations: stationId },
{ $pull: { favoriteStations: stationId } },
err => next(err, station)
);
}
],
async (err, station) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log("ERROR", "STATIONS_REMOVE", `Removing station "${stationId}" failed. "${err}"`);
return cb({ status: "error", message: err });
}
this.log("SUCCESS", "STATIONS_REMOVE", `Removing station "${stationId}" successfully.`);
CacheModule.runJob("PUB", {
channel: "station.remove",
value: stationId
});
ActivitiesModule.runJob("ADD_ACTIVITY", {
userId: session.userId,
type: "station__remove",
payload: { message: `Removed a station named ${station.displayName}` }
});
ActivitiesModule.runJob("REMOVE_ACTIVITY_REFERENCES", { type: "stationId", stationId });
return cb({
status: "success",
message: "Successfully removed."
});
}
);
}),
/**
* Create a station
*
* @param session
* @param data - the station data
* @param cb
*/
create: isLoginRequired(async function create(session, data, cb) {
const userModel = await DBModule.runJob("GET_MODEL", { modelName: "user" }, this);
const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);
const playlistModel = await DBModule.runJob("GET_MODEL", { modelName: "playlist" }, this);
data.name = data.name.toLowerCase();
let blacklist = [
"about",
"support",
"staff",
"help",
"news",
"terms",
"privacy",
"profile",
"c",
"community",
"tos",
"login",
"register",
"p",
"official",
"o",
"faq",
"team",
"donate",
"buy",
"shop",
"forums",
"explore",
"settings",
"admin",
"auth",
"reset_password",
"backend",
"api",
"songs",
"playlists",
"playlist",
"albums",
"artists",
"artist",
"station"
];
if (data.type === "community" && config.has("blacklistedCommunityStationNames"))
blacklist = [...blacklist, ...config.get("blacklistedCommunityStationNames")];
async.waterfall(
[
next => {
if (!data) return next("Invalid data.");
return next();
},
next => {
stationModel.findOne(
{
$or: [{ name: data.name }, { displayName: new RegExp(`^${data.displayName}$`, "i") }]
},
next
);
},
(station, next) => {
this.log(station);
if (station) return next("A station with that name or display name already exists.");
if (blacklist.indexOf(data.name) !== -1)
return next("That name is blacklisted. Please use a different name.");
if (data.type === "official") {
return userModel.findOne({ _id: session.userId }, (err, user) => {
if (err) return next(err);
if (!user) return next("User not found.");
if (user.role !== "admin") return next("Admin required.");
return next();
});
}
return next();
},
next => {
const stationId = mongoose.Types.ObjectId();
playlistModel.create(
{
displayName: `Station - ${data.name}`,
songs: [],
createdBy: data.type === "official" ? "Musare" : session.userId,
createdFor: `${stationId}`,
createdAt: Date.now(),
type: "station"
},
(err, playlist) => {
next(err, playlist, stationId);
}
);
},
(playlist, stationId, next) => {
const { name, displayName, description, type } = data;
if (type === "official") {
stationModel.create(
{
_id: stationId,
name,
displayName,
description,
playlist: playlist._id,
type,
privacy: "private",
queue: [],
currentSong: null,
partyMode: false,
playMode: "random"
},
next
);
} else {
stationModel.create(
{
_id: stationId,
name,
displayName,
description,
playlist: playlist._id,
type,
privacy: "private",
owner: session.userId,
queue: [],
currentSong: null,
partyMode: true,
playMode: "random"
},
next
);
}
}
],
async (err, station) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log("ERROR", "STATIONS_CREATE", `Creating station failed. "${err}"`);
cb({ status: "error", message: err });
} else {
this.log("SUCCESS", "STATIONS_CREATE", `Created station "${station._id}" successfully.`);
CacheModule.runJob("PUB", {
channel: "station.create",
value: station._id
});
ActivitiesModule.runJob("ADD_ACTIVITY", {
userId: session.userId,
type: "station__create",
payload: {
message: `Created a station named ${station.displayName}`,
stationId: station._id
}
});
cb({
status: "success",
message: "Successfully created station."
});
}
}
);
}),
/**
* Adds song to station queue
*
* @param session
* @param stationId - the station id
* @param youtubeId - the song id
* @param cb
*/
addToQueue: isLoginRequired(async function addToQueue(session, stationId, youtubeId, cb) {
const userModel = await DBModule.runJob("GET_MODEL", { modelName: "user" }, this);
const stationModel = await DBModule.runJob(
"GET_MODEL",
{
modelName: "station"
},
this
);
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
if (!station.partyMode) return next("Station is not in party mode.");
if (station.locked) {
return userModel.findOne({ _id: session.userId }, (err, user) => {
if (user.role !== "admin" && station.owner !== session.userId)
return next("Only owners and admins can add songs to a locked queue.");
return next(null, station);
});
}
return next(null, station);
},
(station, next) => {
if (station.type !== "community") return next("That station is not a community station.");
return StationsModule.runJob(
"CAN_USER_VIEW_STATION",
{
station,
userId: session.userId
},
this
)
.then(canView => {
if (canView) return next(null, station);
return next("Insufficient permissions.");
})
.catch(err => next(err));
},
(station, next) => {
if (station.currentSong && station.currentSong.youtubeId === youtubeId)
return next("That song is currently playing.");
return async.each(
station.queue,
(queueSong, next) => {
if (queueSong.youtubeId === youtubeId) return next("That song is already in the queue.");
return next();
},
err => next(err, station)
);
},
(station, next) => {
DBModule.runJob("GET_MODEL", { modelName: "user" }, this)
.then(UserModel => {
UserModel.findOne(
{ _id: session.userId },
{ "preferences.anonymousSongRequests": 1 },
(err, user) => next(err, station, user)
);
})
.catch(next);
},
(station, user, next) => {
SongsModule.runJob(
"ENSURE_SONG_EXISTS_BY_YOUTUBE_ID",
{
youtubeId,
userId: user.preferences.anonymousSongRequests ? null : session.userId,
automaticallyRequested: true
},
this
)
.then(response => {
const { song } = response;
const { _id, title, skipDuration, artists, thumbnail, duration, verified } = song;
next(
null,
{
_id,
youtubeId,
title,
skipDuration,
artists,
thumbnail,
duration,
verified
},
station
);
})
.catch(next);
},
(song, station, next) => {
const excludedPlaylists = [];
async.eachLimit(
station.excludedPlaylists,
1,
(playlistId, next) => {
PlaylistsModule.runJob("GET_PLAYLIST", { playlistId }, this)
.then(playlist => {
excludedPlaylists.push(playlist);
next();
})
.catch(next);
},
err => {
next(err, song, station, excludedPlaylists);
}
);
},
(song, station, excludedPlaylists, next) => {
const excludedSongs = excludedPlaylists
.flatMap(excludedPlaylist => excludedPlaylist.songs)
.reduce(
(items, item) =>
items.find(x => x.youtubeId === item.youtubeId) ? [...items] : [...items, item],
[]
);
if (excludedSongs.find(excludedSong => excludedSong._id.toString() === song._id.toString()))
next("That song is in an excluded playlist and cannot be played.");
else next(null, song, station);
},
(song, station, next) => {
song.requestedBy = session.userId;
song.requestedAt = Date.now();
return next(null, song);
},
// (song, station, next) => {
// song.requestedBy = session.userId;
// song.requestedAt = Date.now();
// let totalDuration = 0;
// station.queue.forEach(song => {
// totalDuration += song.duration;
// });
// if (totalDuration >= 3600 * 3) return next("The max length of the queue is 3 hours.");
// return next(null, song, station);
// },
// (song, station, next) => {
// if (station.queue.length === 0) return next(null, song, station);
// let totalDuration = 0;
// const userId = station.queue[station.queue.length - 1].requestedBy;
// station.queue.forEach(song => {
// if (userId === song.requestedBy) {
// totalDuration += song.duration;
// }
// });
// if (totalDuration >= 900) return next("The max length of songs per user is 15 minutes.");
// return next(null, song, station);
// },
// (song, station, next) => {
// if (station.queue.length === 0) return next(null, song);
// let totalSongs = 0;
// const userId = station.queue[station.queue.length - 1].requestedBy;
// station.queue.forEach(song => {
// if (userId === song.requestedBy) {
// totalSongs += 1;
// }
// });
// if (totalSongs <= 2) return next(null, song);
// if (totalSongs > 3)
// return next("The max amount of songs per user is 3, and only 2 in a row is allowed.");
// if (
// station.queue[station.queue.length - 2].requestedBy !== userId ||
// station.queue[station.queue.length - 3] !== userId
// )
// return next("The max amount of songs per user is 3, and only 2 in a row is allowed.");
// return next(null, song);
// },
(song, next) => {
stationModel.updateOne(
{ _id: stationId },
{ $push: { queue: song } },
{ runValidators: true },
next
);
},
(res, next) => {
StationsModule.runJob("UPDATE_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_ADD_SONG_TO_QUEUE",
`Adding song "${youtubeId}" to station "${stationId}" queue failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_ADD_SONG_TO_QUEUE",
`Added song "${youtubeId}" to station "${stationId}" successfully.`
);
CacheModule.runJob("PUB", {
channel: "station.queueUpdate",
value: stationId
});
return cb({
status: "success",
message: "Successfully added song to queue."
});
}
);
}),
/**
* Removes song from station queue
*
* @param session
* @param stationId - the station id
* @param youtubeId - the youtube id
* @param cb
*/
removeFromQueue: isOwnerRequired(async function removeFromQueue(session, stationId, youtubeId, cb) {
const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);
async.waterfall(
[
next => {
if (!youtubeId) return next("Invalid youtube id.");
return StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
return async.each(
station.queue,
(queueSong, next) => {
if (queueSong.youtubeId === youtubeId) return next(true);
return next();
},
err => {
if (err === true) return next();
return next("Song is not currently in the queue.");
}
);
},
next => {
stationModel.updateOne({ _id: stationId }, { $pull: { queue: { youtubeId } } }, next);
},
(res, next) => {
StationsModule.runJob("UPDATE_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_REMOVE_SONG_TO_QUEUE",
`Removing song "${youtubeId}" from station "${stationId}" queue failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_REMOVE_SONG_TO_QUEUE",
`Removed song "${youtubeId}" from station "${stationId}" successfully.`
);
CacheModule.runJob("PUB", {
channel: "station.queueUpdate",
value: stationId
});
return cb({
status: "success",
message: "Successfully removed song from queue."
});
}
);
}),
/**
* Gets the queue from a station
*
* @param {object} session - user session
* @param {string} stationId - the station id
* @param {Function} cb - callback
*/
getQueue(session, stationId, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
return next(null, station);
},
(station, next) => {
StationsModule.runJob("CAN_USER_VIEW_STATION", { station, userId: session.userId }, this)
.then(canView => {
if (canView) return next(null, station);
return next("Insufficient permissions.");
})
.catch(err => next(err));
},
(station, next) => next(null, station.queue)
],
async (err, queue) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_GET_QUEUE",
`Getting queue for station "${stationId}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log("SUCCESS", "STATIONS_GET_QUEUE", `Got queue for station "${stationId}" successfully.`);
return cb({
status: "success",
message: "Successfully got queue.",
data: { queue }
});
}
);
},
/**
* Reposition a song in station queue
*
* @param {object} session - user session
* @param {object} song - contains details about the song that is to be repositioned
* @param {string} song.youtubeId - the youtube id of the song
* @param {number} song.newIndex - the new position for the song in the queue
* @param {number} song.oldIndex - the old position of the song in the queue
* @param {string} stationId - the station id
* @param {Function} cb - callback
*/
repositionSongInQueue: isOwnerRequired(async function repositionQueue(session, stationId, song, cb) {
const stationModel = await DBModule.runJob("GET_MODEL", { modelName: "station" }, this);
async.waterfall(
[
next => {
if (!song || !song.youtubeId) return next("You must provide a song to reposition.");
return next();
},
// remove song from queue
next => {
stationModel.updateOne(
{ _id: stationId },
{ $pull: { queue: { youtubeId: song.youtubeId } } },
next
);
},
// add song back to queue (in new position)
(res, next) => {
stationModel.updateOne(
{ _id: stationId },
{ $push: { queue: { $each: [song], $position: song.newIndex } } },
err => next(err)
);
},
// update the cache representation of the station
next => {
StationsModule.runJob("UPDATE_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_REPOSITION_SONG_IN_QUEUE",
`Repositioning song ${song.youtubeId} in queue of station "${stationId}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_REPOSITION_SONG_IN_QUEUE",
`Repositioned song ${song.youtubeId} in queue of station "${stationId}" successfully.`
);
CacheModule.runJob("PUB", {
channel: "station.repositionSongInQueue",
value: {
song: {
youtubeId: song.youtubeId,
oldIndex: song.oldIndex,
newIndex: song.newIndex
},
stationId
}
});
return cb({
status: "success",
message: "Successfully repositioned song in queue."
});
}
);
}),
/**
* Includes a playlist in a station
*
* @param session
* @param stationId - the station id
* @param playlistId - the playlist id
* @param cb
*/
includePlaylist: isOwnerRequired(async function includePlaylist(session, stationId, playlistId, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
if (station.includedPlaylists.indexOf(playlistId) !== -1)
return next("That playlist is already included.");
if (station.playMode === "sequential" && station.includedPlaylists.length > 0)
return next("Error: Only 1 playlist can be included in sequential play mode.");
return next();
},
next => {
StationsModule.runJob("INCLUDE_PLAYLIST", { stationId, playlistId }, this)
.then(() => {
next();
})
.catch(next);
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_INCLUDE_PLAYLIST",
`Including playlist "${playlistId}" for station "${stationId}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_INCLUDE_PLAYLIST",
`Including playlist "${playlistId}" for station "${stationId}" successfully.`
);
PlaylistsModule.runJob("AUTOFILL_STATION_PLAYLIST", { stationId }).then().catch();
CacheModule.runJob("PUB", {
channel: "station.includedPlaylist",
value: {
playlistId,
stationId
}
});
return cb({
status: "success",
message: "Successfully included playlist."
});
}
);
}),
/**
* Remove included a playlist from a station
*
* @param session
* @param stationId - the station id
* @param playlistId - the playlist id
* @param cb
*/
removeIncludedPlaylist: isOwnerRequired(async function removeIncludedPlaylist(session, stationId, playlistId, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
if (station.includedPlaylists.indexOf(playlistId) === -1)
return next("That playlist is not included.");
return next();
},
next => {
StationsModule.runJob("REMOVE_INCLUDED_PLAYLIST", { stationId, playlistId }, this)
.then(() => {
next();
})
.catch(next);
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_REMOVE_INCLUDED_PLAYLIST",
`Removing included playlist "${playlistId}" for station "${stationId}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_REMOVE_INCLUDED_PLAYLIST",
`Removing included playlist "${playlistId}" for station "${stationId}" successfully.`
);
PlaylistsModule.runJob("AUTOFILL_STATION_PLAYLIST", { stationId }).then().catch();
CacheModule.runJob("PUB", {
channel: "station.removedIncludedPlaylist",
value: {
playlistId,
stationId
}
});
return cb({
status: "success",
message: "Successfully removed included playlist."
});
}
);
}),
/**
* Excludes a playlist in a station
*
* @param session
* @param stationId - the station id
* @param playlistId - the playlist id
* @param cb
*/
excludePlaylist: isOwnerRequired(async function excludePlaylist(session, stationId, playlistId, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
if (station.excludedPlaylists.indexOf(playlistId) !== -1)
return next("That playlist is already excluded.");
return next();
},
next => {
StationsModule.runJob("EXCLUDE_PLAYLIST", { stationId, playlistId }, this)
.then(() => {
next();
})
.catch(next);
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_EXCLUDE_PLAYLIST",
`Excluding playlist "${playlistId}" for station "${stationId}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_EXCLUDE_PLAYLIST",
`Excluding playlist "${playlistId}" for station "${stationId}" successfully.`
);
PlaylistsModule.runJob("AUTOFILL_STATION_PLAYLIST", { stationId }).then().catch();
CacheModule.runJob("PUB", {
channel: "station.excludedPlaylist",
value: {
playlistId,
stationId
}
});
return cb({
status: "success",
message: "Successfully excluded playlist."
});
}
);
}),
/**
* Remove excluded a playlist from a station
*
* @param session
* @param stationId - the station id
* @param playlistId - the playlist id
* @param cb
*/
removeExcludedPlaylist: isOwnerRequired(async function removeExcludedPlaylist(session, stationId, playlistId, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
if (station.excludedPlaylists.indexOf(playlistId) === -1)
return next("That playlist is not excluded.");
return next();
},
next => {
StationsModule.runJob("REMOVE_EXCLUDED_PLAYLIST", { stationId, playlistId }, this)
.then(() => {
next();
})
.catch(next);
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_REMOVE_EXCLUDED_PLAYLIST",
`Removing excluded playlist "${playlistId}" for station "${stationId}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_REMOVE_EXCLUDED_PLAYLIST",
`Removing excluded playlist "${playlistId}" for station "${stationId}" successfully.`
);
PlaylistsModule.runJob("AUTOFILL_STATION_PLAYLIST", { stationId }).then().catch();
CacheModule.runJob("PUB", {
channel: "station.removedExcludedPlaylist",
value: {
playlistId,
stationId
}
});
return cb({
status: "success",
message: "Successfully removed excluded playlist."
});
}
);
}),
/**
* Selects a private playlist for a station
*
* @param session
* @param stationId - the station id
* @param playlistId - the private playlist id
* @param cb
*/
selectPrivatePlaylist: isOwnerRequired(async function selectPrivatePlaylist(session, stationId, playlistId, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
if (station.type !== "community") return next("Station is not a community station.");
if (station.includedPlaylists.indexOf(playlistId) !== -1)
return next("That playlist is already included.");
return next();
},
next => {
StationsModule.runJob("INCLUDE_PLAYLIST", { stationId, playlistId }, this)
.then(() => {
next();
})
.catch(next);
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_SELECT_PRIVATE_PLAYLIST",
`Selecting private playlist "${playlistId}" for station "${stationId}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_SELECT_PRIVATE_PLAYLIST",
`Selected private playlist "${playlistId}" for station "${stationId}" successfully.`
);
PlaylistsModule.runJob("AUTOFILL_STATION_PLAYLIST", { stationId }).then().catch();
return cb({
status: "success",
message: "Successfully selected playlist."
});
}
);
}),
/**
* Deselects the private playlist selected in a station
*
* @param session
* @param stationId - the station id
* @param cb
*/
deselectPrivatePlaylist: isOwnerRequired(async function deselectPrivatePlaylist(
session,
stationId,
playlistId,
cb
) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => {
next(null, station);
})
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
if (station.type !== "community") return next("Station is not a community station.");
if (station.includedPlaylists.indexOf(playlistId) === -1)
return next("That playlist is not included.");
return next();
},
next => {
StationsModule.runJob("REMOVE_INCLUDED_PLAYLIST", { stationId, playlistId }, this)
.then(() => {
next();
})
.catch(next);
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_DESELECT_PRIVATE_PLAYLIST",
`Deselecting private playlist for station "${stationId}" failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"STATIONS_DESELECT_PRIVATE_PLAYLIST",
`Deselected private playlist for station "${stationId}" successfully.`
);
PlaylistsModule.runJob("AUTOFILL_STATION_PLAYLIST", { stationId }).then().catch();
return cb({
status: "success",
message: "Successfully deselected playlist."
});
}
);
}),
favoriteStation: isLoginRequired(async function favoriteStation(session, stationId, cb) {
const userModel = await DBModule.runJob("GET_MODEL", { modelName: "user" }, this);
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
},
(station, next) => {
if (!station) return next("Station not found.");
return StationsModule.runJob("CAN_USER_VIEW_STATION", { station, userId: session.userId }, this)
.then(canView => {
if (canView) return next(null, station);
return next("Insufficient permissions.");
})
.catch(err => next(err));
},
(station, next) => {
userModel.updateOne(
{ _id: session.userId },
{ $addToSet: { favoriteStations: stationId } },
(err, res) => next(err, station, res)
);
},
(station, res, next) => {
if (res.nModified === 0) return next("The station was already favorited.");
return next(null, station);
}
],
async (err, station) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log("ERROR", "FAVORITE_STATION", `Favoriting station "${stationId}" failed. "${err}"`);
return cb({ status: "error", message: err });
}
this.log("SUCCESS", "FAVORITE_STATION", `Favorited station "${stationId}" successfully.`);
CacheModule.runJob("PUB", {
channel: "user.favoritedStation",
value: {
userId: session.userId,
stationId
}
});
ActivitiesModule.runJob("ADD_ACTIVITY", {
userId: session.userId,
type: "station__favorite",
payload: {
message: `Favorited station ${station.displayName}`,
stationId
}
});
return cb({
status: "success",
message: "Succesfully favorited station."
});
}
);
}),
unfavoriteStation: isLoginRequired(async function unfavoriteStation(session, stationId, cb) {
const userModel = await DBModule.runJob("GET_MODEL", { modelName: "user" }, this);
async.waterfall(
[
next => {
userModel.updateOne({ _id: session.userId }, { $pull: { favoriteStations: stationId } }, next);
},
(res, next) => {
if (res.nModified === 0) return next("The station wasn't favorited.");
return next();
},
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(station => next(null, station))
.catch(next);
}
],
async (err, station) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log("ERROR", "UNFAVORITE_STATION", `Unfavoriting station "${stationId}" failed. "${err}"`);
return cb({ status: "error", message: err });
}
this.log("SUCCESS", "UNFAVORITE_STATION", `Unfavorited station "${stationId}" successfully.`);
CacheModule.runJob("PUB", {
channel: "user.unfavoritedStation",
value: {
userId: session.userId,
stationId
}
});
ActivitiesModule.runJob("ADD_ACTIVITY", {
userId: session.userId,
type: "station__unfavorite",
payload: {
message: `Unfavorited station ${station.displayName}`,
stationId
}
});
return cb({
status: "success",
message: "Succesfully unfavorited station."
});
}
);
}),
/**
* 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: "error", message: err });
}
this.log("SUCCESS", "CLEAR_EVERY_STATION_QUEUE", "Clearing every station queue was successful.");
return cb({ status: "success", message: "Successfully cleared every station queue." });
}
);
}),
/**
* Clears and refills a station queue
*
* @param {object} session - the session object automatically added by socket.io
* @param {string} stationId - the station id
* @param {Function} cb - gets called with the result
*/
clearAndRefillStationQueue: isAdminRequired(async function clearAndRefillStationQueue(session, stationId, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("CLEAR_AND_REFILL_STATION_QUEUE", { stationId }, this)
.then(() => next())
.catch(next);
}
],
async err => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"CLEAR_AND_REFILL_STATION_QUEUE",
`Clearing and refilling station queue failed. "${err}"`
);
return cb({ status: "error", message: err });
}
this.log(
"SUCCESS",
"CLEAR_AND_REFILL_STATION_QUEUE",
"Clearing and refilling station queue was successful."
);
return cb({ status: "success", message: "Successfully cleared and refilled station queue." });
}
);
}),
/**
* Gets skip votes for a station
*
* @param session
* @param stationId - the station id
* @param stationId - the song id to get skipvotes for
* @param cb
*/
getSkipVotes: isLoginRequired(async function getSkipVotes(session, stationId, songId, cb) {
async.waterfall(
[
next => {
StationsModule.runJob("GET_STATION", { stationId }, this)
.then(res => next(null, res.currentSong))
.catch(console.log);
},
(currentSong, next) => {
if (currentSong && currentSong._id === songId)
next(null, {
skipVotes: currentSong.skipVotes.length,
skipVotesCurrent: true
});
else
next(null, {
skipVotes: 0,
skipVotesCurrent: false
});
}
],
async (err, data) => {
if (err) {
err = await UtilsModule.runJob("GET_ERROR", { error: err }, this);
this.log(
"ERROR",
"STATIONS_GET_SKIP_VOTES",
`User "${session.userId}" failed to get skip votes for ${stationId}. "${err}"`
);
return cb({ status: "error", message: err });
}
const { skipVotes, skipVotesCurrent } = data;
return cb({
status: "success",
data: {
skipVotes,
skipVotesCurrent
}
});
}
);
})
};