Upload

.gitignore

@@ -0,0 +1,24 @@
+# Bot Configuration
+config.js
+
+# Node modules
+node_modules
+package-lock.json
+yarn.lock
+
+# Fortnite Shop images
+assets/img/fortnite/shop/**/*.png
+!assets/img/fortnite/shop/**/example-shop.png
+
+# DB
+giveaways.json
+
+# Mac OS files
+.DS_Store
+
+# PM2
+report*.json
+!languages/**/general/report.json
+
+# IDE
+.vscode

assets/json/filters.json

@@ -0,0 +1,15 @@
+{
+	"bassboost": "Bassboost",
+	"8D": "8D",
+	"vaporwave": "Vaporwave",
+	"nightcore": "Nightcore",
+	"phaser": "Phaser",
+	"tremolo": "Tremolo",
+	"vibrato": "Vibrato",
+	"reverse": "Reverse",
+	"treble": "Treble",
+	"normalizer": "Normalizer",
+	"surrounding": "Surrounding",
+	"pulsator": "Pulsator",
+	"superequalizer": "Superequalizer"
+}

assets/json/partners.json

@@ -0,0 +1,8 @@
+[
+	{
+		"name": "",
+		"description_french": "",
+		"description_english": "",
+		"link": ""
+	}
+]

base/Atlanta.js

