MusareFork/backend/logic/db/index.js

'use strict';

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

const bluebird = require('bluebird');

const regex = {
	azAZ09_: /^[A-Za-z0-9_]+$/,
	az09_: /^[a-z0-9_]+$/,
	emailSimple: /^[\x00-\x7F]+@[a-z0-9]+\.[a-z0-9]+(\.[a-z0-9]+)?$/,
	password: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?&])[A-Za-z\d$@$!%*?&]/,
	ascii: /^[\x00-\x7F]+$/
};

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

mongoose.Promise = bluebird;

let initialized = false;
let lockdown = false;

let lib = {

	connection: null,
	schemas: {},
	models: {},

	init: (url, errorCb,  cb) => {
		mongoose.connect(url, {
			useNewUrlParser: true,
			useCreateIndex: true
		})
			.then(() => {
				lib.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`)),
					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`))
				};
	
				lib.models = {
					song: mongoose.model('song', lib.schemas.song),
					queueSong: mongoose.model('queueSong', lib.schemas.queueSong),
					station: mongoose.model('station', lib.schemas.station),
					user: mongoose.model('user', lib.schemas.user),
					playlist: mongoose.model('playlist', lib.schemas.playlist),
					news: mongoose.model('news', lib.schemas.news),
					report: mongoose.model('report', lib.schemas.report),
					punishment: mongoose.model('punishment', lib.schemas.punishment)
				};
	
				// lib.schemas.user.path('username').validate((username) => {
				// 	return (isLength(username, 2, 32) && regex.azAZ09_.test(username));
				// }, 'Invalid username.');
	
				lib.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);
				}, 'Invalid email.');
	
				lib.schemas.station.path('name').validate((id) => {
					return (isLength(id, 2, 16) && regex.az09_.test(id));
				}, 'Invalid station name.');
	
				lib.schemas.station.path('displayName').validate((displayName) => {
					return (isLength(displayName, 2, 32) && regex.azAZ09_.test(displayName));
				}, 'Invalid display name.');
	
				lib.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.');
	
	
				lib.schemas.station.path('owner').validate((owner, callback) => {
					lib.models.station.countDocuments({ owner: owner }, (err, c) => {
						callback(!(err || c >= 3));
					});
				}, 'User already has 3 stations.');
	
				/*
				lib.schemas.station.path('queue').validate((queue, callback) => {
					let totalDuration = 0;
					queue.forEach((song) => {
						totalDuration += song.duration;
					});
					return callback(totalDuration <= 3600 * 3);
				}, 'The max length of the queue is 3 hours.');
	
				lib.schemas.station.path('queue').validate((queue, callback) => {
					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.');
	
				lib.schemas.station.path('queue').validate((queue, callback) => {
					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.');
				*/
	
				let songTitle = (title) => {
					return isLength(title, 1, 100);
				};
				lib.schemas.song.path('title').validate(songTitle, 'Invalid title.');
				lib.schemas.queueSong.path('title').validate(songTitle, 'Invalid title.');
	
				lib.schemas.song.path('artists').validate((artists) => {
					return !(artists.length < 1 || artists.length > 10);
				}, 'Invalid artists.');
				lib.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, 32) && regex.ascii.test(artist) && artist !== "NONE");
						}).length === artists.length;
				};
				lib.schemas.song.path('artists').validate(songArtists, 'Invalid artists.');
				lib.schemas.queueSong.path('artists').validate(songArtists, 'Invalid artists.');
	
				let songGenres = (genres) => {
					return genres.filter((genre) => {
							return (isLength(genre, 1, 16) && regex.az09_.test(genre));
						}).length === genres.length;
				};
				lib.schemas.song.path('genres').validate(songGenres, 'Invalid genres.');
				lib.schemas.queueSong.path('genres').validate(songGenres, 'Invalid genres.');
	
				lib.schemas.song.path('thumbnail').validate((thumbnail) => {
					return isLength(thumbnail, 8, 256);
				}, 'Invalid thumbnail.');
				lib.schemas.queueSong.path('thumbnail').validate((thumbnail) => {
					return isLength(thumbnail, 0, 256);
				}, 'Invalid thumbnail.');
	
				lib.schemas.playlist.path('displayName').validate((displayName) => {
					return (isLength(displayName, 1, 16) && regex.ascii.test(displayName));
				}, 'Invalid display name.');
	
				lib.schemas.playlist.path('createdBy').validate((createdBy) => {
					lib.models.playlist.countDocuments({ createdBy: createdBy }, (err, c) => {
						return !(err || c >= 10);
					});
				}, 'Max 10 playlists per user.');
	
				lib.schemas.playlist.path('songs').validate((songs) => {
					return songs.length <= 2000;
				}, 'Max 2000 songs per playlist.');
	
				lib.schemas.playlist.path('songs').validate((songs) => {
					if (songs.length === 0) return true;
					return songs[0].duration <= 10800;
				}, 'Max 3 hours per song.');
	
				lib.schemas.report.path('description').validate((description) => {
					return (!description || (isLength(description, 0, 400) && regex.ascii.test(description)));
				}, 'Invalid description.');
	
				initialized = true;
	
				if (lockdown) return this._lockdown();
				cb();
			})
			.catch(err => {
				console.error(err);
				errorCb('Database connection error.', err, 'DB');
			});
	},

	passwordValid: (password) => {
		if (!isLength(password, 6, 200)) return false;
		return regex.password.test(password);
	},

	_lockdown: () => {
		lib.connection.close();
		lockdown = true;
	}
};

module.exports = lib;