MusareFork/backend/logic/db/index.js

const CoreClass = require("../../core.js");

const mongoose = require("mongoose");
const config = require("config");

const regex = {
    azAZ09_: /^[A-Za-z0-9_]+$/,
    az09_: /^[a-z0-9_]+$/,
    emailSimple: /^[\x00-\x7F]+@[a-z0-9]+\.[a-z0-9]+(\.[a-z0-9]+)?$/,
    ascii: /^[\x00-\x7F]+$/,
    custom: (regex) => new RegExp(`^[${regex}]+$`),
};

const isLength = (string, min, max) => {
    return !(
        typeof string !== "string" ||
        string.length < min ||
        string.length > max
    );
};

const bluebird = require("bluebird");

mongoose.Promise = bluebird;

class DBModule extends CoreClass {
    constructor() {
        super("db");
    }

    initialize() {
        return new Promise((resolve, reject) => {
            this.schemas = {};
            this.models = {};

            const mongoUrl = config.get("mongo").url;

            mongoose
                .connect(mongoUrl, {
                    useNewUrlParser: true,
                    useCreateIndex: true,
                    reconnectInterval: 3000,
                    reconnectTries: 10,
                })
                .then(() => {
                    this.schemas = {
                        song: new mongoose.Schema(require(`./schemas/song`)),
                        queueSong: new mongoose.Schema(
                            require(`./schemas/queueSong`)
                        ),
                        station: new mongoose.Schema(
                            require(`./schemas/station`)
                        ),
                        user: new mongoose.Schema(require(`./schemas/user`)),
                        activity: new mongoose.Schema(
                            require(`./schemas/activity`)
                        ),
                        playlist: new mongoose.Schema(
                            require(`./schemas/playlist`)
                        ),
                        news: new mongoose.Schema(require(`./schemas/news`)),
                        report: new mongoose.Schema(
                            require(`./schemas/report`)
                        ),
                        punishment: new mongoose.Schema(
                            require(`./schemas/punishment`)
                        ),
                    };

                    this.models = {
                        song: mongoose.model("song", this.schemas.song),
                        queueSong: mongoose.model(
                            "queueSong",
                            this.schemas.queueSong
                        ),
                        station: mongoose.model(
                            "station",
                            this.schemas.station
                        ),
                        user: mongoose.model("user", this.schemas.user),
                        activity: mongoose.model(
                            "activity",
                            this.schemas.activity
                        ),
                        playlist: mongoose.model(
                            "playlist",
                            this.schemas.playlist
                        ),
                        news: mongoose.model("news", this.schemas.news),
                        report: mongoose.model("report", this.schemas.report),
                        punishment: mongoose.model(
                            "punishment",
                            this.schemas.punishment
                        ),
                    };

                    mongoose.connection.on("error", (err) => {
                        this.log("ERROR", err);
                    });

                    mongoose.connection.on("disconnected", () => {
                        this.log(
                            "ERROR",
                            "Disconnected, going to try to reconnect..."
                        );
                        this.setStatus("RECONNECTING");
                    });

                    mongoose.connection.on("reconnected", () => {
                        this.log("INFO", "Reconnected.");
                        this.setStatus("READY");
                    });

                    mongoose.connection.on("reconnectFailed", () => {
                        this.log(
                            "INFO",
                            "Reconnect failed, stopping reconnecting."
                        );
                        // this.failed = true;
                        // this._lockdown();
                        this.setStatus("FAILED");
                    });

                    // User
                    this.schemas.user.path("username").validate((username) => {
                        return (
                            isLength(username, 2, 32) &&
                            regex.custom("a-zA-Z0-9_-").test(username)
                        );
                    }, "Invalid username.");

                    this.schemas.user
                        .path("email.address")
                        .validate((email) => {
                            if (!isLength(email, 3, 254)) return false;
                            if (email.indexOf("@") !== email.lastIndexOf("@"))
                                return false;
                            return (
                                regex.emailSimple.test(email) &&
                                regex.ascii.test(email)
                            );
                        }, "Invalid email.");

                    // Station
                    this.schemas.station.path("name").validate((id) => {
                        return isLength(id, 2, 16) && regex.az09_.test(id);
                    }, "Invalid station name.");

                    this.schemas.station
                        .path("displayName")
                        .validate((displayName) => {
                            return (
                                isLength(displayName, 2, 32) &&
                                regex.ascii.test(displayName)
                            );
                        }, "Invalid display name.");

                    this.schemas.station
                        .path("description")
                        .validate((description) => {
                            if (!isLength(description, 2, 200)) return false;
                            let characters = description.split("");
                            return (
                                characters.filter((character) => {
                                    return character.charCodeAt(0) === 21328;
                                }).length === 0
                            );
                        }, "Invalid display name.");

                    this.schemas.station.path("owner").validate({
                        validator: (owner) => {
                            return new Promise((resolve, reject) => {
                                this.models.station.countDocuments(
                                    { owner: owner },
                                    (err, c) => {
                                        if (err)
                                            reject(
                                                new Error(
                                                    "A mongo error happened."
                                                )
                                            );
                                        else if (c >= 3)
                                            reject(
                                                new Error(
                                                    "User already has 3 stations."
                                                )
                                            );
                                        else resolve();
                                    }
                                );
                            });
                        },
                        message: "User already has 3 stations.",
                    });

                    /*
					this.schemas.station.path('queue').validate((queue, callback) => { //Callback no longer works, see station max count
						let totalDuration = 0;
						queue.forEach((song) => {
							totalDuration += song.duration;
						});
						return callback(totalDuration <= 3600 * 3);
					}, 'The max length of the queue is 3 hours.');
		
					this.schemas.station.path('queue').validate((queue, callback) => { //Callback no longer works, see station max count
						if (queue.length === 0) return callback(true);
						let totalDuration = 0;
						const userId = queue[queue.length - 1].requestedBy;
						queue.forEach((song) => {
							if (userId === song.requestedBy) {
								totalDuration += song.duration;
							}
						});
						return callback(totalDuration <= 900);
					}, 'The max length of songs per user is 15 minutes.');
		
					this.schemas.station.path('queue').validate((queue, callback) => { //Callback no longer works, see station max count
						if (queue.length === 0) return callback(true);
						let totalSongs = 0;
						const userId = queue[queue.length - 1].requestedBy;
						queue.forEach((song) => {
							if (userId === song.requestedBy) {
								totalSongs++;
							}
						});
						if (totalSongs <= 2) return callback(true);
						if (totalSongs > 3) return callback(false);
						if (queue[queue.length - 2].requestedBy !== userId || queue[queue.length - 3] !== userId) return callback(true);
						return callback(false);
					}, 'The max amount of songs per user is 3, and only 2 in a row is allowed.');
					*/

                    // Song
                    let songTitle = (title) => {
                        return isLength(title, 1, 100);
                    };
                    this.schemas.song
                        .path("title")
                        .validate(songTitle, "Invalid title.");
                    this.schemas.queueSong
                        .path("title")
                        .validate(songTitle, "Invalid title.");

                    this.schemas.song.path("artists").validate((artists) => {
                        return !(artists.length < 1 || artists.length > 10);
                    }, "Invalid artists.");
                    this.schemas.queueSong
                        .path("artists")
                        .validate((artists) => {
                            return !(artists.length < 0 || artists.length > 10);
                        }, "Invalid artists.");

                    let songArtists = (artists) => {
                        return (
                            artists.filter((artist) => {
                                return (
                                    isLength(artist, 1, 64) && artist !== "NONE"
                                );
                            }).length === artists.length
                        );
                    };
                    this.schemas.song
                        .path("artists")
                        .validate(songArtists, "Invalid artists.");
                    this.schemas.queueSong
                        .path("artists")
                        .validate(songArtists, "Invalid artists.");

                    let songGenres = (genres) => {
                        if (genres.length < 1 || genres.length > 16)
                            return false;
                        return (
                            genres.filter((genre) => {
                                return (
                                    isLength(genre, 1, 32) &&
                                    regex.ascii.test(genre)
                                );
                            }).length === genres.length
                        );
                    };
                    this.schemas.song
                        .path("genres")
                        .validate(songGenres, "Invalid genres.");
                    this.schemas.queueSong
                        .path("genres")
                        .validate(songGenres, "Invalid genres.");

                    let songThumbnail = (thumbnail) => {
                        if (!isLength(thumbnail, 1, 256)) return false;
                        if (config.get("cookie.secure") === true)
                            return thumbnail.startsWith("https://");
                        else
                            return (
                                thumbnail.startsWith("http://") ||
                                thumbnail.startsWith("https://")
                            );
                    };
                    this.schemas.song
                        .path("thumbnail")
                        .validate(songThumbnail, "Invalid thumbnail.");
                    this.schemas.queueSong
                        .path("thumbnail")
                        .validate(songThumbnail, "Invalid thumbnail.");

                    // Playlist
                    this.schemas.playlist
                        .path("displayName")
                        .validate((displayName) => {
                            return (
                                isLength(displayName, 1, 32) &&
                                regex.ascii.test(displayName)
                            );
                        }, "Invalid display name.");

                    this.schemas.playlist
                        .path("createdBy")
                        .validate((createdBy) => {
                            this.models.playlist.countDocuments(
                                { createdBy: createdBy },
                                (err, c) => {
                                    return !(err || c >= 10);
                                }
                            );
                        }, "Max 10 playlists per user.");

                    this.schemas.playlist.path("songs").validate((songs) => {
                        return songs.length <= 5000;
                    }, "Max 5000 songs per playlist.");

                    this.schemas.playlist.path("songs").validate((songs) => {
                        if (songs.length === 0) return true;
                        return songs[0].duration <= 10800;
                    }, "Max 3 hours per song.");

                    // Report
                    this.schemas.report
                        .path("description")
                        .validate((description) => {
                            return (
                                !description ||
                                (isLength(description, 0, 400) &&
                                    regex.ascii.test(description))
                            );
                        }, "Invalid description.");

                    resolve();
                })
                .catch((err) => {
                    this.log("ERROR", err);
                    reject(err);
                });
        });
    }

    GET_MODEL(payload) {
        return new Promise((resolve, reject) => {
            resolve(this.models[payload.modelName]);
        });
    }

    GET_SCHEMA(payload) {
        return new Promise((resolve, reject) => {
            resolve(this.schemas[payload.schemaName]);
        });
    }

    passwordValid(password) {
        return isLength(password, 6, 200);
    }
}

module.exports = new DBModule();