@@ -0,0 +1,339 @@
+const { MessageEmbed, Util, Client, Collection } = require("discord.js");
+const { GiveawaysManager } = require("discord-giveaways");
+const { Player } = require("discord-player");
+const { Client: Joker } = require("blague.xyz");
+
+const util = require("util"),
+	AmeClient = require("amethyste-api"),
+	path = require("path"),
+	moment = require("moment");
+
+moment.relativeTimeThreshold("s", 60);
+moment.relativeTimeThreshold("ss", 5);
+moment.relativeTimeThreshold("m", 60);
+moment.relativeTimeThreshold("h", 60);
+moment.relativeTimeThreshold("d", 24);
+moment.relativeTimeThreshold("M", 12);
+
+// Creates Atlanta class
+class Atlanta extends Client {
+	constructor (options) {
+		super(options);
+		this.config = require("../config"); // Load the config file
+		this.customEmojis = require("../emojis.json"); // load the bot's emojis
+		this.languages = require("../languages/language-meta.json"); // Load the bot's languages
+		this.commands = new Collection(); // Creates new commands collection
+		this.aliases = new Collection(); // Creates new command aliases collection
+		this.logger = require("../helpers/logger"); // Load the logger file
+		this.wait = util.promisify(setTimeout); // client.wait(1000) - Wait 1 second
+		this.functions = require("../helpers/functions"); // Load the functions file
+		this.guildsData = require("../base/Guild"); // Guild mongoose model
+		this.usersData = require("../base/User"); // User mongoose model
+		this.membersData = require("../base/Member"); // Member mongoose model
+		this.logs = require("../base/Log"); // Log mongoose model
+		this.dashboard = require("../dashboard/app"); // Dashboard app
+		this.queues = new Collection(); // This collection will be used for the music
+		this.states = {}; // Used for the dashboard
+		this.knownGuilds = [];
+
+		this.databaseCache = {};
+		this.databaseCache.users = new Collection();
+		this.databaseCache.guilds = new Collection();
+		this.databaseCache.members = new Collection();
+
+		this.databaseCache.usersReminds = new Collection(); // members with active reminds
+		this.databaseCache.mutedUsers = new Collection(); // members who are currently muted
+
+		if (this.config.apiKeys.amethyste) {
+			this.AmeAPI = new AmeClient(this.config.apiKeys.amethyste);
+		};
+
+		if (this.config.apiKeys.blagueXYZ) {
+			this.joker = new Joker(this.config.apiKeys.blagueXYZ, {
+				defaultLanguage: "en"
+			});
+		};
+
+		this.player = new Player(this, {
+			leaveOnEmpty: false,
+			enableLive: true
+		});
+
+		this.player
+			.on("trackStart", (message, track) => {
+				message.success("music/play:NOW_PLAYING", {
+					songName: track.title
+				});
+			})
+			.on("playlistStart", (message, queue, playlist, track) => {
+				message.channel.send(this.customEmojis.success+" | "+message.translate("music/play:PLAYING_PLAYLIST", {
+					playlistTitle: playlist.title,
+					playlistEmoji: this.customEmojis.playlist,
+					songName: track.title
+				}));
+			})
+			.on("searchResults", (message, query, tracks) => {
+				if (tracks.length > 10) tracks = tracks.slice(0, 10);
+				const embed = new MessageEmbed()
+					.setDescription(Util.escapeSpoiler(tracks.map((t, i) => `**${++i} -** ${t.title}`).join("\n")))
+					.setFooter(message.translate("music/play:RESULTS_FOOTER"))
+					.setColor(this.config.embed.color);
+				message.channel.send(embed);
+			})
+			.on("searchInvalidResponse", (message, query, tracks, content, collector) => {
+				if (content === "cancel") {
+					collector.stop();
+					return message.success("music/play:RESULTS_CANCEL");
+				};
+
+				message.error("misc:INVALID_NUMBER_RANGE", {
+					min: 1,
+					max: tracks.length
+				});
+			})
+			.on("searchCancel", (message) => {
+				message.error("misc:TIMES_UP");
+			})
+			.on("botDisconnect", (message) => {
+				message.error("music/play:STOP_DISCONNECTED");
+			})
+			.on("noResults", (message) => {
+				message.error("music/play:NO_RESULT");
+			})
+			.on("queueEnd", (message) => {
+				message.success("music/play:QUEUE_ENDED");
+			})
+			.on("playlistAdd", (message, queue, playlist) => {
+				message.success("music/play:ADDED_QUEUE_COUNT", {
+					songCount: playlist.items.length
+				});
+			})
+			.on("trackAdd", (message, queue, track) => {
+				message.success("music/play:ADDED_QUEUE", {
+					songName: track.title
+				});
+			})
+			.on("channelEmpty", () => {
+				// do nothing, leaveOnEmpty is not enabled
+			})
+			.on("error", (error, message) => {
+				switch (error) {
+					case "NotConnected":
+						message.error("music/play:NO_VOICE_CHANNEL");
+					break;
+
+					case "UnableToJoin":
+						message.error("music/play:VOICE_CHANNEL_CONNECT");
+					break;
+
+					case "NotPlaying":
+						message.error("music/play:NOT_PLAYING");
+					break;
+
+					case "LiveVideo":
+						message.error("music/play:LIVE_VIDEO");
+					break;
+
+					default:
+						message.error("music/play:ERR_OCCURRED", {
+							error
+						});
+					break;
+				};
+			});
+
+		this.giveawaysManager = new GiveawaysManager(this, {
+			storage: "./giveaways.json",
+			updateCountdownEvery: 10000,
+			default: {
+				botsCanWin: false,
+				// exemptPermissions: [ "MANAGE_MESSAGES", "ADMINISTRATOR" ],
+				embedColor: "#FF0000",
+				reaction: "🎉"
+			}
+		});
+	};
+
+	get defaultLanguage() {
+		return this.languages.find((language) => language.default).name;
+	};
+
+	translate(key, args, locale) {
+		if (!locale) locale = this.defaultLanguage;
+		const language = this.translations.get(locale);
+		if (!language) throw "Invalid language set in data.";
+		return language(key, args);
+	};
+
+	printDate(date, format, locale) {
+		if (!locale) locale = this.defaultLanguage;
+		const languageData = this.languages.find((language) => language.name === locale || language.aliases.includes(locale));
+		if (!format) format = languageData.defaultMomentFormat;
+		return moment(new Date(date))
+			.locale(languageData.moment)
+			.format(format);
+	};
+
+	convertTime(time, type, noPrefix, locale) {
+		if (!type) time = "to";
+		if (!locale) locale = this.defaultLanguage;
+		const languageData = this.languages.find((language) => language.name === locale || language.aliases.includes(locale));
+		const m = moment(time)
+			.locale(languageData.moment);
+		return (type === "to" ? m.toNow(noPrefix) : m.fromNow(noPrefix));
+	};
+
+	// This function is used to load a command and add it to the collection
+	loadCommand(commandPath, commandName) {
+		try {
+			const props = new (require(`.${commandPath}${path.sep}${commandName}`))(this);
+			this.logger.log(`Loading Command: ${props.help.name}. 👌`, "log");
+			props.conf.location = commandPath;
+			if (props.init) {
+				props.init(this);
+			};
+			this.commands.set(props.help.name, props);
+			props.help.aliases.forEach((alias) => {
+				this.aliases.set(alias, props.help.name);
+			});
+			return false;
+		} catch (e) {
+			return `Unable to load command ${commandName}: ${e}`;
+		};
+	};
+
+	// This function is used to unload a command (you need to load them again)
+	async unloadCommand (commandPath, commandName) {
+		let command;
+		if (this.commands.has(commandName)) {
+			command = this.commands.get(commandName);
+		} else if (this.aliases.has(commandName)) {
+			command = this.commands.get(this.aliases.get(commandName));
+		};
+		if (!command) {
+			return `The command \`${commandName}\` doesn't seem to exist, nor is it an alias. Try again!`;
+		};
+		if (command.shutdown) {
+			await command.shutdown(this);
+		};
+		delete require.cache[require.resolve(`.${commandPath}${path.sep}${commandName}.js`)];
+		return false;
+	};
+
+	// This function is used to find a user data or create it
+	async findOrCreateUser({ id: userID }, isLean) {
+		if (this.databaseCache.users.get(userID)) {
+			return isLean ? this.databaseCache.users.get(userID).toJSON() : this.databaseCache.users.get(userID);
+		} else {
+			let userData = (isLean ? await this.usersData.findOne({ id: userID }).lean() : await this.usersData.findOne({ id: userID }));
+			if (userData) {
+				if (!isLean) this.databaseCache.users.set(userID, userData);
+				return userData;
+			} else {
+				userData = new this.usersData({ id: userID });
+				await userData.save();
+				this.databaseCache.users.set(userID, userData);
+				return isLean ? userData.toJSON() : userData;
+			};
+		};
+	};
+
+	// This function is used to find a member data or create it
+	async findOrCreateMember({ id: memberID, guildID }, isLean) {
+		if (this.databaseCache.members.get(`${memberID}${guildID}`)) {
+			return isLean ? this.databaseCache.members.get(`${memberID}${guildID}`).toJSON() : this.databaseCache.members.get(`${memberID}${guildID}`);
+		} else {
+			let memberData = (isLean ? await this.membersData.findOne({ guildID, id: memberID }).lean() : await this.membersData.findOne({ guildID, id: memberID }));
+			if (memberData) {
+				if (!isLean) this.databaseCache.members.set(`${memberID}${guildID}`, memberData);
+				return memberData;
+			} else {
+				memberData = new this.membersData({ id: memberID, guildID: guildID });
+				await memberData.save();
+				const guild = await this.findOrCreateGuild({ id: guildID });
+				if (guild) {
+					guild.members.push(memberData._id);
+					await guild.save();
+				};
+				this.databaseCache.members.set(`${memberID}${guildID}`, memberData);
+				return isLean ? memberData.toJSON() : memberData;
+			};
+		};
+	};
+
+	// This function is used to find a guild data or create it
+	async findOrCreateGuild({ id: guildID }, isLean) {
+		if (this.databaseCache.guilds.get(guildID)) {
+			return isLean ? this.databaseCache.guilds.get(guildID).toJSON() : this.databaseCache.guilds.get(guildID);
+		} else {
+			let guildData = (isLean ? await this.guildsData.findOne({ id: guildID }).populate("members").lean() : await this.guildsData.findOne({ id: guildID }).populate("members"));
+			if (guildData) {
+				if (!isLean) this.databaseCache.guilds.set(guildID, guildData);
+				return guildData;
+			} else {
+				guildData = new this.guildsData({ id: guildID });
+				await guildData.save();
+				this.databaseCache.guilds.set(guildID, guildData);
+				return isLean ? guildData.toJSON() : guildData;
+			};
+		};
+	};
+
+	// This function is used to resolve a user from a string
+	async resolveUser(search) {
+		let user = null;
+		if (!search || typeof search !== "string") return;
+		// Try ID search
+		if (search.match(/^<@!?(\d+)>$/)) {
+			const id = search.match(/^<@!?(\d+)>$/)[1];
+			user = this.users.fetch(id).catch(() => {});
+			if (user) return user;
+		};
+		// Try username search
+		if (search.match(/^!?(\w+)#(\d+)$/)) {
+			const username = search.match(/^!?(\w+)#(\d+)$/)[0];
+			const discriminator = search.match(/^!?(\w+)#(\d+)$/)[1];
+			user = this.users.find((u) => u.username === username && u.discriminator === discriminator);
+			if (user) return user;
+		};
+		user = await this.users.fetch(search).catch(() => {});
+		return user;
+	};
+
+	async resolveMember(search, guild) {
+		let member = null;
+		if (!search || typeof search !== "string") return;
+		// Try ID search
+		if (search.match(/^<@!?(\d+)>$/)) {
+			const id = search.match(/^<@!?(\d+)>$/)[1];
+			member = await guild.members.fetch(id).catch(() => {});
+			if (member) return member;
+		};
+		// Try username search
+		if (search.match(/^!?(\w+)#(\d+)$/)) {
+			guild = await guild.fetch();
+			member = guild.members.cache.find((m) => m.user.tag === search);
+			if (member) return member;
+		};
+		member = await guild.members.fetch(search).catch(() => {});
+		return member;
+	};
+
+	async resolveRole(search, guild) {
+		let role = null;
+		if (!search || typeof search !== "string") return;
+		// Try ID search
+		if (search.match(/^<@&!?(\d+)>$/)) {
+			const id = search.match(/^<@&!?(\d+)>$/)[1];
+			role = guild.roles.cache.get(id);
+			if (role) return role;
+		};
+		// Try name search
+		role = guild.roles.cache.find((r) => search === r.name);
+		if (role) return role;
+		role = guild.roles.cache.get(search);
+		return role;
+	};
+};
+
+module.exports = Atlanta;

base/Command.js

@@ -0,0 +1,23 @@
+const path = require("path");
+
+module.exports = class Command {
+	constructor(client, {
+		name = null,
+		dirname = false,
+		enabled = true,
+		guildOnly = false,
+		aliases = new Array(),
+		botPermissions = new Array(),
+		memberPermissions = new Array(),
+		nsfw = false,
+		ownerOnly = false,
+		cooldown = 3000
+	})
+
+	{
+		const category = (dirname ? dirname.split(path.sep)[parseInt(dirname.split(path.sep).length - 1, 10)] : "Other");
+		this.client = client;
+		this.conf = { enabled, guildOnly, memberPermissions, botPermissions, nsfw, ownerOnly, cooldown};
+		this.help = { name, category, aliases };
+	}
+};

base/Guild.js

@@ -0,0 +1,68 @@
+const mongoose = require("mongoose"),
+	Schema = mongoose.Schema,
+	config = require("../config.js"),
+	languages = require("../languages/language-meta.json");
+
+module.exports = mongoose.model("Guild", new Schema({
+	/* REQUIRED */
+	id: { type: String }, // Discord ID of the guild
+
+	/* MEMBERSDATA */
+	membersData: { type: Object, default: {} }, // Members data of the guild
+	members: [{ type: Schema.Types.ObjectId, ref: "Member" }],
+
+	/* CONFIGURATION */
+	language: { type: String, default: languages.find((l) => l.default).name }, // Language of the guild
+	prefix: { type: String, default: config.prefix }, // Default or custom prefix of the guild
+	plugins: { type: Object, default: { // Plugins data
+		// Welcome messages
+		welcome: {
+			enabled: false, // Whether the welcome messages are enabled
+			message: null, // The welcome message
+			channel: null, // The channel to send the welcome messages
+			withImage: null // Whether the welcome images are enabled
+		},
+		// Goodbye messages
+		goodbye: {
+			enabled: false, // Whether the goodbye messages are enabled
+			message: null, // The goodbye message
+			channel: null, // The channel to send the goodbye messages
+			withImage: null // Whether the goodbye images are enabled
+		},
+		// Autorole
+		autorole: {
+			enabled: false, // Whether the autorole is enabled
+			role: null // The role to add when a member join the server
+		},
+		// Auto moderation
+		automod: {
+			enabled: false, // Whether the auto moderation is enabled
+			ignored: [] // The channels in which the auto moderation is disabled
+		},
+		// Auto sanctions
+		warnsSanctions: {
+			kick: false, // The number of warns required to kick the user
+			ban: false // The number of warns required to ban the user
+		},
+		// Tickets
+		tickets: {
+			enabled: false, // Whether the tickets system is enabled
+			category: null // The category for the tickets system
+		},
+		suggestions: false, // the channel in which the suggestions will be sent
+		modlogs: false, // the channel in which the moderation logs (mute, kick, ban, etc...) will be sent
+		reports: false, // the channel in which the reports will be sent
+		fortniteshop: false, // the channel in which the fortnite shop image will be sent at 2.05am
+		logs: false // the channel in which the logs (message deleted, etc...) will be sent
+	}},
+	slowmode: { type: Object, default: { // Servers slowmode
+		users: [],
+		channels: []
+	}},
+	casesCount: { type: Number, default: 0 },
+	ignoredChannels: { type: Array, default: [] }, // Channels ignored by the bot
+	customCommands: { type: Array, default: [] }, // Custom commands of the guild
+	commands: { type: Array, default: [] }, // Commands logs
+	autoDeleteModCommands: { type: Boolean, default: false }, // Whether to auto delete moderation commands
+	disabledCategories: { type: Array, default: [] } // Disabled categories
+}));

base/Log.js

@@ -0,0 +1,15 @@
+const mongoose = require("mongoose");
+
+module.exports = mongoose.model("Log", new mongoose.Schema({
+	commandName: { type: String, default: "unknown" },
+	date: { type: Number, default: Date.now() },
+	author: { type: Object, default: {
+		username: "Unknown",
+		discrminator: "0000",
+		id: null
+	}},
+	guild: { type: Object, default: {
+		name: "Unknown",
+		id: null
+	}}
+}));

base/Member.js

@@ -0,0 +1,31 @@
+const mongoose = require("mongoose");
+
+module.exports = mongoose.model("Member", new mongoose.Schema({
+	/* REQUIRED */
+	id: { type: String }, // Discord ID of the user
+	guildID: { type: String }, // ID of the guild to which the member is connected
+
+	/* SERVER ECONOMY */
+	money: { type: Number, default: 0 }, // Money of the user
+	workStreak: { type: Number, default: 0 }, // work streak of the user
+	bankSold: { type: Number, default: 0 }, // Bank sold of the user
+	exp: { type: Number, default: 0 }, // Exp points of the user
+	level: { type: Number, default: 0 }, // Level of the user
+
+	/* STATS */
+	registeredAt: { type: Number, default: Date.now() }, // Registered date of the member
+
+	/* COOLDOWN */
+	cooldowns: { type: Object, default: {
+		work: 0,
+		rob: 0
+	}},
+
+	/* OTHER INFORMATIONS */
+	sanctions: { type: Array, default: [] }, // Array of the member sanctions (mute, ban, kick, etc...)
+	mute: { type: Object, default: { // The member mute infos
+		muted: false,
+		case: null,
+		endDate: null
+	}},
+}));

base/User.js

@@ -0,0 +1,117 @@
+const mongoose = require("mongoose"),
+	Canvas = require("canvas");
+
+const genToken = () => {
+	let token = "";
+	const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwzy0123456789.-_";
+	for (let i = 0; i < 32; i++) {
+		token += characters.charAt(Math.floor(Math.random() * characters.length));
+	};
+	return token;
+};
+
+const userSchema = new mongoose.Schema({
+	/* REQUIRED */
+	id: { type: String }, // Discord ID of the user
+
+	/* ECONOMY (GLOBAL) */
+	rep: { type: Number, default: 0 }, // Reputation points of the user
+	bio: { type: String }, // Biography of the user
+	birthdate: { type: Number }, // Birthdate of the user (the timestamp)
+	lover: { type: String }, // The person with whom the user is in a relationship
+
+	/* STATS */
+	registeredAt: { type: Number, default: Date.now() }, // Registered date of the user
+
+	/* ACHIEVEMENTS */
+	achievements: { type: Object, default: {
+		married: {
+			achieved: false,
+			progress: {
+				now: 0,
+				total: 1
+			}
+		},
+		work: {
+			achieved: false,
+			progress: {
+				now: 0,
+				total: 10
+			}
+		},
+		firstCommand: {
+			achieved: false,
+			progress: {
+				now: 0,
+				total: 1
+			}
+		},
+		slots: {
+			achieved: false,
+			progress: {
+				now: 0,
+				total: 3
+			}
+		},
+		tip: {
+			achieved: false,
+			progress: {
+				now: 0,
+				total: 1
+			}
+		},
+		rep: {
+			achieved: false,
+			progress: {
+				now: 0,
+				total: 20
+			},
+		},
+		invite: {
+			achieved: false,
+			progress: {
+				now: 0,
+				total: 1
+			}
+		}
+	}},
+
+	/* COOLDOWN */
+	cooldowns: { type: Object, default: {
+		rep: 0
+	}},
+
+	/* OTHER INFORMATIONS */
+	afk: { type: String, default: null }, // Whether the member is AFK
+	reminds: { type: Array, default: [] }, // the reminds of the user
+	logged: { type: Boolean, default: false }, // if the user is logged to the dashboard
+	apiToken: { type: String, default: genToken() } // the api token of the user
+});
+
+userSchema.method("genApiToken", async function() {
+	this.apiToken = genToken();
+	await this.save();
+	return this.apiToken;
+});
+
+userSchema.method("getAchievements", async function() {
+	const canvas = Canvas.createCanvas(1800, 250),
+		ctx = canvas.getContext("2d");
+	const images = [
+		await Canvas.loadImage(`./assets/img/achievements/achievement${this.achievements.work.achieved ? "_colored" : ""}1.png`),
+		await Canvas.loadImage(`./assets/img/achievements/achievement${this.achievements.firstCommand.achieved ? "_colored" : ""}2.png`),
+		await Canvas.loadImage(`./assets/img/achievements/achievement${this.achievements.married.achieved ? "_colored" : ""}3.png`),
+		await Canvas.loadImage(`./assets/img/achievements/achievement${this.achievements.slots.achieved ? "_colored" : ""}4.png`),
+		await Canvas.loadImage(`./assets/img/achievements/achievement${this.achievements.tip.achieved ? "_colored" : ""}5.png`),
+		await Canvas.loadImage(`./assets/img/achievements/achievement${this.achievements.rep.achieved ? "_colored" : ""}6.png`),
+		await Canvas.loadImage(`./assets/img/achievements/achievement${this.achievements.invite.achieved ? "_colored" : ""}7.png`)
+	];
+	let dim = 0;
+	for(let i = 0; i < images.length; i++) {
+		await ctx.drawImage(images[i], dim, 10, 350, 200);
+		dim += 200;
+	};
+	return canvas.toBuffer();
+});
+
+module.exports = mongoose.model("User", userSchema);

commands/Administration/addcommand.js

@@ -0,0 +1,39 @@
+const Command = require("../../base/Command.js");
+
+class Addcommand extends Command {
+	constructor (client) {
+		super(client, {
+			name: "addcommand",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "custom-command" ],
+			memberPermissions: [ "MANAGE_GUILD" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		if (!args[0]) return message.error("administration/addcommand:MISSING_NAME");
+
+		const name = args[0].split("\n")[0];
+
+		if (this.client.commands.get(name) || this.client.aliases.get(name) || data.guild.customCommands.find((c) => c.name === name)) return message.error("administration/addcommand:COMMAND_ALREADY_EXISTS");
+
+		const answer = (args[0].split("\n")[1] || "") + args.slice(1).join(" ");
+		if (!answer) return message.error("administration/addcommand:MISSING_ANSWER");
+
+		data.guild.customCommands.push({
+			name: name.toLowerCase(),
+			answer: answer
+		});
+		data.guild.save();
+
+		message.success("administration/addcommand:SUCCESS", { commandName: name, prefix: data.guild.prefix });
+	}
+};
+
+module.exports = Addcommand;

commands/Administration/addemoji.js

@@ -0,0 +1,38 @@
+const Command = require("../../base/Command.js");
+
+class Addemoji extends Command {
+	constructor (client) {
+		super(client, {
+			name: "addemoji",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [],
+			memberPermissions: [ "MANAGE_GUILD" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 5000
+		});
+	}
+
+	async run (message, args) {
+		const URL = args[0];
+		if (!URL) return message.error("administration/addemoji:MISSING_URL");
+
+		const name = args[1] ? args[1].replace(/[^a-z0-9]/gi, "") : null;
+		if (!name) return message.error("administration/addemoji:MISSING_NAME");
+		if (name.length < 2 || name > 32) return message.error("administration/addemoji:INVALID_NAME");
+
+		message.guild.emojis
+			.create(URL, name)
+			.then(emoji => {
+				message.success("administration/addemoji:SUCCESS", { emojiName: emoji.name });
+			})
+			.catch(() => {
+				message.error("administration/addemoji:ERROR", { emojiName: name });
+			});
+	}
+};
+
+module.exports = Addemoji;

commands/Administration/automod.js

@@ -0,0 +1,45 @@
+const Command = require("../../base/Command.js");
+
+class Automod extends Command {
+	constructor (client) {
+		super(client, {
+			name: "automod",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [],
+			memberPermissions: [ "MANAGE_GUILD" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 5000
+		});
+	}
+
+	async run (message, args,data) {
+		const status = args[0];
+		if (!status || (status !== "on" && status !== "off")) return message.error("administration/automod:MISSING_STATUS");
+
+		if (status === "on") {
+			data.guild.plugins.automod = { enabled: true, ignored: [] };
+			data.guild.markModified("plugins.automod");
+			data.guild.save();
+			message.success("administration/automod:ENABLED", { prefix: data.guild.prefix });
+		} else if (status === "off") {
+			if (message.mentions.channels.filter((ch) => ch.type === "text" && ch.guild.id === message.guild.id).first()) {
+				const channel = message.mentions.channels.first();
+				data.guild.plugins.automod.ignored.push(channel);
+				data.guild.markModified("plugins.automod");
+				data.guild.save();
+				message.success("administration/automod:DISABLED_CHANNEL", { channel: channel.toString() });
+			} else {
+				data.guild.plugins.automod = { enabled: false, ignored: [] };
+				data.guild.markModified("plugins.automod");
+				data.guild.save();
+				message.success("administration/automod:DISABLED");
+			};
+		};
+	}
+};
+
+module.exports = Automod;

commands/Administration/autorole.js

@@ -0,0 +1,56 @@
+const Command = require("../../base/Command.js"),
+	Resolvers = require("../../helpers/resolvers");
+
+class Autorole extends Command {
+	constructor (client) {
+		super(client, {
+			name: "autorole",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "ar" ],
+			memberPermissions: [ "MANAGE_GUILD" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 5000
+		});
+	}
+
+	async run (message, args, data) {
+		const status = args[0];
+		if (status !== "on" && status !== "off") return message.error("administration/autorole:MISSING_STATUS");
+
+		if (status === "on") {
+			const role = await Resolvers.resolveRole({
+				message,
+				search: args.slice(1).join(" ")
+			});
+			if (!role) return message.error("administration/autorole:MISSING_ROLE");
+
+			data.guild.plugins.autorole = {
+				enabled: true,
+				role: role.id
+			};
+			data.guild.markModified("plugins.autorole");
+			await data.guild.save();
+
+			message.success("administration/autorole:SUCCESS_ENABLED", {
+				roleName: role.name
+			});
+		} else if (status === "off") {
+			if (!data.guild.plugins.autorole.enabled) return message.success("administration/autorole:ALREADY_DISABLED", { prefix: data.guild.prefix });
+
+			data.guild.plugins.autorole = {
+				enabled: false,
+				role: null
+			};
+			data.guild.markModified("plugins.autorole");
+			await data.guild.save();
+
+			message.success("administration/autorole:SUCCESS_DISABLED", { prefix: data.guild.prefix });
+		};
+	}
+};
+
+module.exports = Autorole;

commands/Administration/backup.js

@@ -0,0 +1,99 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js"),
+	backup = require("discord-backup"),
+	Sentry = require("@sentry/node");
+
+class Backup extends Command {
+	constructor (client) {
+		super(client, {
+			name: "backup",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "sauvegarde" ],
+			memberPermissions: [ "MANAGE_GUILD" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS", "ADMINISTRATOR" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 30000
+		});
+	}
+
+	async run (message, args, data) {
+		const status = args[0];
+		if (!status) return message.error("administration/backup:MISSING_STATUS");
+
+		if (status === "create") {
+			const m = await message.sendT("misc:PLEASE_WAIT", null, { prefixEmoji: "loading" });
+			backup.create(message.guild).then((backup) => {
+				m.delete();
+				message.success("administration/backup:SUCCESS_PUBLIC");
+				message.author.send(message.translate("administration/backup:SUCCESS_PRIVATE", { backupID: backup.id })).catch(() => {
+					backup.remove(backup.id);
+					message.error("misc:CANNOT_DM");
+				});
+			}).catch((err) => {
+				Sentry.captureException(err);
+				return message.error("misc:ERR_OCCURRED");
+			});
+		} else if (status === "load"){
+			const backupID = args[1];
+			if (!backupID) return message.error("administration/backup:MISSING_BACKUP_ID");
+
+			backup.fetch(backupID).then(async () => {
+				message.sendT("administration/backup:CONFIRMATION");
+				await message.channel.awaitMessages(m => (m.author.id === message.author.id) && (m.content === "confirm"), {
+					max: 1,
+					time: 20000,
+					errors: ["time"]
+				}).catch(() => {
+					// if the author of the commands does not confirm the backup loading
+					return message.error("administration/backup:TIMES_UP");
+				});
+				// When the author of the command has confirmed that he wants to load the backup on his server
+				message.author.send(message.translate("administration/backup:START_LOADING"));
+				// Load the backup
+				backup.load(backupID, message.guild).then(() => {
+					// When the backup is loaded, delete them from the server
+					backup.remove(backupID);
+					message.author.send(message.translate("administration/backup:LOAD_SUCCESS"));
+				}).catch((err) => {
+					Sentry.captureException(err);
+					// If an error occurenced
+					return message.error("misc:ERR_OCCURRED");
+				});
+			}).catch(() => {
+				// if the backup wasn't found
+				return message.error("administration/backup:NO_BACKUP_FOUND", {
+					backupID
+				});
+			});
+		} else if (status === "info"){
+			const backupID = args[1];
+			if (!backupID) return message.error("administration/backup:MISSING_BACKUP_ID");
+
+			backup.fetch(backupID).then(async (backupInfos) => {
+				const embed = new Discord.MessageEmbed()
+					.setAuthor(message.translate("administration/backup:TITLE_INFOS"))
+					// Display the backup ID
+					.addField(message.translate("administration/backup:TITLE_ID"), backupInfos.id, true)
+					// Displays the server from which this backup comes
+					.addField(message.translate("administration/backup:TITLE_SERVER_ID"), backupInfos.data.guildID, true)
+					// Display the size (in mb) of the backup
+					.addField(message.translate("administration/backup:TITLE_SIZE"), backupInfos.size+" mb", true)
+					// Display when the backup was created
+					.addField(message.translate("administration/backup:TITLE_CREATED_AT"), message.printDate(new Date(backupInfos.data.createdTimestamp)), true)
+					.setColor(data.config.embed.color)
+					.setFooter(data.config.embed.footer);
+				message.channel.send(embed);
+			}).catch(() => {
+				// if the backup wasn't found
+				return message.error("administration/backup:NO_BACKUP_FOUND", { backupID });
+			});
+		} else {
+			return message.error("administration/backup:MISSING_STATUS");
+		};
+	}
+};
+
+module.exports = Backup;

commands/Administration/configuration.js

@@ -0,0 +1,89 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js");
+
+class Configuration extends Command {
+	constructor (client) {
+		super(client, {
+			name: "configuration",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "conf", "config" ],
+			memberPermissions: [ "MANAGE_GUILD" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		const guildData = data.guild;
+
+		const embed = new Discord.MessageEmbed()
+			.setAuthor(message.guild.name, message.guild.iconURL())
+			.setColor(this.client.config.embed.color)
+			.setFooter(this.client.config.embed.footer);
+
+		// Guild prefix
+		embed.addField(message.translate("administration/configuration:PREFIX_TITLE"), guildData.prefix);
+
+		// Ignored channels
+		embed.addField(message.translate("administration/configuration:IGNORED_CHANNELS_TITLE"), (guildData.ignoredChannels.length > 0) ? guildData.ignoredChannels.map((ch) => `<#${ch}>`).join(", ") : message.translate("administration/configuration:NO_IGNORED_CHANNELS"));
+
+		// Autorole plugin
+		embed.addField(message.translate("administration/configuration:AUTOROLE_TITLE"), (guildData.plugins.autorole.enabled) ? message.translate("administration/configuration:AUTOROLE_CONTENT", {
+			roleName: `<@&${guildData.plugins.autorole.role}>`
+		}) : message.translate("administration/configuration:AUTOROLE_DISABLED"));
+
+		// Welcome plugin
+		embed.addField(message.translate("administration/configuration:WELCOME_TITLE"), (guildData.plugins.welcome.enabled) ? message.translate("administration/configuration:WELCOME_CONTENT", {
+			channel: `<#${guildData.plugins.welcome.channel}>`,
+			withImage: guildData.plugins.welcome.withImage ? message.translate("common:YES") : message.translate("common:NO")
+		}) : message.translate("administration/configuration:WELCOME_DISABLED"));
+
+		// Goodbye plugin
+		embed.addField(message.translate("administration/configuration:GOODBYE_TITLE"), (guildData.plugins.goodbye.enabled) ? message.translate("administration/configuration:GOODBYE_CONTENT", {
+			channel: `<#${guildData.plugins.goodbye.channelID}>`,
+			withImage: guildData.plugins.goodbye.withImage ? message.translate("common:YES") : message.translate("common:NO")
+		}) : message.translate("administration/configuration:GOODBYE_DISABLED"));
+
+		// Special channels
+		embed.addField(message.translate("administration/configuration:SPECIAL_CHANNELS"),
+			message.translate("administration/configuration:MODLOGS", {
+				channel: guildData.plugins.modlogs ? `<#${guildData.plugins.modlogs}>` : message.translate("common:NOT_DEFINED")
+			}) + "\n" +
+			message.translate("administration/configuration:FORTNITESHOP", {
+				channel: guildData.plugins.fortniteshop ? `<#${guildData.plugins.fortniteshop}>` : message.translate("common:NOT_DEFINED")
+			}) + "\n" +
+			message.translate("administration/configuration:SUGGESTIONS", {
+				channel: guildData.plugins.suggestions ? `<#${guildData.plugins.suggestions}>` : message.translate("common:NOT_DEFINED")
+			}) + "\n" +
+			message.translate("administration/configuration:REPORTS", {
+				channel: guildData.plugins.reports ? `<#${guildData.plugins.reports}>` : message.translate("common:NOT_DEFINED")
+			})
+		);
+
+		// Auto sanctions
+		embed.addField(message.translate("administration/configuration:AUTO_SANCTIONS"), ((guildData.plugins.warnsSanctions.kick) ? message.translate("administration/configuration:KICK_CONTENT", {
+			count: guildData.plugins.warnsSanctions.kick
+		}) : message.translate("administration/configuration:KICK_NOT_DEFINED")) + "\n" + ((guildData.plugins.warnsSanctions.ban) ? message.translate("administration/configuration:BAN_CONTENT", {
+			count: guildData.plugins.warnsSanctions.ban
+		}) : message.translate("administration/configuration:BAN_NOT_DEFINED")));
+
+		// Automod plugin
+		embed.addField(message.translate("administration/configuration:AUTOMOD_TITLE"), (guildData.plugins.automod.enabled) ? message.translate("administration/configuration:AUTOMOD_CONTENT", {
+			channels: guildData.plugins.automod.ignored.map((ch) => `<#${ch}>`)
+		}) : message.translate("administration/configuration:AUTOMOD_DISABLED"));
+
+		// Auto-delete mod commands
+		embed.addField(message.translate("administration/configuration:AUTODELETEMOD"), (!message.guild.autoDeleteModCommands) ? message.translate("administration/configuration:AUTODELETEMOD_ENABLED") : message.translate("administration/configuration:AUTODELETEMOD_DISABLED"));
+
+		// Dashboard link
+		embed.addField(message.translate("administration/configuration:DASHBOARD_TITLE"), `[${message.translate("administration/configuration:DASHBOARD_CONTENT")}](${this.client.config.dashboard.baseURL})`);
+
+		message.channel.send(embed);
+	}
+};
+
+module.exports = Configuration;

commands/Administration/delcommand.js

@@ -0,0 +1,32 @@
+const Command = require("../../base/Command.js");
+
+class Delcommand extends Command {
+	constructor (client) {
+		super(client, {
+			name: "delcommand",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [],
+			memberPermissions: [ "MANAGE_GUILD" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		const name = args[0];
+		if (!name) return message.error("administration/delcommand:MISSING_NAME");
+
+		if (!data.guild.customCommands.find((c) => c.name === name)) return message.error("administration/delcommand:UNKNOWN_COMMAND", { commandName: name });
+
+		data.guild.customCommands = data.guild.customCommands.filter((c) => c.name !== name);
+		data.guild.save();
+
+		message.success("administration/delcommand:SUCCESS", { commandName: name });
+	}
+};
+
+module.exports = Delcommand;

commands/Administration/deletemod.js

@@ -0,0 +1,35 @@
+const Command = require("../../base/Command.js");
+
+class Deletemod extends Command {
+	constructor (client) {
+		super(client, {
+			name: "deletemod",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "autodeletemodcommands" ],
+			memberPermissions: [ "MANAGE_MESSAGES" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		const status = args[0];
+		if (!status || status !== "on" && status !== "off") return message.error("administration/deletemod:MISSING_STATUS");
+
+		if (status === "on") {
+			data.guild.autoDeleteModCommands = true;
+			data.guild.save();
+			message.success("administration/deletemod:ENABLED");
+		} else {
+			data.guild.autoDeleteModCommands = false;
+			data.guild.save();
+			message.success("administration/deletemod:DISABLED");
+		};
+	}
+};
+
+module.exports = Deletemod;

commands/Administration/goodbye.js

@@ -0,0 +1,101 @@
+const Command = require("../../base/Command.js"),
+	Resolvers = require("../../helpers/resolvers");
+
+class Goodbye extends Command {
+	constructor (client) {
+		super(client, {
+			name: "goodbye",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "au-revoir" ],
+			memberPermissions: [ "MANAGE_GUILD" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		if (args[0] === "test" && data.guild.plugins.goodbye.enabled) {
+			this.client.emit("guildMemberRemove", message.member);
+			return message.success("administration/goodbye:TEST_SUCCESS");
+		};
+
+		if ((!args[0] || !["edit", "off"].includes(args[0])) && data.guild.plugins.goodbye.enabled) return message.error("administration/goodbye:MISSING_STATUS");
+
+		if (args[0] === "off") {
+			data.guild.plugins.goodbye = {
+				enabled: false,
+				message: null,
+				channelID: null,
+				withImage: null
+			};
+			data.guild.markModified("plugins.goodbye");
+			data.guild.save();
+			return message.error("administration/goodbye:DISABLED", { prefix: data.guild.prefix });
+		} else {
+			const goodbye = {
+				enabled: true,
+				channel: null,
+				message: null,
+				withImage: null,
+			};
+
+			message.sendT("administration/goodbye:FORM_1", { author: message.author.toString() });
+			const collector = message.channel.createMessageCollector(m => m.author.id === message.author.id, {
+				time: 120000 // 2 minutes
+			});
+
+			collector.on("collect", async msg => {
+				// If the message is filled, it means the user sent yes or no for the image
+				if (goodbye.message) {
+					if (msg.content.toLowerCase() === message.translate("common:YES").toLowerCase()) {
+						goodbye.withImage = true;
+					} else if (msg.content.toLowerCase() === message.translate("common:NO").toLowerCase()) {
+						goodbye.withImage = false;
+					} else {
+						return message.error("misc:INVALID_YES_NO");
+					};
+					data.guild.plugins.goodbye = goodbye;
+					data.guild.markModified("plugins.goodbye");
+					await data.guild.save();
+					message.sendT("administration/goodbye:FORM_SUCCESS", { prefix: data.guild.prefix, channel: `<#${goodbye.channel}>` });
+					return collector.stop();
+				};
+
+				// If the channel is filled and the message is not, it means the user sent the message
+				if (goodbye.channel && !goodbye.message) {
+					if (msg.content.length < 1800) {
+						goodbye.message = msg.content;
+						return message.sendT("administration/goodbye:FORM_3");
+					};
+					return message.error("administration/goodbye:MAX_CHARACT");
+				};
+
+				// If the channel is not filled, it means the user sent it
+				if (!goodbye.channel) {
+					const channel = await Resolvers.resolveChannel({
+						message: msg,
+						channelType: "text"
+					});
+					if (!channel) return message.error("misc:INVALID_CHANNEL");
+
+					goodbye.channel = channel.id;
+					message.sendT("administration/goodbye:FORM_2", {
+						channel: channel.toString(),
+						author: msg.author.tag,
+						memberCount: msg.guild.memberCount
+					});
+				};
+			});
+
+			collector.on("end", (_, reason) => {
+				if (reason === "time") return message.error("misc:TIMEOUT");
+			});
+		};
+	}
+};
+
+module.exports = Goodbye;

commands/Administration/ignore.js

@@ -0,0 +1,37 @@
+const Command = require("../../base/Command.js");
+
+class Ignore extends Command {
+	constructor (client) {
+		super(client, {
+			name: "ignore",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "disableChannel" ],
+			memberPermissions: [ "MANAGE_GUILD" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		const channel = message.mentions.channels.filter((ch) => ch.type === "text" && ch.guild.id === message.guild.id).first();
+		if (!channel) return message.error("misc:INVALID_CHANNEL");
+
+		const ignored = data.guild.ignoredChannels.includes(channel.id);
+
+		if (ignored) {
+			data.guild.ignoredChannels = data.guild.ignoredChannels.filter((ch) => ch !== channel.id);
+			data.guild.save();
+			return message.success("administration/ignore:ALLOWED", { channel: channel.toString() });
+		} else if (!ignored) {
+			data.guild.ignoredChannels.push(channel.id);
+			data.guild.save();
+			return message.success("administration/ignore:IGNORED", { channel: channel.toString() });
+		};
+	}
+};
+
+module.exports = Ignore;

commands/Administration/setfortniteshop.js

@@ -0,0 +1,66 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js"),
+	Canvas = require("discord-canvas");
+
+class Setfortniteshop extends Command {
+	constructor(client) {
+		super(client, {
+			name: "setfortniteshop",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: ["setfnshop"],
+			memberPermissions: ["MANAGE_GUILD"],
+			botPermissions: ["SEND_MESSAGES", "EMBED_LINKS"],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 5000
+		});
+	}
+
+	async run(message, args, data) {
+		if (!data.config.apiKeys.fortniteFNBR || data.config.apiKeys.fortniteFNBR.length === "") return message.error("misc:COMMAND_DISABLED");
+
+		if (data.guild.plugins.fortniteshop && !message.mentions.channels.first() || message.mentions.channels.first() && data.guild.plugins.fortniteshop === message.mentions.channels.first().id) {
+			data.guild.plugins.fortniteshop = false;
+			data.guild.markModified("plugins.fortniteshop");
+			data.guild.save();
+			return message.success("administration/setfortniteshop:DISABLED");
+		};
+
+		const channel = message.mentions.channels.first() || message.channel;
+		data.guild.plugins.fortniteshop = channel.id;
+		data.guild.markModified("plugins.fortniteshop");
+		data.guild.save();
+
+		message.success("administration/setfortniteshop:ENABLED", { channel: channel.toString() });
+
+		const momentName = this.client.languages.find((language) => language.name === data.guild.language || language.aliases.includes(data.guild.language)).moment;
+		const shop = new Canvas.FortniteShop();
+		const image = await shop
+			.setToken(data.config.apiKeys.fortniteFNBR)
+			.setText("header", message.translate("general/fortniteshop:HEADER"))
+			.setText("daily", message.translate("general/fortniteshop:DAILY"))
+			.setText("featured", message.translate("general/fortniteshop:FEATURED"))
+			.setText("date", message.translate("general/fortniteshop:DATE", {
+				skipInterpolation: true
+			}).replace("{{date}}", "{date}"))
+			.setText("footer", message.translate("general/fortniteshop:FOOTER"))
+			.lang(momentName)
+			.toAttachment();
+		const attachment = new Discord.MessageAttachment(image, "shop.png");
+
+		const embed = new Discord.MessageEmbed()
+			.setAuthor(this.client.translate("general/fortniteshop:DATE", { date: this.client.printDate(new Date(Date.now()), null, message.guild.data.language) }, message.guild.data.language), this.client.user.displayAvatarURL({ size: 512, dynamic: true, format: 'png' }))
+			.attachFiles(attachment)
+			.setImage("attachment://shop.png")
+			.setColor(this.client.config.embed.color)
+			.setFooter(this.client.config.embed.footer);
+		const msg = await channel.send(embed);
+		await msg.react("😍");
+		await msg.react("😐");
+		await msg.react("😭");
+	}
+};
+
+module.exports = Setfortniteshop;

commands/Administration/setlang.js

@@ -0,0 +1,31 @@
+const Command = require("../../base/Command.js");
+
+class Setlang extends Command {
+	constructor (client) {
+		super(client, {
+			name: "setlang",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [],
+			memberPermissions: [ "MANAGE_GUILD" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		const language = this.client.languages.find((l) => l.name === args[0] || l.aliases.includes(args[0]));
+
+		if (!args[0] || !language) return message.error("administration/setlang:MISSING_LANG", { list: this.client.languages.map((l) => "`"+l.name+"`").join(", ") });
+
+		data.guild.language = language.name;
+		await data.guild.save();
+
+		return message.sendT("administration/setlang:SUCCESS", { lang: language.nativeName });
+	}
+};
+
+module.exports = Setlang;

commands/Administration/setmodlogs.js

@@ -0,0 +1,39 @@
+const Command = require("../../base/Command.js"),
+	Resolvers = require("../../helpers/resolvers");
+
+class Setmodlogs extends Command {
+	constructor (client) {
+		super(client, {
+			name: "setmodlogs",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "setmodlogs" ],
+			memberPermissions: [ "MANAGE_GUILD" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		const areModLogsEnabled = Boolean(data.guild.plugins.modlogs);
+		const sentChannel = await Resolvers.resolveChannel({ message, search: args.join(" "), channelType: "text" });
+
+		if (!sentChannel && areModLogsEnabled) {
+			data.guild.plugins.modlogs = null;
+			data.guild.markModified("plugins.modlogs");
+			await data.guild.save();
+			return message.success("administration/setmodlogs:SUCCESS_DISABLED");
+		} else {
+			const channel = sentChannel || message.channel;
+			data.guild.plugins.modlogs = channel.id;
+			data.guild.markModified("plugins.modlogs");
+			await data.guild.save();
+			return message.success("administration/setmodlogs:SUCCESS_ENABLED", { channel: channel.toString() });
+		};
+	}
+};
+
+module.exports = Setmodlogs;

commands/Administration/setprefix.js

@@ -0,0 +1,32 @@
+const Command = require("../../base/Command.js");
+
+class Setprefix extends Command {
+	constructor (client) {
+		super(client, {
+			name: "setprefix",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [],
+			memberPermissions: [ "MANAGE_GUILD" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		const prefix = args[0];
+		if (!prefix) return message.error("administration/setprefix:MISSING_PREFIX");
+		if (prefix.length > 5) return message.error("administration/setprefix:TOO_LONG");
+
+		data.guild.prefix = prefix;
+		data.guild.save();
+
+		// Sucess
+		return message.success("administration/setprefix:SUCCESS", { prefix });
+	}
+};
+
+module.exports = Setprefix;

commands/Administration/setreports.js

@@ -0,0 +1,39 @@
+const Command = require("../../base/Command.js"),
+	Resolvers = require("../../helpers/resolvers");
+
+class Setreports extends Command {
+	constructor (client) {
+		super(client, {
+			name: "setreports",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "setreport"],
+			memberPermissions: [ "MANAGE_GUILD" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		const areReportsEnabled = Boolean(data.guild.plugins.reports);
+		const sentChannel = await Resolvers.resolveChannel({ message, search: args.join(" "), channelType: "text" });
+
+		if (!sentChannel && areReportsEnabled) {
+			data.guild.plugins.reports = null;
+			data.guild.markModified("plugins.reports");
+			await data.guild.save();
+			return message.success("administration/setreports:SUCCESS_DISABLED");
+		} else {
+			const channel = sentChannel || message.channel;
+			data.guild.plugins.reports = channel.id;
+			data.guild.markModified("plugins.reports");
+			await data.guild.save();
+			return message.success("administration/setreports:SUCCESS_ENABLED", { channel: channel.toString() });
+		};
+	}
+};
+
+module.exports = Setreports;

commands/Administration/setsuggests.js

@@ -0,0 +1,39 @@
+const Command = require("../../base/Command.js"),
+	Resolvers = require("../../helpers/resolvers");
+
+class Setsuggests extends Command {
+	constructor (client) {
+		super(client, {
+			name: "setsuggests",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "setsuggest", "setsuggestions", "setsuggestion" ],
+			memberPermissions: [ "MANAGE_GUILD" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		const areSuggestsEnabled = Boolean(data.guild.plugins.suggestions);
+		const sentChannel = await Resolvers.resolveChannel({ message, search: args.join(" "), channelType: "text" });
+
+		if (!sentChannel && areSuggestsEnabled) {
+			data.guild.plugins.suggestions = null;
+			data.guild.markModified("plugins.suggestions");
+			await data.guild.save();
+			return message.success("administration/setsuggests:SUCCESS_DISABLED");
+		} else {
+			const channel = sentChannel || message.channel;
+			data.guild.plugins.suggestions = channel.id;
+			data.guild.markModified("plugins.suggestions");
+			await data.guild.save();
+			return message.success("administration/setsuggests:SUCCESS_ENABLED", { channel: channel.toString() });
+		};
+	}
+};
+
+module.exports = Setsuggests;

commands/Administration/slowmode.js

@@ -0,0 +1,47 @@
+const Command = require("../../base/Command.js"),
+	ms = require("ms");
+
+class Slowmode extends Command {
+	constructor (client) {
+		super(client, {
+			name: "slowmode",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "slowmotion" ],
+			memberPermissions: [ "MANAGE_GUILD" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		const channel = message.mentions.channels.filter((ch) => ch.type === "text" && ch.guild.id === message.guild.id).first();
+		if (!channel) return message.error("misc:INVALID_CHANNEL");
+
+		const time = args[1];
+		if (!time) {
+			if (!data.guild.slowmode.channels.find((ch) => ch.id === channel.id)) return message.error("misc:INVALID_TIME");
+
+			data.guild.slowmode.channels = data.guild.slowmode.channels.filter((ch) => ch.id !== channel.id);
+			data.guild.markModified("slowmode.channels");
+			data.guild.save();
+			message.success("administration/slowmode:DISABLED", { prefix: data.guild.prefix, channel: `#${channel.name}` });
+		} else {
+			if (isNaN(ms(time))) return message.error("misc:INVALID_TIME");
+			if (data.guild.slowmode.channels.find((ch) => ch.id === channel.id)) data.guild.slowmode.channels = data.guild.slowmode.channels.filter((ch) => ch.id !== channel.id);
+
+			data.guild.slowmode.channels.push({
+				id: channel.id,
+				time: ms(time)
+			});
+			data.guild.markModified("slowmode.channels");
+			data.guild.save();
+			message.success("administration/slowmode:ENABLED", { prefix: data.guild.prefix, channel: `#${channel.name}`, time: this.client.functions.convertTime(message.guild, ms(time)) });
+		};
+	}
+};
+
+module.exports = Slowmode;

commands/Administration/welcome.js

@@ -0,0 +1,100 @@
+const Command = require("../../base/Command.js"),
+	Resolvers = require("../../helpers/resolvers");
+
+class Welcome extends Command {
+	constructor (client) {
+		super(client, {
+			name: "welcome",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "bienvenue" ],
+			memberPermissions: [ "MANAGE_GUILD" ],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		if (args[0] === "test" && data.guild.plugins.welcome.enabled) {
+			this.client.emit("guildMemberAdd", message.member);
+			return message.success("administration/welcome:TEST_SUCCESS");
+		};
+
+		if ((!args[0] || !["edit", "off"].includes(args[0])) && data.guild.plugins.welcome.enabled) return message.error("administration/welcome:MISSING_STATUS");
+
+		if (args[0] === "off") {
+			data.guild.plugins.welcome = {
+				enabled: false,
+				message: null,
+				channelID: null,
+				withImage: null
+			};
+			data.guild.markModified("plugins.welcome");
+			data.guild.save();
+			return message.error("administration/welcome:DISABLED", { prefix: data.guild.prefix });
+		} else {
+			const welcome = {
+				enabled: true,
+				channel: null,
+				message: null,
+				withImage: null,
+			};
+
+			message.sendT("administration/welcome:FORM_1", { author: message.author.toString() });
+			const collector = message.channel.createMessageCollector(m => m.author.id === message.author.id, {
+				time: 120000 // 2 minutes
+			});
+
+			collector.on("collect", async msg => {
+				// If the message is filled, it means the user sent yes or no for the image
+				if (welcome.message) {
+					if (msg.content.toLowerCase() === message.translate("common:YES").toLowerCase()) {
+						welcome.withImage = true;
+					} else if (msg.content.toLowerCase() === message.translate("common:NO").toLowerCase()) {
+						welcome.withImage = false;
+					} else {
+						return message.error("misc:INVALID_YES_NO");
+					};
+					data.guild.plugins.welcome = welcome;
+					data.guild.markModified("plugins.welcome");
+					await data.guild.save();
+					message.sendT("administration/welcome:FORM_SUCCESS", { prefix: data.guild.prefix, channel: `<#${welcome.channel}>` });
+					return collector.stop();
+				};
+
+				// If the channel is filled and the message is not, it means the user sent the message
+				if (welcome.channel && !welcome.message) {
+					if (msg.content.length < 1800) {
+						welcome.message = msg.content;
+						return message.sendT("administration/welcome:FORM_3");
+					};
+					return message.error("administration/goodbye:MAX_CHARACT");
+				};
+
+				// If the channel is not filled, it means the user sent it
+				if (!welcome.channel) {
+					const channel = await Resolvers.resolveChannel({ message: msg, channelType: "text" });
+					if (!channel) return message.error("misc:INVALID_CHANNEL");
+
+					welcome.channel = channel.id;
+					message.sendT("administration/welcome:FORM_2", {
+						guildName: message.guild.name,
+						author: msg.author.tag,
+						memberCount: msg.guild.memberCount
+					});
+				};
+			});
+
+			collector.on("end", (_, reason) => {
+				if (reason === "time") {
+					return message.error("misc:TIMEOUT");
+				};
+			});
+		};
+	}
+};
+
+module.exports = Welcome;

commands/Economy/achievements.js

@@ -0,0 +1,66 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js");
+
+class Achievements extends Command {
+	constructor (client) {
+		super(client, {
+			name: "achievements",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "ac" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 1000
+		});
+	}
+
+	async run (message, args, data) {
+		const embed = new Discord.MessageEmbed()
+			.setAuthor(message.translate("economy/achievements:TITLE"))
+			.setColor(data.config.embed.color)
+			.setFooter(data.config.embed.footer);
+
+		embed.addField(message.translate("economy/achievements:SEND_CMD"), message.translate("economy/achievements:PROGRESS", {
+			now: data.userData.achievements.firstCommand.progress.now,
+			total: data.userData.achievements.firstCommand.progress.total,
+			percent: Math.round(100 * (data.userData.achievements.firstCommand.progress.now/data.userData.achievements.firstCommand.progress.total))
+		}));
+		embed.addField(message.translate("economy/achievements:CLAIM_SALARY"), message.translate("economy/achievements:PROGRESS", {
+			now: data.userData.achievements.work.progress.now,
+			total: data.userData.achievements.work.progress.total,
+			percent: Math.round(100 * (data.userData.achievements.work.progress.now/data.userData.achievements.work.progress.total))
+		}));
+		embed.addField(message.translate("economy/achievements:MARRY"), message.translate("economy/achievements:PROGRESS", {
+			now: data.userData.achievements.married.progress.now,
+			total: data.userData.achievements.married.progress.total,
+			percent: Math.round(100 * (data.userData.achievements.married.progress.now/data.userData.achievements.married.progress.total))
+		}));
+		embed.addField(message.translate("economy/achievements:SLOTS"), message.translate("economy/achievements:PROGRESS", {
+			now: data.userData.achievements.slots.progress.now,
+			total: data.userData.achievements.slots.progress.total,
+			percent: Math.round(100 * (data.userData.achievements.slots.progress.now/data.userData.achievements.slots.progress.total))
+		}));
+		embed.addField(message.translate("economy/achievements:TIP"), message.translate("economy/achievements:PROGRESS", {
+			now: data.userData.achievements.tip.progress.now,
+			total: data.userData.achievements.tip.progress.total,
+			percent: Math.round(100 * (data.userData.achievements.tip.progress.now/data.userData.achievements.tip.progress.total))
+		}));
+		embed.addField(message.translate("economy/achievements:REP"), message.translate("economy/achievements:PROGRESS", {
+			now: data.userData.achievements.rep.progress.now,
+			total: data.userData.achievements.rep.progress.total,
+			percent: Math.round(100 * (data.userData.achievements.rep.progress.now/data.userData.achievements.rep.progress.total))
+		}));
+		embed.addField(message.translate("economy/achievements:INVITE"), message.translate("economy/achievements:PROGRESS", {
+			now: data.userData.achievements.invite.progress.now,
+			total: data.userData.achievements.invite.progress.total,
+			percent: Math.round(100 * (data.userData.achievements.invite.progress.now/data.userData.achievements.invite.progress.total))
+		}));
+
+		message.channel.send(embed);
+	}
+};
+
+module.exports = Achievements;

commands/Economy/birthdate.js

@@ -0,0 +1,46 @@
+const Command = require("../../base/Command.js");
+
+class Birthdate extends Command {
+	constructor (client) {
+		super(client, {
+			name: "birthdate",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "anniversaire" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 1000
+		});
+	}
+
+	async run (message, args, data) {
+		const date = args[0];
+		if (!date) return message.error("economy/birthdate:MISSING_DATE");
+
+		const tArgs = date.split("/");
+		const [day, month, year] = tArgs;
+		if (!day || !month || !year) return message.error("economy/birthdate:INVALID_DATE");
+
+		// Gets the string of the date
+		const match = date.match(/\d+/g);
+		if (!match) return message.error("economy/birthdate:INVALID_DATE_FORMAT");
+
+		const tday = +match[0], tmonth = +match[1] - 1;
+		let tyear = +match[2];
+		if (tyear < 100) tyear += tyear < 50 ? 2000 : 1900;
+		const d = new Date(tyear, tmonth, tday);
+		if (!(tday == d.getDate() && tmonth == d.getMonth() && tyear == d.getFullYear())) return message.error("economy/birthdate:INVALID_DATE_FORMAT");
+		if (d.getTime() > Date.now()) return message.error("economy/birthdate:DATE_TOO_HIGH");
+		if (d.getTime() < (Date.now()-2.523e+12))return message.error("economy/birthdate:DATE_TOO_LOW");
+
+		data.userData.birthdate = d;
+		data.userData.save();
+
+		message.success("economy/birthdate:SUCCESS", { date: message.printDate(d)});
+	}
+};
+
+module.exports = Birthdate;

commands/Economy/deposit.js

@@ -0,0 +1,41 @@
+const Command = require("../../base/Command.js");
+
+class Deposit extends Command {
+	constructor (client) {
+		super(client, {
+			name: "deposit",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "bank", "banque", "dep" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 1000
+		});
+	}
+
+	async run (message, args, data) {
+		let amount = args[0];
+
+		if (!(parseInt(data.memberData.money, 10) > 0)) return message.error("economy/deposit:NO_CREDIT");
+
+		if (args[0] === "all") {
+			amount = parseInt(data.memberData.money, 10);
+		} else {
+			if (isNaN(amount) || parseInt(amount, 10) < 1) return message.error("economy/deposit:MISSING_AMOUNT");
+			amount = parseInt(amount, 10);
+		};
+
+		if (data.memberData.money < amount) return message.error("economy/deposit:NOT_ENOUGH_CREDIT", { money: amount });
+
+		data.memberData.money = data.memberData.money - amount;
+		data.memberData.bankSold = data.memberData.bankSold + amount;
+		data.memberData.save();
+
+		message.success("economy/deposit:SUCCESS", { money: amount });
+	}
+};
+
+module.exports = Deposit;

commands/Economy/divorce.js

@@ -0,0 +1,38 @@
+const Command = require("../../base/Command.js");
+
+class Divorce extends Command {
+	constructor (client) {
+		super(client, {
+			name: "divorce",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "profil" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		// Check if the message author is wedded
+		if (!data.userData.lover) return message.error("economy/divorce:NOT_MARRIED");
+
+		// Updates db
+		const user = this.client.users.cache.get(data.userData.lover) || await this.client.users.fetch(data.userData.lover);
+
+		data.userData.lover = null;
+		data.userData.save();
+
+		const oldLover = await this.client.findOrCreateUser({ id:user.id });
+		oldLover.lover = null;
+		oldLover.save();
+
+		// Send success message
+		message.success("economy/divorce:SUCCESS", { username: user.username });
+	}
+};
+
+module.exports = Divorce;

commands/Economy/leaderboard.js

@@ -0,0 +1,87 @@
+const Command = require("../../base/Command.js"),
+	AsciiTable = require("ascii-table");
+
+class Leaderboard extends Command {
+	constructor (client) {
+		super(client, {
+			name: "leaderboard",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "lb" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 5000
+		});
+	}
+
+	async run (message, args) {
+		const isOnlyOnMobile = (message.author.presence.clientStatus ? JSON.stringify(Object.keys(message.author.presence.clientStatus)) === JSON.stringify([ "mobile" ]) : false);
+
+		const type = args[0];
+		if (!type || (type !== "credits" && type !== "level" && type !== "rep")) return message.error("economy/leaderboard:MISSING_TYPE");
+
+		if (type === "credits") {
+			const members = await this.client.membersData.find({ guildID: message.guild.id }).lean(),
+				membersLeaderboard = members.map((m) => {
+					return {
+						id: m.id,
+						value: m.money+m.bankSold
+					};
+				}).sort((a,b) => b.value - a.value);
+			const table = new AsciiTable("LEADERBOARD");
+			table.setHeading("#", message.translate("common:USER"), message.translate("common:CREDITS"));
+			if (membersLeaderboard.length > 20) membersLeaderboard.length = 20;
+			const newTable = await fetchUsers(membersLeaderboard, table, this.client);
+			message.channel.send("```\n"+newTable.toString()+"```");
+		} else if (type === "level") {
+			const members = await this.client.membersData.find({ guildID: message.guild.id }).lean(),
+				membersLeaderboard = members.map((m) => {
+					return {
+						id: m.id,
+						value: m.level
+					};
+				}).sort((a,b) => b.value - a.value);
+			const table = new AsciiTable("LEADERBOARD");
+			table.setHeading("#", message.translate("common:USER"), message.translate("common:LEVEL"));
+			if (membersLeaderboard.length > 20) membersLeaderboard.length = 20;
+			const newTable = await fetchUsers(membersLeaderboard, table, this.client);
+			message.channel.send("```\n"+newTable.toString()+"```");
+		} else if (type === "rep") {
+			const users = await this.client.usersData.find().lean(),
+				usersLeaderboard = users.map((u) => {
+					return {
+						id: u.id,
+						value: u.rep
+					};
+				}).sort((a,b) => b.value - a.value);
+			const table = new AsciiTable("LEADERBOARD");
+			table.setHeading("#", message.translate("common:USER"), message.translate("common:POINTS"));
+			if (usersLeaderboard.length > 20) usersLeaderboard.length = 20;
+			const newTable = await fetchUsers(usersLeaderboard, table, this.client);
+			message.channel.send("```\n"+newTable.toString()+"```");
+		};
+
+		if (isOnlyOnMobile) message.sendT("economy/leaderboard:MOBILE");
+
+		async function fetchUsers(array, table, client) {
+			return new Promise((resolve) => {
+				let index = 0;
+				array.forEach((element) => {
+					client.users.fetch(element.id).then((user) => {
+						const regEx = /(?:[\u2700-\u27bf]|(?:\ud83c[\udde6-\uddff]){2}|[\ud800-\udbff][\udc00-\udfff]|[\u0023-\u0039]\ufe0f?\u20e3|\u3299|\u3297|\u303d|\u3030|\u24c2|\ud83c[\udd70-\udd71]|\ud83c[\udd7e-\udd7f]|\ud83c\udd8e|\ud83c[\udd91-\udd9a]|\ud83c[\udde6-\uddff]|\ud83c[\ude01-\ude02]|\ud83c\ude1a|\ud83c\ude2f|\ud83c[\ude32-\ude3a]|\ud83c[\ude50-\ude51]|\u203c|\u2049|[\u25aa-\u25ab]|\u25b6|\u25c0|[\u25fb-\u25fe]|\u00a9|\u00ae|\u2122|\u2139|\ud83c\udc04|[\u2600-\u26FF]|\u2b05|\u2b06|\u2b07|\u2b1b|\u2b1c|\u2b50|\u2b55|\u231a|\u231b|\u2328|\u23cf|[\u23e9-\u23f3]|[\u23f8-\u23fa]|\ud83c\udccf|\u2934|\u2935|[\u2190-\u21ff])/g;
+						let username = user.username.replace(regEx, "");
+						if (username.length > 20) username = username.substr(0, 20);
+
+						table.addRow(index++, username, element.value);
+					});
+				});
+				resolve(table);
+			});
+		};
+	}
+};
+
+module.exports = Leaderboard;

commands/Economy/marry.js

@@ -0,0 +1,121 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js");
+
+// An object to store pending requests
+const pendings = {};
+
+class Marry extends Command {
+	constructor (client) {
+		super(client, {
+			name: "marry",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "mariage" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 10000
+		});
+	}
+
+	async run (message, args, data) {
+		// if the message author is already wedded
+		if (data.userData.lover) return message.error("economy/marry:ALREADY_MARRIED", { prefix: data.guild.prefix });
+
+		// Gets the first mentionned member
+		const member = await this.client.resolveMember(args[0], message.guild);
+		if (!member) return message.error("economy/marry:INVALID_MEMBER");
+
+		const userData = await this.client.findOrCreateUser({ id: member.id });
+
+		// if the member is already wedded
+		if (userData.lover) return message.error("economy/marry:ALREADY_MARRIED_USER", { username: member.user.tag });
+
+		if (member.user.bot) return message.error("economy/marry:BOT_USER");
+
+		if (member.id === message.author.id) return message.error("economy/marry:YOURSELF");
+
+		for (const requester in pendings) {
+			const receiver = pendings[requester];
+			// If the member already sent a request to someone
+			if (requester === message.author.id) {
+				const user =  this.client.users.cache.get(receiver) || await this.client.users.fetch(receiver);
+				return message.error("economy/marry:REQUEST_AUTHOR_TO_AMEMBER", { username: user.tag });
+			} else if (receiver === message.author.id) { // If there is a pending request for this member
+				const user =  this.client.users.cache.get(requester) || await this.client.users.fetch(requester);
+				return message.error("economy/marry:REQUEST_AMEMBER_TO_AUTHOR", { username: user.tag });
+			} else if (requester === member.id) { // If the asked member has sent pending request
+				const user = this.client.users.cache.get(receiver) || await this.client.users.fetch(receiver);
+				return message.error("economy/marry:REQUEST_AMEMBER_TO_MEMBER", { firstUsername: member.user.tag, secondUsername: user.tag });
+			} else if (receiver === member.id) { // If there is a pending request for the asked member
+				const user = this.client.users.cache.get(requester) || await this.client.users.fetch(requester);
+				return message.error("economy/marry:REQUEST_MEMBER_TO_AMEMBER", { firstUsername: member.user.tag, secondUsername: user.tag });
+			};
+		};
+
+		// Update pending requests
+		pendings[message.author.id] = member.id;
+
+		message.sendT("economy/marry:REQUEST", { from: message.author.toString(), to: member.user.toString() });
+
+		const collector = new Discord.MessageCollector(message.channel, (m) => m.author.id === member.id, {
+			time: 120000
+		});
+
+		collector.on("collect", (msg) => {
+			if (msg.content.toLowerCase() === message.translate("common:YES").toLowerCase()) {
+				return collector.stop(true);
+			} else if (msg.content.toLowerCase() === message.translate("common:NO").toLowerCase()) {
+				return collector.stop(false);
+			} else {
+				return message.error("misc:INVALID_YES_NO");
+			};
+		});
+
+		collector.on("end", async (_collected, reason) => {
+			// Delete pending request
+			delete pendings[message.author.id];
+			if (reason === "time") {
+				return message.error("economy/marry:TIMEOUT", { username: member.user.toString() });
+			};
+			if (reason) {
+				data.userData.lover = member.id;
+				await data.userData.save();
+				userData.lover = message.author.id;
+				await userData.save();
+				const messageOptions = {
+					content: `${member.toString()} :heart: ${message.author.toString()}`,
+					files: [
+						{
+							name: "unlocked.png",
+							attachment: "./assets/img/achievements/achievement_unlocked3.png"
+						}
+					]
+				};
+				let sent = false;
+				if (!userData.achievements.married.achieved) {
+					message.channel.send(messageOptions);
+					sent = true;
+					userData.achievements.married.achieved = true;
+					userData.achievements.married.progress.now = 1;
+					userData.markModified("achievements.married");
+					userData.save();
+				};
+				if (!data.userData.achievements.married.achieved) {
+					if (!sent) message.channel.send(messageOptions);
+					data.userData.achievements.married.achieved = true;
+					data.userData.achievements.married.progress.now = 1;
+					data.userData.markModified("achievements.married");
+					data.userData.save();
+				};
+				return message.success("economy/marry:SUCCESS", { creator: message.author.toString(), partner: member.user.toString() });
+			} else {
+				return message.success("economy/marry:DENIED", { creator: message.author.toString(), partner: member.user.toString() });
+			};
+		});
+	}
+};
+
+module.exports = Marry;

commands/Economy/money.js

@@ -0,0 +1,62 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js");
+
+const asyncForEach = async (array, callback) => {
+	for (let index = 0; index < array.length; index++) {
+		await callback(array[index], index, array);
+	};
+};
+
+class Credits extends Command {
+	constructor (client) {
+		super(client, {
+			name: "money",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "credits", "balance" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 1000
+		});
+	}
+
+	async run (message, args, data) {
+		let member = await this.client.resolveMember(args[0], message.guild);
+		if (!member) member = message.member;
+		const user = member.user;
+
+		if (user.bot) return message.error("misc:BOT_USER");
+
+		const memberData = (message.author === user) ? data.memberData : await this.client.findOrCreateMember({ id: user.id, guildID: message.guild.id });
+
+		const commonsGuilds = this.client.guilds.cache.filter((g) => g.members.cache.get(user.id));
+		let globalMoney = 0;
+		await asyncForEach(commonsGuilds.array(), async (guild) => {
+			const memberData = await this.client.findOrCreateMember({ id: user.id, guildID: guild.id });
+			globalMoney+=memberData.money;
+			globalMoney+=memberData.bankSold;
+		});
+
+		const embed = new Discord.MessageEmbed()
+			.setAuthor(message.translate("economy/money:TITLE", {
+				username: member.user.username
+			}), member.user.displayAvatarURL({ size: 512, dynamic: true, format: 'png' }))
+			.addField(message.translate("economy/profile:CASH"), message.translate("economy/profile:MONEY", {
+				money: memberData.money
+			}), true)
+			.addField(message.translate("economy/profile:BANK"), message.translate("economy/profile:MONEY", {
+				money: memberData.bankSold
+			}), true)
+			.addField(message.translate("economy/profile:GLOBAL"), message.translate("economy/profile:MONEY", {
+				money: globalMoney
+			}), true)
+			.setColor(this.client.config.embed.color)
+			.setFooter(this.client.config.embed.footer);
+		message.channel.send(embed);
+	}
+};
+
+module.exports = Credits;

commands/Economy/pay.js

@@ -0,0 +1,47 @@
+const Command = require("../../base/Command.js");
+
+class Pay extends Command {
+	constructor (client) {
+		super(client, {
+			name: "pay",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 10000
+		});
+	}
+
+	async run (message, args, data) {
+		const member = await this.client.resolveMember(args[0], message.guild);
+		if (!member) return message.error("economy/pay:INVALID_MEMBER");
+
+		if (member.user.bot) return message.error("economy/pay:BOT_USER");
+
+		if (member.id === message.author.id) return message.error("economy/pay:YOURSELF");
+
+		const sentAmount = args[1];
+		if (!sentAmount || isNaN(sentAmount) || parseInt(sentAmount, 10) <= 0) return message.error("economy/pay:INVALID_AMOUNT", { username: member.user.tag });
+
+		const amount = Math.ceil(parseInt(sentAmount, 10));
+
+		if (amount > data.memberData.money) return message.error("economy/pay:ENOUGH_MONEY", { amount, username: member.user.tag });
+
+		const memberData = await this.client.findOrCreateMember({ id: member.id, guildID: message.guild.id });
+
+		data.memberData.money = data.memberData.money - parseInt(amount, 10);
+		data.memberData.save();
+
+		memberData.money = memberData.money + parseInt(amount, 10);
+		memberData.save();
+
+		// Send a success message
+		message.success("economy/pay:SUCCESS", { amount, username: member.user.tag });
+	}
+};
+
+module.exports = Pay;

commands/Economy/profile.js

@@ -0,0 +1,85 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js");
+
+const asyncForEach = async (array, callback) => {
+	for (let index = 0; index < array.length; index++) {
+		await callback(array[index], index, array);
+	};
+};
+
+class Profile extends Command {
+	constructor (client) {
+		super(client, {
+			name: "profile",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "profil" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		const client = this.client;
+
+		let member = await client.resolveMember(args[0], message.guild);
+		if (!member) member = message.member;
+
+		// Check if the user is a bot
+		if (member.user.bot) return message.error("economy/profile:BOT_USER");
+
+		// Gets the data of the user whose profile you want to display
+		const memberData = (member.id === message.author.id ? data.memberData : await client.findOrCreateMember({ id: member.id, guildID: message.guild.id}));
+		const userData = (member.id === message.author.id ? data.userData : await client.findOrCreateUser({ id: member.id }));
+
+		// Check if the lover is cached
+		if (userData.lover && !this.client.users.cache.get(userData.lover)) await this.client.users.fetch(userData.lover, true);
+
+		const commonsGuilds = client.guilds.cache.filter((g) => g.members.cache.get(member.id));
+		let globalMoney = 0;
+		await asyncForEach(commonsGuilds.array(), async (guild) => {
+			const memberData = await client.findOrCreateMember({ id: member.id, guildID: guild.id });
+			globalMoney+=memberData.money;
+			globalMoney+=memberData.bankSold;
+		});
+
+		const profileEmbed = new Discord.MessageEmbed()
+			.setAuthor(message.translate("economy/profile:TITLE", {
+				username: member.user.tag
+			}), member.user.displayAvatarURL({ size: 512, dynamic: true, format: 'png' }))
+			.attachFiles([{ attachment: await userData.getAchievements(), name: "achievements.png" }])
+			.setImage("attachment://achievements.png")
+			.setDescription(userData.bio ? userData.bio : message.translate("economy/profile:NO_BIO"))
+			.addField(message.translate("economy/profile:CASH"), message.translate("economy/profile:MONEY", {
+				money: memberData.money
+			}), true)
+			.addField(message.translate("economy/profile:BANK"), message.translate("economy/profile:MONEY", {
+				money: memberData.bankSold
+			}), true)
+			.addField(message.translate("economy/profile:GLOBAL"), message.translate("economy/profile:MONEY", {
+				money: globalMoney
+			}), true)
+			.addField(message.translate("economy/profile:REPUTATION"), message.translate("economy/profile:REP_POINTS", {
+				points: userData.rep
+			}), true)
+			.addField(message.translate("economy/profile:LEVEL"), `**${memberData.level}**`, true)
+			.addField(message.translate("economy/profile:EXP"), `**${memberData.exp}** xp`, true)
+			.addField(message.translate("economy/profile:REGISTERED"), message.printDate(new Date(memberData.registeredAt)), true)
+			.addField(message.translate("economy/profile:BIRTHDATE"), (!userData.birthdate ? message.translate("economy/profile:NO_BIRTHDATE"): message.printDate(new Date(userData.birthdate))), true)
+			.addField(message.translate("economy/profile:LOVER"), (!userData.lover ? message.translate("economy/profile:NO_LOVER") : this.client.users.cache.get(userData.lover).tag), true)
+			.addField(message.translate("economy/profile:ACHIEVEMENTS"), message.translate("economy/profile:ACHIEVEMENTS_CONTENT", {
+				prefix: data.guild.prefix
+			}))
+			.setColor(data.config.embed.color) // Sets the color of the embed
+			.setFooter(data.config.embed.footer) // Sets the footer of the embed
+			.setTimestamp();
+
+		message.channel.send(profileEmbed); // Send the embed in the current channel
+	}
+};
+
+module.exports = Profile;

commands/Economy/rep.js

@@ -0,0 +1,57 @@
+const Command = require("../../base/Command.js");
+
+class Rep extends Command {
+	constructor (client) {
+		super(client, {
+			name: "rep",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "reputation" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		// if the member is already in the cooldown db
+		const isInCooldown = (data.userData.cooldowns || { rep: 0 }).rep;
+		if (isInCooldown) {
+			/*if the timestamp recorded in the database indicating
+			when the member will be able to execute the order again
+			is greater than the current date, display an error message */
+			if (isInCooldown > Date.now()) return message.error("economy/rep:COOLDOWN", { time: message.convertTime(isInCooldown, "to", true) });
+		};
+
+		const user = await this.client.resolveUser(args[0]);
+		if (!user) return message.error("economy/rep:INVALID_USER");
+		if (user.bot) return message.error("economy/rep:BOT_USER");
+		if (user.id === message.author.id) return message.error("economy/rep:YOURSELF");
+
+		// Records in the database the time when the member will be able to execute the command again (in 12 hours)
+		const toWait = Date.now() + 21600000;
+		data.userData.cooldowns = {};
+		data.userData.cooldowns.rep = toWait;
+		data.userData.markModified("cooldowns");
+		data.userData.save();
+
+		const userData = await this.client.findOrCreateUser({ id: user.id });
+		userData.rep++;
+		if (!userData.achievements.rep.achieved) {
+			userData.achievements.rep.progress.now = (userData.rep > userData.achievements.rep.progress.total ? userData.achievements.rep.progress.total : userData.rep);
+			if (userData.achievements.rep.progress.now >= userData.achievements.rep.progress.total) {
+				userData.achievements.rep.achieved = true;
+				message.channel.send({ files: [ { name: "unlocked.png", attachment: "./assets/img/achievements/achievement_unlocked6.png"}]});
+			};
+			userData.markModified("achievements.rep");
+		};
+		await userData.save();
+
+		message.success("economy/rep:SUCCESS", { username: user.username });
+	}
+};
+
+module.exports = Rep;

commands/Economy/rob.js

@@ -0,0 +1,66 @@
+const Command = require("../../base/Command.js");
+
+class Rob extends Command {
+	constructor (client) {
+		super(client, {
+			name: "rob",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "steal" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 1000
+		});
+	}
+
+	async run (message, args, data) {
+		const member = await this.client.resolveMember(args[0], message.guild);
+		if (!member) return message.error("economy/rob:MISSING_MEMBER");
+
+		if (member.id === message.author.id) return message.error("economy/rob:YOURSELF");
+
+		const memberData = await this.client.findOrCreateMember({ id: member.id, guildID: message.guild.id });
+		const isInCooldown = memberData.cooldowns.rob || 0;
+		if (isInCooldown) {
+			if (isInCooldown > Date.now()) return message.error("economy/rob:COOLDOWN", { username: member.user.tag });
+		};
+
+		let amountToRob = args[1];
+		if (!amountToRob || isNaN(amountToRob) || parseInt(amountToRob, 10) <= 0) return message.error("economy/rob:MISSING_AMOUNT", { username: member.user.username });
+
+		amountToRob = Math.floor(parseInt(amountToRob, 10));
+
+		if (amountToRob > memberData.money) return message.error("economy/rob:NOT_ENOUGH_MEMBER", { username: member.user.username, money: amountToRob });
+
+		const potentiallyLose = Math.floor(amountToRob * 1.5);
+		if (potentiallyLose > data.memberData.money) return message.error("economy/rob:NOT_ENOUGH_AUTHOR", { moneyMin: potentiallyLose, moneyCurrent: data.memberData.money });
+
+		const itsAWon = Math.floor(this.client.functions.randomNum(0, 100) < 25);
+
+		if (itsAWon) {
+			const toWait = Date.now() + 6 * (60 * 60000);
+			memberData.cooldowns.rob = toWait;
+			memberData.markModified("cooldowns");
+			await memberData.save();
+			const randomNum = Math.floor(this.client.functions.randomNum(1, 3));
+			message.sendT("economy/rob:ROB_WON_" + randomNum, { money: amountToRob, username: member.user.username });
+			data.memberData.money += amountToRob;
+			memberData.money -= amountToRob, 10;
+			memberData.save();
+			data.memberData.save();
+		} else {
+			const won = Math.floor(0.9 * amountToRob);
+			const randomNum = Math.floor(this.client.functions.randomNum(1, 3));
+			message.sendT("economy/rob:ROB_LOSE_" + randomNum, { fine: potentiallyLose, offset: won, username: member.user.username });
+			data.memberData.money -= potentiallyLose;
+			memberData.money += won;
+			memberData.save();
+			data.memberData.save();
+		};
+	}
+};
+
+module.exports = Rob;

commands/Economy/setbio.js

@@ -0,0 +1,30 @@
+const Command = require("../../base/Command.js");
+
+class Setbio extends Command {
+	constructor (client) {
+		super(client, {
+			name: "setbio",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "biography", "setdesc" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 5000
+		});
+	}
+
+	async run (message, args, data) {
+		const newBio = args.join(" ");
+		if (!newBio) return message.error("economy/setbio:MISSING");
+		if (newBio.length > 100) return message.error("economy/setbio:MAX_CHARACT");
+
+		data.userData.bio = newBio;
+		message.success("economy/setbio:SUCCESS");
+		await data.userData.save();
+	}
+};
+
+module.exports = Setbio;

commands/Economy/slots.js

@@ -0,0 +1,156 @@
+const Command = require("../../base/Command.js");
+
+class Slots extends Command {
+	constructor (client) {
+		super(client, {
+			name: "slots",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "casino", "slot" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		const fruits = [ "🍎", "🍐", "🍌", "🍇", "🍉", "🍒", "🍓" ];
+
+		let i1=0, j1=0, k1=0,
+			i2=1, j2=1, k2=1,
+			i3=2, j3=2, k3=2;
+
+		// Gets three random fruits array
+		const colonnes = [
+			this.client.functions.shuffle(fruits),
+			this.client.functions.shuffle(fruits),
+			this.client.functions.shuffle(fruits)
+		];
+
+		// Gets the amount provided
+		let amount = args[0];
+		if (!amount || isNaN(amount) || amount < 1) amount = 1;
+
+		if (amount > data.memberData.money) return message.error("economy/slots:NOT_ENOUGH", { money: amount });
+
+		amount = Math.round(amount);
+
+		function getCredits(number, isJackpot){
+			if (!isJackpot) {
+				number = number * 1.5;
+			} else if (isJackpot) {
+				number = number * 4;
+			};
+			return Math.round(number);
+		};
+
+		const tmsg = await message.sendT("misc:loading", null, { prefixEmoji: "loading" });
+		editMsg();
+		const interval = setInterval(editMsg, 1000);
+		setTimeout(() => {
+			clearInterval(interval);
+			end(tmsg);
+		}, 4000);
+
+		async function end() {
+			let msg = "[  :slot_machine: | **СЛОТЫ** ]\n------------------\n";
+
+			i1 = (i1 < fruits.length - 1) ? i1 + 1 : 0;
+			i2 = (i2 < fruits.length - 1) ? i2 + 1 : 0;
+			i3 = (i3 < fruits.length - 1) ? i3 + 1 : 0;
+			j1 = (j1 < fruits.length - 1) ? j1 + 1 : 0;
+			j2 = (j2 < fruits.length - 1) ? j2 + 1 : 0;
+			j3 = (j3 < fruits.length - 1) ? j3 + 1 : 0;
+			k1 = (k1 < fruits.length - 1) ? k1 + 1 : 0;
+			k2 = (k2 < fruits.length - 1) ? k2 + 1 : 0;
+			k3 = (k3 < fruits.length - 1) ? k3 + 1 : 0;
+
+			msg += colonnes[0][i1] + " : " + colonnes[1][j1] + " : "+ colonnes[2][k1] + "\n";
+			msg += colonnes[0][i2] + " : " + colonnes[1][j2] + " : "+ colonnes[2][k2] + " **<**\n";
+			msg += colonnes[0][i3] + " : " + colonnes[1][j3] + " : "+ colonnes[2][k3] + "\n------------------\n";
+
+			if ((colonnes[0][i2] == colonnes[1][j2]) && (colonnes[1][j2] == colonnes[2][k2])) {
+				msg += "| : : :  **"+(message.translate("common:VICTORY").toUpperCase())+"**  : : : |";
+				tmsg.edit(msg);
+				const credits = getCredits(amount, true);
+				message.channel.send("**!! ДЖЕКПОТ !!**\n"+message.translate("economy/slots:VICTORY", { money: amount, won: credits, username: message.author.username }));
+				const toAdd = credits - amount;
+				data.memberData.money = data.memberData.money + toAdd;
+				if (!data.userData.achievements.slots.achieved) {
+					data.userData.achievements.slots.progress.now += 1;
+					if (data.userData.achievements.slots.progress.now === data.userData.achievements.slots.progress.total) {
+						data.userData.achievements.slots.achieved = true;
+						message.channel.send({ files: [ { name: "unlocked.png", attachment: "./assets/img/achievements/achievement_unlocked4.png" } ] });
+					};
+					data.userData.markModified("achievements.slots");
+					await data.userData.save();
+				};
+				await data.memberData.save();
+				return;
+			};
+
+			if (colonnes[0][i2] == colonnes[1][j2] || colonnes[1][j2] == colonnes[2][k2] || colonnes[0][i2] == colonnes[2][k2]) {
+				msg += "| : : :  **"+(message.translate("common:VICTORY").toUpperCase())+"**  : : : |";
+				tmsg.edit(msg);
+				const credits = getCredits(amount, false);
+				message.channel.send(message.translate("economy/slots:VICTORY", {
+					money: amount,
+					won: credits,
+					username: message.author.username
+				}));
+				const toAdd = credits - amount;
+				data.memberData.money = data.memberData.money + toAdd;
+				if (!data.userData.achievements.slots.achieved) {
+					data.userData.achievements.slots.progress.now += 1;
+					if (data.userData.achievements.slots.progress.now === data.userData.achievements.slots.progress.total) {
+						data.userData.achievements.slots.achieved = true;
+						message.channel.send({ files: [ { name: "unlocked.png", attachment: "./assets/img/achievements/achievement_unlocked4.png" } ] });
+					};
+					data.userData.markModified("achievements.slots");
+					await data.userData.save();
+				};
+				await data.memberData.save();
+				return;
+			};
+
+			msg += "| : : :  **"+(message.translate("common:DEFEAT").toUpperCase())+"**  : : : |";
+			message.channel.send(message.translate("economy/slots:DEFEAT", {
+				money: amount,
+				username: message.author.username
+			}));
+			data.memberData.money = data.memberData.money - amount;
+			if (!data.userData.achievements.slots.achieved) {
+				data.userData.achievements.slots.progress.now = 0;
+				data.userData.markModified("achievements.slots");
+				await data.userData.save();
+			};
+			await data.memberData.save();
+			return;
+		};
+
+		function editMsg() {
+			let msg = "[  :slot_machine: l SLOTS ]\n------------------\n";
+
+			i1 = (i1 < fruits.length - 1) ? i1 + 1 : 0;
+			i2 = (i2 < fruits.length - 1) ? i2 + 1 : 0;
+			i3 = (i3 < fruits.length - 1) ? i3 + 1 : 0;
+			j1 = (j1 < fruits.length - 1) ? j1 + 1 : 0;
+			j2 = (j2 < fruits.length - 1) ? j2 + 1 : 0;
+			j3 = (j3 < fruits.length - 1) ? j3 + 1 : 0;
+			k1 = (k1 < fruits.length - 1) ? k1 + 1 : 0;
+			k2 = (k2 < fruits.length - 1) ? k2 + 1 : 0;
+			k3 = (k3 < fruits.length - 1) ? k3 + 1 : 0;
+
+			msg += colonnes[0][i1] + " : " + colonnes[1][j1] + " : "+ colonnes[2][k1] + "\n";
+			msg += colonnes[0][i2] + " : " + colonnes[1][j2] + " : "+ colonnes[2][k2] + " **<**\n";
+			msg += colonnes[0][i3] + " : " + colonnes[1][j3] + " : "+ colonnes[2][k3] + "\n";
+
+			tmsg.edit(msg);
+		};
+	}
+};
+
+module.exports = Slots;

commands/Economy/withdraw.js

@@ -0,0 +1,42 @@
+const Command = require("../../base/Command.js");
+
+class Withdraw extends Command {
+	constructor (client) {
+		super(client, {
+			name: "withdraw",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "wd" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 1000
+		});
+	}
+
+	async run (message, args, data) {
+		let amount = args[0];
+
+		if (!(parseInt(data.memberData.bankSold, 10) > 0)) return message.error("economy/withdraw:NO_CREDIT");
+
+
+		if (args[0] === "all") {
+			amount = parseInt(data.memberData.bankSold, 10);
+		} else {
+			if (isNaN(amount) || parseInt(amount, 10) < 1)return message.error("economy/withdraw:MISSING_AMOUNT");
+			amount = parseInt(amount, 10);
+		};
+
+		if (data.memberData.bankSold < amount) return message.error("economy/withdraw:NOT_ENOUGH", { money: amount });
+
+		data.memberData.money = data.memberData.money + amount;
+		data.memberData.bankSold = data.memberData.bankSold - amount;
+		data.memberData.save();
+
+		message.success("economy/withdraw:SUCCESS", { money: amount });
+	}
+};
+
+module.exports = Withdraw;

commands/Economy/work.js

@@ -0,0 +1,93 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js");
+
+class Work extends Command {
+	constructor (client) {
+		super(client, {
+			name: "work",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "salaire", "salary", "travail", "daily", "dailies" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		// if the member is already in the cooldown db
+		const isInCooldown = data.memberData.cooldowns.work;
+		if (isInCooldown) {
+			/*if the timestamp recorded in the database indicating
+			when the member will be able to execute the order again
+			is greater than the current date, display an error message */
+			if (isInCooldown > Date.now()) return message.error("economy/work:COOLDOWN", { time: message.convertTime(isInCooldown, "to", true) });
+		};
+
+		if (Date.now() > data.memberData.cooldowns.work + (24 * 3600000)) data.memberData.workStreak = 0;
+
+		// Records in the database the time when the member will be able to execute the command again (in 12 hours)
+		const toWait = Date.now() + 21600000;
+		data.memberData.cooldowns.work = toWait;
+		data.memberData.markModified("cooldowns");
+
+		data.memberData.workStreak = (data.memberData.workStreak || 0) + 1;
+		await data.memberData.save();
+
+		const embed = new Discord.MessageEmbed()
+			.setFooter(message.translate("economy/work:AWARD"), message.author.displayAvatarURL({ size: 512, dynamic: true, format: 'png' }))
+			.setColor(data.config.embed.color);
+
+		const award = [
+			this.client.customEmojis.letters.a,
+			this.client.customEmojis.letters.w,
+			this.client.customEmojis.letters.a,
+			this.client.customEmojis.letters.r,
+			this.client.customEmojis.letters.d
+		];
+		let won = 200;
+
+		if (data.memberData.workStreak >= 5) {
+			won += 200;
+			embed.addField(message.translate("economy/work:SALARY"), message.translate("economy/work:SALARY_CONTENT", { won }))
+				.addField(message.translate("economy/work:STREAK"), message.translate("economy/work:STREAK_CONTENT"));
+			data.memberData.workStreak = 0;
+		} else {
+			for (let i = 0; i < award.length; i++) {
+				if (data.memberData.workStreak > i) {
+					const letter = Discord.Util.parseEmoji(award[i]).name.split("_")[1];
+					award[i] = `:regional_indicator_${letter.toLowerCase()}:`;
+				};
+			};
+			embed.addField(message.translate("economy/work:SALARY"), message.translate("economy/work:SALARY_CONTENT", { won }))
+				.addField(message.translate("economy/work:STREAK"), award.join(""));
+		};
+
+		data.memberData.money = data.memberData.money + won;
+		data.memberData.save();
+
+		const messageOptions = { embed };
+		if (!data.userData.achievements.work.achieved) {
+			data.userData.achievements.work.progress.now += 1;
+			if (data.userData.achievements.work.progress.now === data.userData.achievements.work.progress.total) {
+				messageOptions.files = [
+					{
+						name: "unlocked.png",
+						attachment: "./assets/img/achievements/achievement_unlocked1.png"
+					}
+				];
+				data.userData.achievements.work.achieved = true;
+			};
+			data.userData.markModified("achievements.work");
+			data.userData.save();
+		};
+
+		// Send the embed in the current channel
+		message.channel.send(messageOptions);
+	}
+};
+
+module.exports = Work;

commands/Fun/8ball.js

@@ -0,0 +1,29 @@
+const Command = require("../../base/Command.js");
+
+class Eightball extends Command {
+	constructor (client) {
+		super(client, {
+			name: "8ball",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "eight-ball", "eightball" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args) {
+		if (!args[0] || !message.content.endsWith("?")) return message.error("fun/8ball:ERR_QUESTION");
+
+		const answerNO = parseInt(Math.floor(Math.random() * 10), 10);
+		const answer = message.translate(`fun/8ball:RESPONSE_${answerNO + 1}`);
+
+		message.channel.send(`${message.author.username}, ${answer}`);
+	}
+};
+
+module.exports = Eightball;

commands/Fun/ascii.js

@@ -0,0 +1,31 @@
+const Command = require("../../base/Command.js"),
+	figlet = require("figlet"),
+	util = require("util"),
+	figletAsync = util.promisify(figlet);
+
+class Ascii extends Command {
+	constructor (client) {
+		super(client, {
+			name: "ascii",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 5000
+		});
+	}
+
+	async run (message, args) {
+		const text = args.join(" ");
+		if (!text || text.length > 20) return message.error("fun/ascii:TEXT_MISSING");
+
+		const rendered = await figletAsync(text);
+		message.channel.send("```" + rendered + "```");
+	}
+};
+
+module.exports = Ascii;

commands/Fun/choice.js

@@ -0,0 +1,35 @@
+const Command = require("../../base/Command.js");
+
+class Choice extends Command {
+	constructor (client) {
+		super(client, {
+			name: "choice",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "random" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 5000
+		});
+	}
+
+	async run (message, args) {
+		// Gets the answers by spliting on "/"
+		const answers = args.join(" ").split("/");
+		if (answers.length < 2) return message.error("fun/choice:MISSING");
+		if (answers.some(answer => !answer)) return message.error("fun/choice:EMPTY");
+
+		const m = await message.sendT("fun/choice:PROGRESS", null, false, false, "loading");
+
+		setTimeout(() => {
+			m.success("fun/choice:DONE", null, { edit: true });
+			const result = answers[parseInt(Math.floor(Math.random() * answers.length))];
+			message.channel.send("```" + result + "```");
+		}, 1500);
+	}
+};
+
+module.exports = Choice;

commands/Fun/findwords.js

@@ -0,0 +1,130 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js");
+
+const currentGames = {};
+
+class FindWords extends Command {
+	constructor (client) {
+		super(client, {
+			name: "findwords",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 5000
+		});
+	}
+
+	async run (message, args, data) {
+		if (currentGames[message.guild.id]) return message.error("fun/number:GAME_RUNNING");
+
+		// Reads words file
+		const wordList = require(`../../assets/json/words/${message.guild.data.language}.json`);
+
+		// Init some utils variables
+		const participants = [],
+			winners = [],
+			words = [],
+			nbGames = 4;
+
+		// Store the date wich the game has started
+		const createdAt = Date.now(); // 20929038303
+
+		for (let i = 0; i < nbGames; i++) {
+			const result = Math.floor((Math.random() * wordList.length));
+			words.push(wordList[result].substring(0, 3).toLowerCase());
+		};
+
+		let i = 0; // Inits i variable to count games
+		currentGames[message.guild.id] = true; // Update current game variable
+		generateGame.call(this, words[i]); // Generate a new round
+
+		function generateGame(word){
+			word = word.toLowerCase();
+
+			// Launch timer
+			const delay = (i === 0) ? 10000 : 0;
+			if (i === 0) message.sendT("fun/findwords:GAME_STARTING");
+
+			setTimeout(() => {
+				// Send announcment message
+				message.sendT("fun/findwords:FIND_WORD", { word }, false, false, "warn");
+
+				// init a collector to receive the answers
+				const collector = new Discord.MessageCollector(message.channel, (m) => !m.author.bot, {
+					time: 20000
+				});
+
+				collector.on("collect", (msg) => {
+					if (!participants.includes(msg.author.id)) {
+						participants.push(msg.author.id);
+					};
+					if (msg.content.toLowerCase().indexOf(word) >= 0 && wordList.map((word) => word.toLowerCase()).indexOf(msg.content.toLowerCase()) >= 0) {
+						collector.stop(msg.author.id); // Stop the collector
+					} else {
+						msg.error("fun/findwords:INVALID_WORD", { member: msg.author.toString() });
+					};
+				});
+
+				collector.on("end", async (collected, reason) => {
+					if (reason === "time") {
+						message.error("fun/findwords:NO_WINNER");
+					} else {
+						message.success("fun/findwords:WORD_FOUND", { winner: `<@${reason}>` });
+						winners.push(reason);
+					}
+					if (i < nbGames-1) {
+						i++;
+						generateGame.call(this, words[i]);
+					} else {
+						currentGames[message.guild.id] = false;
+						if (winners.length < 1) return message.error("fun/findwords:NO_WINNER_ALL");
+
+						const winnerID = await getWinner(winners);
+						const time = message.convertTime(createdAt, "from", true);
+						const user = await this.client.users.fetch(winnerID);
+						message.sendT("fun/findwords:GAME_STATS", {
+							winner: user.username,
+							duration: time,
+							participantCount: participants.length,
+							participantList: participants.map((p) => "<@"+p+">").join("\n")
+						});
+						if (participants.length > 1 && data.guild.disabledCategories && !data.guild.disabledCategories.includes("Economy")) {
+							message.sendT("fun/findwords:CREDITS", { winner: user.username });
+							const userdata = await this.client.findOrCreateMember({ id: user.id, guildID: message.guild.id });
+							userdata.money = userdata.money + 15;
+							userdata.save();
+						};
+					};
+				});
+			}, delay);
+		};
+
+		async function getWinner(array){
+			return new Promise(function (resolve){
+				const counts = {};
+				let compare = 0;
+				let mostFrequent;
+				for (let i = 0, len = array.length; i < len; i++) {
+					const winner = array[i];
+					if (!counts[winner]) {
+						counts[winner] = 1;
+					} else {
+						counts[winner] = counts[winner] + 1;
+					};
+					if (counts[winner] > compare){
+						compare = counts[winner];
+						mostFrequent = array[i];
+					};
+				};
+				resolve(mostFrequent);
+			});
+		};
+	}
+};
+
+module.exports = FindWords;

commands/Fun/flip.js

@@ -0,0 +1,25 @@
+const Command = require("../../base/Command.js");
+
+class Flip extends Command {
+	constructor (client) {
+		super(client, {
+			name: "flip",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "dice", "coin" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 1000
+		});
+	}
+
+	async run (message) {
+		const isHeads = Math.random() > 0.5;
+		isHeads ? message.sendT("fun/flip:HEADS") : message.sendT("fun/flip:TAILS");
+	}
+};
+
+module.exports = Flip;

commands/Fun/fml.js

@@ -0,0 +1,35 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js");
+
+class Fml extends Command {
+	constructor (client) {
+		super(client, {
+			name: "fml",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "vdm" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		// if (!this.client.config.apiKeys.blagueXYZ) return message.error("misc:COMMAND_DISABLED");
+
+		// const fml = await this.client.joker.randomVDM(null, data.guild.language.substr(0, 2));
+		const fml = await this.client.joker.randomVDM(null, "en");
+
+		const embed = new Discord.MessageEmbed()
+			.setDescription(fml.content)
+			.setFooter(message.translate("fun/fml:FOOTER"))
+			.setColor(this.client.config.embed.color);
+
+		message.channel.send(embed);
+	}
+};
+
+module.exports = Fml;

commands/Fun/joke.js

@@ -0,0 +1,35 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js");
+
+class Joke extends Command {
+	constructor (client) {
+		super(client, {
+			name: "joke",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "blague" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		// if (!this.client.config.apiKeys.blagueXYZ) return message.error("misc:COMMAND_DISABLED");
+
+		// const joke = await this.client.joker.randomJoke(data.guild.language.substr(0, 2));
+		const  joke = await this.client.joker.randomJoke("en");
+
+		const embed = new Discord.MessageEmbed()
+			.setDescription(joke.toDiscordSpoils())
+			.setFooter(message.translate("fun/joke:FOOTER"))
+			.setColor(this.client.config.embed.color);
+
+		message.channel.send(embed);
+	}
+};
+
+module.exports = Joke;

commands/Fun/lmg.js

@@ -0,0 +1,28 @@
+const Command = require("../../base/Command.js");
+
+class Lmg extends Command {
+	constructor (client) {
+		super(client, {
+			name: "lmg",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "lmgtfy" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 1000
+		});
+	}
+
+	async run (message, args) {
+		const question = args.join(" ");
+		if (!question) return message.error("fun/lmg:MISSING");
+		const encodedQuestion = question.replace(/[' '_]/g, "+");
+		await message.channel.send(`http://lmgtfy.com/?q=${encodedQuestion}`);
+		message.delete().catch(() => {});
+	}
+};
+
+module.exports = Lmg;

commands/Fun/lovecalc.js

@@ -0,0 +1,49 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js"),
+	md5 = require("md5");
+
+class Lovecalc extends Command {
+	constructor (client) {
+		super(client, {
+			name: "lovecalc",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: ["lc"],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 1000
+		});
+	}
+
+	async run (message) {
+		const firstMember = message.mentions.members.filter(m => m.id !== message.author.id).first();
+		if (!firstMember) return message.error("fun/lovecalc:MISSING");
+		const secondMember = message.mentions.members
+				.filter(m => m.id !== firstMember.id)
+				.filter(m => m.id !== message.author.id)
+				.first() || message.member;
+		if (!secondMember) return message.error("fun/lovecalc:MISSING");
+
+		const members = [firstMember, secondMember].sort((a, b) => parseInt(a.id, 10) - parseInt(b.id, 10));
+		const hash = md5(`${members[0].id}${members[1].user.username}${members[0].user.username}${members[1].id}`);
+
+		const string = hash
+			.split("")
+			.filter(e => !isNaN(e))
+			.join("");
+		const percent = parseInt(string.substr(0, 2), 10);
+
+		const embed = new Discord.MessageEmbed()
+			.setAuthor("❤️ LoveCalc")
+			.setDescription(message.translate("fun/lovecalc:CONTENT", { percent, firstUsername: firstMember.user.username, secondUsername: secondMember.user.username }))
+			.setColor(this.client.config.embed.color)
+			.setFooter(this.client.config.embed.footer);
+
+		message.channel.send(embed);
+	}
+};
+
+module.exports = Lovecalc;

commands/Fun/number.js

@@ -0,0 +1,68 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js");
+
+const currentGames = {};
+
+class Number extends Command {
+	constructor (client) {
+		super(client, {
+			name: "number",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 5000
+		});
+	}
+
+	async run (message) {
+		if (currentGames[message.guild.id]) return message.error("fun/number:GAME_RUNNING");
+
+		const participants = [];
+		const number = Math.floor(Math.random() * 3000);
+
+		await message.sendT("fun/number:GAME_START");
+
+		// Store the date wich the game has started
+		const gameCreatedAt = Date.now();
+
+		const collector = new Discord.MessageCollector(message.channel, m => !m.author.bot, {
+			time: 480000 // 8 minutes
+		});
+		currentGames[message.guild.id] = true;
+
+		collector.on("collect", async msg => {
+			if (!participants.includes(msg.author.id)) participants.push(msg.author.id);
+
+			// if it's not a number, return
+			if (isNaN(msg.content)) return;
+
+			const parsedNumber = parseInt(msg.content, 10);
+
+			if (parsedNumber === number) {
+				const time = this.client.functions.convertTime(message.guild, Date.now()-gameCreatedAt);
+				message.sendT("fun/number:GAME_STATS", { winner: msg.author.toString(), number, time, participantCount: participants.length, participants: participants.map(p => `<@${p}>`).join("\n") });
+				message.sendT("fun/number:WON", { winner: msg.author.toString() });
+				const userdata = await this.client.findOrCreateMember({ id: msg.author.id, guildID: message.guild.id });
+				userdata.money = userdata.money + 10;
+				userdata.save();
+				collector.stop(msg.author.username);
+			};
+			if (parseInt(msg.content) < number) message.error("fun/number:BIG", { user: msg.author.toString(), number: parsedNumber });
+			if (parseInt(msg.content) > number) message.error("fun/number:SMALL", { user: msg.author.toString(), number: parsedNumber });
+		});
+
+		collector.on("end", (_collected, reason) => {
+			delete currentGames[message.guild.id];
+			if (reason === "time") {
+				return message.error("fun/number:DEFEAT", { number });
+			};
+		});
+	}
+};
+
+module.exports = Number;

commands/General/fortnite.js

@@ -0,0 +1,70 @@
+const Command = require("../../base/Command.js"),
+	Canvas = require("discord-canvas"),
+	Discord = require("discord.js");
+
+class Fortnite extends Command {
+	constructor (client) {
+		super(client, {
+			name: "fortnite",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "fn" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 500
+		});
+	}
+
+	async run (message, args, data) {
+		if (!data.config.apiKeys.fortniteTRN || data.config.apiKeys.fortniteTRN.length === "") return message.success("misc:COMMAND_DISABLED");
+
+		const stats = new Canvas.FortniteStats();
+
+		const platform = args[0];
+		if (!platform || (platform !== "PC" && platform !== "XBL" && platform !== "PSN")) return message.error("general/fortnite:MISSING_PLATFORM");
+
+		const user = args.slice(1).join(" ");
+		if (!user) return message.error("general/fortnite:MISSING_USERNAME");
+
+		const m = await message.sendT("misc:PLEASE_WAIT", null, { prefixEmoji: "loading" });
+
+		const statsImage = await stats
+			.setToken(data.config.apiKeys.fortniteTRN)
+			.setUser(user)
+			.setPlatform(platform)
+			.setText("averageKills", message.translate("general/fortnite:AVERAGE_KILLS"))
+			.setText("averageKill", message.translate("general/fortnite:AVERAGE_KILL"))
+			.setText("wPercent", message.translate("general/fortnite:W_PERCENT"))
+			.setText("winPercent", message.translate("general/fortnite:WIN_PERCENT"))
+			.setText("kD", message.translate("general/fortnite:KD"))
+			.setText("wins", message.translate("general/fortnite:WINS"))
+			.setText("win", message.translate("general/fortnite:WIN"))
+			.setText("kills", message.translate("general/fortnite:KILLS"))
+			.setText("kill", message.translate("general/fortnite:KILL"))
+			.setText("matches", message.translate("general/fortnite:MATCHES"))
+			.setText("match", message.translate("general/fortnite:MATCH"))
+			.setText("footer", message.translate("general/fortnite:FOOTER"))
+			.toAttachment();
+
+		if (!statsImage) {
+			m.delete();
+			return message.error("general/fortnite:NOT_FOUND", { platform, search: user });
+		};
+
+		// Send embed
+		const attachment = new Discord.MessageAttachment(statsImage.toBuffer(), "fortnite-stats-image.png"),
+			embed = new Discord.MessageEmbed()
+				.setDescription(message.translate("general/fortnite:TITLE", { username: `[${stats.data.username}](${stats.data.url.replace(new RegExp(" ", "g"), "%20")})` }))
+				.attachFiles(attachment)
+				.setImage("attachment://fortnite-stats-image.png")
+				.setColor(data.config.embed.color)
+				.setFooter(data.config.embed.footer);
+		message.channel.send(embed);
+		m.delete();
+	}
+};
+
+module.exports = Fortnite;

commands/General/fortniteshop.js

@@ -0,0 +1,51 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js"),
+	Canvas = require("discord-canvas");
+
+class Fortniteshop extends Command {
+	constructor (client) {
+		super(client, {
+			name: "fortniteshop",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "fnshop" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 500
+		});
+	}
+
+	async run(message, args, data) {
+		if (!data.config.apiKeys.fortniteFNBR || data.config.apiKeys.fortniteFNBR.length === "") return message.error("misc:COMMAND_DISABLED");
+
+		const m = await message.sendT("misc:PLEASE_WAIT", null, { prefixEmoji: "loading" });
+
+		const momentName = this.client.languages.find((language) => language.name === data.guild.language || language.aliases.includes(data.guild.language)).moment;
+		const shop = new Canvas.FortniteShop();
+		const image = await shop
+			.setToken(data.config.apiKeys.fortniteFNBR)
+			.setText("header", message.translate("general/fortniteshop:HEADER"))
+			.setText("daily", message.translate("general/fortniteshop:DAILY"))
+			.setText("featured", message.translate("general/fortniteshop:FEATURED"))
+			.setText("date", message.translate("general/fortniteshop:DATE", { skipInterpolation: true }).replace("{{date}}", "{date}"))
+			.setText("footer", message.translate("general/fortniteshop:FOOTER"))
+			.lang(momentName)
+			.toAttachment();
+		const attachment = new Discord.MessageAttachment(image, "shop.png");
+
+		const embed = new Discord.MessageEmbed()
+			.setAuthor(message.translate("general/fortniteshop:HEADER", { date: message.printDate(new Date(Date.now())) }), this.client.user.displayAvatarURL({ size: 512, dynamic: true, format: 'png' }))
+			.attachFiles(attachment)
+			.setImage("attachment://shop.png")
+			.setColor(this.client.config.embed.color)
+			.setFooter(this.client.config.embed.footer);
+		await message.channel.send(embed);
+		await m.delete();
+		return;
+	}
+};
+
+module.exports = Fortniteshop;

commands/General/github.js

@@ -0,0 +1,40 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js"),
+	fetch = require("node-fetch");
+
+class Github extends Command {
+	constructor (client) {
+		super(client, {
+			name: "github",
+			dirname: __dirname,
+			enabled: false,
+			guildOnly: false,
+			aliases: [ "git", "code" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 5000
+		});
+	}
+
+	async run (message, args, data) {
+		const res = await fetch("https://api.github.com/repos/Androz2091/AtlantaBot");
+		const json = await res.json();
+
+		const embed = new Discord.MessageEmbed()
+			.setAuthor(this.client.user.tag, this.client.user.displayAvatarURL({ size: 512, dynamic: true, format: 'png' }))
+			.setDescription("["+message.translate("general/github:CLICK_HERE")+"](https://github.com/Androz2091/AtlantaBot)")
+			.addField("Stars", json.stargazers_count, true)
+			.addField("Forks", json.forks_count, true)
+			.addField(message.translate("general/github:LANGUAGE"), json.language, true)
+			.addField(message.translate("general/github:OWNER"), "["+json.owner.login+"]("+json.owner.html_url+")")
+			.setImage(json.owner.avatar_url)
+			.setColor(data.config.embed.color)
+			.setFooter(data.config.embed.footer);
+
+		message.channel.send(embed);
+	}
+};
+
+module.exports = Github;

commands/General/hastebin.js

@@ -0,0 +1,48 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js"),
+	fetch = require("node-fetch");
+
+class Hastebin extends Command {
+	constructor (client) {
+		super(client, {
+			name: "hastebin",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "pastebin" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 5000
+		});
+	}
+
+	async run (message, args, data) {
+		const content = args.join(" ");
+		if (!content) return message.error("general/hastebin:MISSING_TEXT");
+
+		try {
+			const res = await fetch("https://hastebin.com/documents", {
+				method: "POST",
+				body: content,
+				headers: { "Content-Type": "text/plain" }
+			});
+
+			const json = await res.json();
+			if (!json.key) return message.error("misc:ERR_OCCURRED");
+
+			const url = `https://hastebin.com/${json.key}.js`;
+
+			const embed = new Discord.MessageEmbed()
+				.setAuthor(message.translate("general/hastebin:SUCCESS"))
+				.setDescription(url)
+				.setColor(data.config.embed.color);
+			message.channel.send(embed);
+		} catch(e){
+			message.error("misc:ERR_OCCURRED");
+		};
+	}
+};
+
+module.exports = Hastebin;

commands/General/help.js

@@ -0,0 +1,90 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js");
+
+class Help extends Command {
+	constructor (client) {
+		super(client, {
+			name: "help",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "aide", "h", "commands" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 5000
+		});
+	}
+
+	async run (message, args, data) {
+		// if a command is provided
+		if (args[0]) {
+			const isCustom = (message.guild && data.guild.customCommands ? data.guild.customCommands.find((c) => c.name === args[0]) : false);
+
+			// if the command doesn't exist, error message
+			const cmd = this.client.commands.get(args[0]) || this.client.commands.get(this.client.aliases.get(args[0]));
+			if (!cmd && isCustom) {
+				return message.error("general/help:CUSTOM", { cmd: args[0] });
+			} else if (!cmd) {
+				return message.error("general/help:NOT_FOUND", { search: args[0] });
+			};
+
+			const description = message.translate(`${cmd.help.category.toLowerCase()}/${cmd.help.name}:DESCRIPTION`);
+			const usage = message.translate(`${cmd.help.category.toLowerCase()}/${cmd.help.name}:USAGE`, { prefix: message.guild ? data.guild.prefix : "" });
+			const examples = message.translate(`${cmd.help.category.toLowerCase()}/${cmd.help.name}:EXAMPLES`, { prefix: message.guild ? data.guild.prefix : "" });
+
+			// Creates the help embed
+			const groupEmbed = new Discord.MessageEmbed()
+				.setAuthor(message.translate("general/help:CMD_TITLE", { prefix: message.guild ? data.guild.prefix : "", cmd: cmd.help.name }))
+				.addField(message.translate("general/help:FIELD_DESCRIPTION"), description)
+				.addField(message.translate("general/help:FIELD_USAGE"), usage)
+				.addField(message.translate("general/help:FIELD_EXAMPLES"), examples)
+				.addField(message.translate("general/help:FIELD_ALIASES"), cmd.help.aliases.length > 0 ? cmd.help.aliases.map(a => "`" + a + "`").join("\n") : message.translate("general/help:NO_ALIAS"))
+				.addField(message.translate("general/help:FIELD_PERMISSIONS"), cmd.conf.memberPermissions.length > 0 ? cmd.conf.memberPermissions.map((p) => "`"+p+"`").join("\n") : message.translate("general/help:NO_REQUIRED_PERMISSION"))
+				.setColor(this.client.config.embed.color)
+				.setFooter(this.client.config.embed.footer);
+
+			// and send the embed in the current channel
+			return message.channel.send(groupEmbed);
+		};
+
+		const categories = [];
+		const commands = this.client.commands;
+
+		commands.forEach((command) => {
+			if (!categories.includes(command.help.category)) {
+				if (command.help.category === "Owner" && message.author.id !== this.client.config.owner.id) return;
+				categories.push(command.help.category);
+			};
+		});
+
+		const emojis = this.client.customEmojis;
+
+		const embed = new Discord.MessageEmbed()
+			.setDescription(message.translate("general/help:INFO", { prefix: message.guild ? data.guild.prefix : "" }))
+			.setColor(data.config.embed.color)
+			.setFooter(data.config.embed.footer);
+		categories.sort().forEach((cat) => {
+			const tCommands = commands.filter((cmd) => cmd.help.category === cat);
+			embed.addField(emojis.categories[cat.toLowerCase()]+" "+cat+" - ("+tCommands.size+")", tCommands.map((cmd) => "`"+cmd.help.name+"`").join(", "));
+		});
+		if (message.guild) {
+			if (data.guild.customCommands.length > 0) embed.addField(emojis.categories.custom+" "+message.guild.name+" | "+message.translate("general/help:CUSTOM_COMMANDS")+" - ("+data.guild.customCommands.length+")", data.guild.customCommands.map((cmd) => "`"+cmd.name+"`").join(", "));
+		};
+
+		embed.addField("\u200B", message.translate("misc:STATS_FOOTER", {
+			donateLink: "",
+			dashboardLink: "",
+			inviteLink: await this.client.generateInvite({
+				permissions: ["ADMINISTRATOR"]
+			}),
+			githubLink: "https://github.com/Androz2091",
+			supportLink: ""
+		}));
+		embed.setAuthor(message.translate("general/help:TITLE", { name: this.client.user.username }), this.client.user.displayAvatarURL({ size: 512, dynamic: true, format: 'png' }));
+		return message.channel.send(embed);
+	}
+};
+
+module.exports = Help;

commands/General/invitations.js

@@ -0,0 +1,61 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js");
+
+class Invitations extends Command {
+	constructor (client) {
+		super(client, {
+			name: "invitations",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS", "MANAGE_GUILD" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		let member = await this.client.resolveMember(args[0], message.guild);
+		if (!member) member = message.member;
+
+		// Gets the invites
+		const invites = await message.guild.fetchInvites().catch(() => {});
+		if (!invites) return message.error("misc:ERR_OCCURRED");
+
+		const memberInvites = invites.filter((i) => i.inviter && i.inviter.id === member.user.id);
+
+		if (memberInvites.size <= 0) {
+			if (member === message.member) {
+				return message.error("general/invitations:NOBODY_AUTHOR");
+			} else {
+				return message.error("general/invitations:NOBODY_MEMBER", { member: member.user.tag });
+			};
+		};
+
+		const content = memberInvites.map((i) => {
+			return message.translate("general/invitations:CODE", { uses: i.uses, code: i.code, channel: i.channel.toString() });
+		}).join("\n");
+		let index = 0;
+		memberInvites.forEach((invite) => index += invite.uses);
+
+		const embed = new Discord.MessageEmbed()
+			.setColor(data.config.embed.color)
+			.setFooter(data.config.embed.footer)
+			.setAuthor(message.translate("general/invitations:TRACKER"))
+			.setDescription(message.translate("general/invitations:TITLE", {
+				member: member.user.tag,
+				guild: message.guild.name
+			}))
+			.addField(message.translate("general/invitations:FIELD_INVITED"), message.translate("general/invitations:FIELD_MEMBERS", {
+				total: index
+			}))
+			.addField(message.translate("general/invitations:FIELD_CODES"), content);
+
+		message.channel.send(embed);
+	}
+};
+
+module.exports = Invitations;

commands/General/invite.js

@@ -0,0 +1,40 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js");
+
+class Invite extends Command {
+	constructor (client) {
+		super(client, {
+			name: "invite",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "i", "add", "vote" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 5000
+		});
+	}
+
+	async run (message, args, data) {
+		const inviteLink = this.client.config.inviteURL || `https://discordapp.com/oauth2/authorize?client_id=${this.client.user.id}&scope=bot&permissions=*`;
+		const voteURL = this.client.config.voteURL || `https://discordbots.org/bot/${this.client.user.id}/vote`;
+		const supportURL = this.client.config.supportURL || await this.client.functions.supportLink(this.client);
+
+		if (args[0] && args[0] === "copy") return message.channel.send(inviteLink);
+
+		const embed = new Discord.MessageEmbed()
+			.setAuthor(message.translate("general/invite:LINKS"))
+			.setDescription(message.translate("general/invite:TIP", { prefix: data.guild.prefix || "" }))
+			.addField(message.translate("general/invite:ADD"), inviteLink)
+			.addField(message.translate("general/invite:VOTE"), voteURL)
+			.addField(message.translate("general/invite:SUPPORT"), supportURL)
+			.setColor(data.config.embed.color)
+			.setFooter(data.config.embed.footer);
+
+		message.channel.send(embed);
+	}
+};
+
+module.exports = Invite;

commands/General/minecraft.js

@@ -0,0 +1,81 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js"),
+	fetch = require("node-fetch"),
+	gamedig = require("gamedig"),
+	Sentry = require("@sentry/node");
+
+class Minecraft extends Command {
+	constructor (client) {
+		super(client, {
+			name: "minecraft",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "mc" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 3000
+		});
+	}
+
+	async run (message, args, data) {
+		const ip = args[0];
+		if (!ip) return message.error("general/minecraft:MISSING_IP");
+
+		const favicon = `https://eu.mc-api.net/v3/server/favicon/${ip}`;
+		let options = {
+			type: "minecraft",
+			host: ip
+		};
+
+		if (ip.split(":").length > 1) {
+			const ip = ip.split(":")
+			options = {
+				type: "minecraft",
+				host: ip[0],
+				port: ip[1]
+			};
+		};
+
+		const m = await message.sendT("misc:PLEASE_WAIT", null, { prefixEmoji: "loading" });
+
+		let json = null;
+
+		await gamedig.query(options).then((res) => {
+			json = res;
+		}).catch((err) => {
+			Sentry.captureException(err);
+		});
+
+		if (!json) {
+			options.type = "minecraftpe";
+			await gamedig.query(options).then((res) => {
+				json = res;
+			}).catch((err) => {
+				Sentry.captureException(err);
+			});
+		};
+
+		if (!json) return m.error("general/minecraft:FAILED", null, { edit: true });
+
+		const imgRes = await fetch("https://www.minecraftskinstealer.com/achievement/a.php?i=2&h=Success&t="+ip);
+		const imgAttachment = new Discord.MessageAttachment(await imgRes.buffer(), "success.png");
+
+		const mcEmbed = new Discord.MessageEmbed()
+			.setAuthor(message.translate("general/minecraft:FIELD_NAME", { ip: json.name }))
+			.addField(message.translate("general/minecraft:FIELD_VERSION"), json.raw.vanilla.raw.version.name)
+			.addField(message.translate("general/minecraft:FIELD_CONNECTED"), message.translate("general/minecraft:PLAYERS", { count: (json.raw.players ? json.raw.players.online : json.players.length) }))
+			.addField(message.translate("general/minecraft:FIELD_MAX"), message.translate("general/minecraft:PLAYERS", { count: (json.raw.players ? json.raw.players.max : json.maxplayers) }))
+			.addField(message.translate("general/minecraft:FIELD_STATUS"), message.translate("general/minecraft:ONLINE"))
+			.addField(message.translate("general/minecraft:FIELD_IP"), json.connect)
+			.setColor(data.config.embed.color)
+			.setThumbnail(favicon)
+			.setFooter(data.config.embed.footer);
+
+		m.edit(null, [ mcEmbed, imgAttachment ]);
+	}
+};
+
+module.exports = Minecraft;

commands/General/permissions.js

@@ -0,0 +1,43 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js");
+const permissions = Object.keys(Discord.Permissions.FLAGS);
+
+class Permissions extends Command {
+	constructor (client) {
+		super(client, {
+			name: "permissions",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "perms" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 500
+		});
+	}
+
+	async run (message) {
+		const member = message.mentions.members.first() || message.member;
+		let text = "```\n"+message.translate("general/permissions:TITLE", { user: member.user.username, channel: message.channel.name })+"\n\n";
+		const mPermissions = message.channel.permissionsFor(member);
+		const total = {
+			denied: 0,
+			allowed: 0
+		};
+		permissions.forEach((perm) => {
+			if (!mPermissions.has(perm)) {
+				text += `${perm} ❌\n`;
+				total.denied++;
+			} else {
+				text += `${perm} ✅\n`;
+				total.allowed++;
+			};
+		});
+		text += `\n${total.allowed} ✅ | ${total.denied} ❌`+"\n```";
+		message.channel.send(text);
+	}
+};
+
+module.exports = Permissions;

commands/General/ping.js

@@ -0,0 +1,27 @@
+const Command = require("../../base/Command.js");
+
+class Ping extends Command {
+	constructor (client) {
+		super(client, {
+			name: "ping",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: false,
+			aliases: [ "pong", "latency" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 1000
+		});
+	}
+
+	async run (message) {
+		message.sendT("general/ping:CONTENT", { ping: "..."
+		}).then((m) => {
+			m.sendT("general/ping:CONTENT", { ping: m.createdTimestamp - message.createdTimestamp }, { edit: true });
+		});
+	}
+};
+
+module.exports = Ping;

commands/General/quote.js

@@ -0,0 +1,77 @@
+const Command = require("../../base/Command.js"),
+	Discord = require("discord.js");
+
+class Quote extends Command {
+	constructor (client) {
+		super(client, {
+			name: "quote",
+			dirname: __dirname,
+			enabled: true,
+			guildOnly: true,
+			aliases: [ "quoter" ],
+			memberPermissions: [],
+			botPermissions: [ "SEND_MESSAGES", "EMBED_LINKS" ],
+			nsfw: false,
+			ownerOnly: false,
+			cooldown: 5000
+		});
+	}
+
+	async run (message, args, data) {
+		function embed(m){
+			const embed = new Discord.MessageEmbed()
+				.setAuthor(m.author.tag, m.author.displayAvatarURL({ size: 512, dynamic: true, format: 'png' }))
+				.setDescription(m.content)
+				.setColor(m.member ? m.member.roles.highest ? m.member.roles.highest.color : data.config.embed.color : data.config.embed.color)
+				.setFooter(m.guild.name+" | #"+m.channel.name)
+				.setTimestamp(m.createdTimestamp);
+			if (m.attachments.size > 0) embed.setImage(m.attachments.first().url);
+			return embed;
+		};
+
+		const msgID = args[0];
+		if (isNaN(msgID)) {
+			message.author.send(message.translate("general/quote:MISSING_ID")).then(() => {
+				message.delete();
+			}).catch(() => {
+				message.error("misc:CANNOT_DM");
+			});
+			return;
+		};
+
+		let channel = message.mentions.channels.first();
+		if (args[1] && !channel) {
+			channel = this.client.channels.cache.get(args[1]);
+			if (!channel) {
+				message.author.send(message.translate("general/quote:NO_MESSAGE_ID")).then(() => {
+					message.delete();
+				}).catch(() => { message.error("misc:CANNOT_DM") });
+				return;
+			};
+		};
+
+		if (!channel) {
+			message.channel.messages.fetch(msgID).catch(() => {
+				message.author.send((message.translate("general/quote:NO_MESSAGE_ID"))).then(() => {
+					message.delete();
+				}).catch(() => { message.error("misc:CANNOT_DM") });
+				return;
+			}).then((msg) => {
+				message.delete();
+				message.channel.send(embed(msg));
+			});
+		} else {
+			channel.messages.fetch(msgID).catch(() => {
+				message.author.send(message.translate("general/quote:NO_MESSAGE_ID")).then(() => {
+					message.delete();
+				}).catch(() => { message.error("misc:CANNOT_DM") });
+				return;
+			}).then((msg) => {
+				message.delete();
+				message.channel.send(embed(msg));
+			});
+		};
+	}
+};
+
+module.exports = Quote;