You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
500 lines
18 KiB
JavaScript
500 lines
18 KiB
JavaScript
/* Module definition */
|
|
|
|
/* Variable Definition */
|
|
const Discord = require('discord.js'),
|
|
args = require('args-parser')(process.argv),
|
|
config = require('../config.json'),
|
|
gcmdTempl = require('../commands/globalcommands'),
|
|
scmdTempl = require('../commands/servercommands'),
|
|
utils = require('./utils');
|
|
|
|
let logger = require('winston'),
|
|
globCommands = {};
|
|
|
|
/**
|
|
* @type {Servant}
|
|
*/
|
|
exports.Servant = class {
|
|
constructor(prefix) {
|
|
this.commands = {};
|
|
this.prefix = prefix;
|
|
// show all commands (except the owner commands if the user is not an owner)
|
|
this.createCommand(gcmdTempl.utils.help, (msg, kwargs) => {
|
|
if (kwargs.command) {
|
|
let cmd = kwargs.command;
|
|
let allCommands = {...globCommands, ...this.commands};
|
|
if (cmd.charAt(0) !== prefix)
|
|
cmd = this.prefix + cmd;
|
|
if (allCommands[cmd])
|
|
return new Discord.RichEmbed()
|
|
.setTitle(`Help for ${cmd}`)
|
|
.addField('Usage', `\`${cmd} [${allCommands[cmd].args.join('] [')}]\``.replace('[]', ''))
|
|
.addField('Description', allCommands[cmd].description)
|
|
.addField('Permission Role', allCommands[cmd].role || 'all');
|
|
else
|
|
return 'Command not found :(';
|
|
|
|
} else {
|
|
let allCommands = {...globCommands, ...this.commands};
|
|
return createHelpEmbed(allCommands, msg, prefix);
|
|
}
|
|
});
|
|
|
|
// show all roles that are used by commands
|
|
this.createCommand(scmdTempl.utils.roles, () => {
|
|
let roles = [];
|
|
Object.values(globCommands).concat(Object.values(this.commands)).sort().forEach((value) => {
|
|
roles.push(value.role || 'all');
|
|
});
|
|
return `**Roles**\n${[...new Set(roles)].join('\n')}`;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Creates a command entry in the private commands dict
|
|
* @param template
|
|
* @param call
|
|
*/
|
|
createCommand(template, call) {
|
|
if (!template.name) {
|
|
logger.debug(`Name of command template is null or undef. Failed creating command.`);
|
|
return;
|
|
}
|
|
this.commands[this.prefix + template.name] = {
|
|
'args': template.args || [],
|
|
'description': template.description,
|
|
'callback': call,
|
|
'role': template.permission,
|
|
'category': template.category || 'Other'
|
|
};
|
|
logger.debug(`Created server command: ${this.prefix + template.name}, args: ${template.args}`);
|
|
}
|
|
|
|
/**
|
|
* Removes a command
|
|
* @param command
|
|
* @deprecated Why would you want to remove a command?
|
|
*/
|
|
removeCommand(command) {
|
|
delete this.commands[command];
|
|
}
|
|
|
|
/**
|
|
* Processes the command
|
|
* @param msg
|
|
* @param globResult
|
|
* @param content
|
|
* @param returnFunction Boolean if the return value should be a function.
|
|
* @param fallback
|
|
* @returns {*}
|
|
*/
|
|
processCommand(msg, globResult, content, returnFunction, fallback) {
|
|
let command = (content.match(/^.\w+/) || [])[0];
|
|
if (!command || !this.commands[command])
|
|
if (fallback && !globResult) {
|
|
command = fallback;
|
|
content = `${fallback} ${content}`;
|
|
} else {
|
|
return globResult;
|
|
}
|
|
let cmd = this.commands[command];
|
|
if (!checkPermission(msg, cmd.role))
|
|
return 'No Permission';
|
|
logger.debug(`Permission <${cmd.role || 'all'}> granted for command ${command} for user <${msg.author.tag}>`);
|
|
let argvars = content.match(/(?<= )\S+/g) || [];
|
|
let kwargs = {};
|
|
let nLength = Math.min(cmd.args.length, argvars.length);
|
|
for (let i = 0; i < nLength; i++)
|
|
kwargs[cmd.args[i]] = argvars[i];
|
|
|
|
let argv = argvars.slice(nLength);
|
|
logger.debug(`Executing callback for command: ${command}, kwargs: ${kwargs}, argv: ${argv}`);
|
|
try {
|
|
let locResult = returnFunction? () => cmd.callback(msg, kwargs, argv) : cmd.callback(msg, kwargs, argv);
|
|
return locResult || globResult;
|
|
} catch (err) {
|
|
logger.error(err.message);
|
|
return `The command \`${command}\` has thrown an error.`;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Parses the message and executes the command callback for the found command entry in the commands dict
|
|
* @param msg
|
|
* @returns {*}
|
|
*/
|
|
parseCommand(msg) {
|
|
let globResult = parseGlobalCommand(msg);
|
|
logger.debug(`Global command result is ${globResult}`);
|
|
let content = msg.content;
|
|
let commands = content.split(/(?<!\\);/).map(x => x.replace(/^ +/, ''));
|
|
if (commands.length === 1) {
|
|
return this.processCommand(msg, globResult, content);
|
|
} else if (commands.length < (config.maxCmdSequenceLength || 5)) {
|
|
let answers = [];
|
|
let previousCommand = (commands[0].match(/^.\w+/) || [])[0];
|
|
for (let i = 0; i < commands.length; i++) {
|
|
answers.push(this.processCommand(msg, globResult[i], commands[i],
|
|
true, previousCommand)); // return function to avoid "race conditions"
|
|
let commandMatch = (commands[i].match(/^.\w+/) || [])[0];
|
|
previousCommand = this.commands[commandMatch]? commandMatch : previousCommand;
|
|
}
|
|
|
|
return answers;
|
|
} else {
|
|
return 'This command sequence is too long!';
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
/**
|
|
* Getting the logger
|
|
* @param {Object} newLogger
|
|
*/
|
|
exports.setLogger = function (newLogger) {
|
|
logger = newLogger;
|
|
};
|
|
|
|
/**
|
|
* Creates a global command that can be executed in every channel.
|
|
* @param prefix
|
|
* @param template
|
|
* @param call
|
|
*/
|
|
exports.createGlobalCommand = function (prefix, template, call) {
|
|
if (!template.name) {
|
|
logger.debug(`Name of command template is null or undef. Failed to create command.`);
|
|
return;
|
|
}
|
|
globCommands[prefix + template.name] = {
|
|
'args': template.args || [],
|
|
'description': template.description,
|
|
'callback': call,
|
|
'role': template.permission,
|
|
'name': template.name,
|
|
'category': template.category || 'Other'
|
|
};
|
|
logger.debug(`Created global command: ${prefix + template.name}, args: ${template.args}`);
|
|
};
|
|
|
|
|
|
/**
|
|
* Parses a message for a global command
|
|
* @param msg
|
|
* @returns {boolean|*}
|
|
*/
|
|
exports.parseMessage = function (msg) {
|
|
return parseGlobalCommand(msg);
|
|
};
|
|
|
|
/**
|
|
* Initializes the module by creating a help command
|
|
*/
|
|
exports.init = function (prefix) {
|
|
logger.verbose("Creating help command...");
|
|
this.createGlobalCommand((prefix || config.prefix), gcmdTempl.utils.help, (msg, kwargs) => {
|
|
if (kwargs.command) {
|
|
let cmd = kwargs.command;
|
|
if (cmd.charAt(0) !== prefix)
|
|
cmd = prefix + cmd;
|
|
if (globCommands[cmd])
|
|
return new Discord.RichEmbed()
|
|
.setTitle(`Help for ${cmd}`)
|
|
.addField('Usage', `\`${cmd} [${globCommands[cmd].args.join('] [')}]\``.replace('[]', ''))
|
|
.addField('Description', globCommands[cmd].description)
|
|
.addField('Permission Role', globCommands[cmd].role || 'all');
|
|
|
|
} else {
|
|
return createHelpEmbed(globCommands, msg, prefix);
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Processes commands for command series.
|
|
* @param cmd
|
|
* @param msg
|
|
* @param content
|
|
* @param returnFunction
|
|
* @returns {function(): *}
|
|
*/
|
|
function processCommand(cmd, msg, content, returnFunction) {
|
|
let argvars = content.match(/(?<= )\S+/g) || [];
|
|
let kwargs = {};
|
|
let nLength = Math.min(cmd.args.length, argvars.length);
|
|
for (let i = 0; i < nLength; i++)
|
|
kwargs[cmd.args[i]] = argvars[i];
|
|
let argv = argvars.slice(nLength);
|
|
logger.debug(`Executing callback for command: ${cmd.name}, kwargs: ${JSON.stringify(kwargs)}, argv: ${argv}`);
|
|
return returnFunction? () => cmd.callback(msg, kwargs, argv) : cmd.callback(msg, kwargs, argv);
|
|
}
|
|
|
|
/**
|
|
* Parses the message by calling the assigned function for the command with arguments
|
|
* @param msg
|
|
*/
|
|
function parseGlobalCommand(msg) {
|
|
let content = msg.content;
|
|
let commands = content.split(/(?<!\\);/).map(x => x.replace(/^ +/, ''));
|
|
if (commands.length === 1) {
|
|
let command = (content.match(/^.\w+/) || [])[0];
|
|
if (!command || !globCommands[command])
|
|
return false;
|
|
let cmd = globCommands[command];
|
|
if (!checkPermission(msg, cmd.role))
|
|
return false;
|
|
logger.debug(`Permission <${cmd.role}> granted for command ${command} for user <${msg.author.tag}>`);
|
|
return processCommand(cmd, msg, content);
|
|
} else if (commands.length < (config.maxCmdSequenceLength || 5)) {
|
|
let answers = [];
|
|
let previousCommand = '';
|
|
for (let commandPart of commands) {
|
|
let command = (commandPart.match(/^.\w+/) || [])[0] || previousCommand;
|
|
previousCommand = globCommands[command]? command : previousCommand;
|
|
if (!commandPart || !globCommands[command]) {
|
|
commandPart = `${previousCommand} ${commandPart}`;
|
|
command = previousCommand;
|
|
}
|
|
if (command && globCommands[command]) {
|
|
let cmd = globCommands[command];
|
|
if (checkPermission(msg, cmd.role)) {
|
|
logger.debug(`Permission <${cmd.role}> granted for command ${command} for user <${msg.author.tag}>`);
|
|
answers.push(processCommand(cmd, msg, commandPart,
|
|
true)); // return an function to avoid "race conditions"
|
|
} else {
|
|
answers.push(false);
|
|
}
|
|
} else {
|
|
answers.push(false);
|
|
}
|
|
}
|
|
return answers;
|
|
} else {
|
|
return 'This command sequence is too long!';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a rich embed that contains help for all commands in the commands object
|
|
* @param commands {Object}
|
|
* @param msg {module:discord.js.Message}
|
|
* @param prefix {String}
|
|
* @returns {module:discord.js.RichEmbed}
|
|
*/
|
|
function createHelpEmbed(commands, msg, prefix) {
|
|
let helpEmbed = new Discord.RichEmbed()
|
|
.setTitle('Commands')
|
|
.setDescription('Create a sequence of commands with `;` (semicolon).')
|
|
.setTimestamp();
|
|
let categories = [];
|
|
let catCommands = {};
|
|
Object.entries(commands).sort().forEach(([key, value]) => {
|
|
if (value.role !== 'owner' || checkPermission(msg, 'owner'))
|
|
if (!categories.includes(value.category)) {
|
|
categories.push(value.category);
|
|
catCommands[value.category] = `\`${key}\` \t`;
|
|
} else {
|
|
catCommands[value.category] += `\`${key}\` \t`;
|
|
}
|
|
|
|
});
|
|
for (let cat of categories)
|
|
helpEmbed.addField(cat, catCommands[cat]);
|
|
|
|
helpEmbed.setFooter(prefix + 'help [command] for more info to each command');
|
|
return helpEmbed;
|
|
}
|
|
|
|
/**
|
|
* @param msg
|
|
* @param rolePerm {String}
|
|
* @returns {boolean}
|
|
*/
|
|
function checkPermission(msg, rolePerm) {
|
|
if (!rolePerm || ['all', 'any', 'everyone'].includes(rolePerm))
|
|
return true;
|
|
if (msg.author.tag === args.owner || config.owners.includes(msg.author.tag))
|
|
return true;
|
|
else
|
|
if (msg.member && rolePerm && rolePerm !== 'owner' && msg.member.roles
|
|
.some(role => (role.name.toLowerCase() === rolePerm.toLowerCase() || role.name.toLowerCase() === 'botcommander')))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Registers the bot's utility commands
|
|
* @param prefix
|
|
* @param bot - the instance of the bot that called
|
|
*/
|
|
exports.registerUtilityCommands = function(prefix, bot) {
|
|
// responde with the commands args
|
|
exports.createGlobalCommand(prefix, gcmdTempl.utils.say, (msg, argv, args) => {
|
|
return args.join(' ');
|
|
});
|
|
|
|
// adds a presence that will be saved in the presence file and added to the rotation
|
|
exports.createGlobalCommand(prefix, gcmdTempl.utils.addpresence, async (msg, argv, args) => {
|
|
let p = args.join(' ');
|
|
this.presences.push(p);
|
|
await bot.maindb.run('INSERT INTO presences (text) VALUES (?)', [p]);
|
|
return `Added Presence \`${p}\``;
|
|
});
|
|
|
|
// shuts down the bot after destroying the client
|
|
exports.createGlobalCommand(prefix, gcmdTempl.utils.shutdown, async (msg) => {
|
|
try {
|
|
await msg.reply('Shutting down...');
|
|
logger.debug('Destroying client...');
|
|
} catch (err) {
|
|
logger.error(err.message);
|
|
logger.debug(err.stack);
|
|
}
|
|
try {
|
|
await bot.client.destroy();
|
|
logger.debug('Exiting server...');
|
|
} catch (err) {
|
|
logger.error(err.message);
|
|
logger.debug(err.stack);
|
|
}
|
|
try {
|
|
await bot.webServer.stop();
|
|
logger.debug(`Exiting Process...`);
|
|
process.exit(0);
|
|
} catch (err) {
|
|
logger.error(err.message);
|
|
logger.debug(err.stack);
|
|
}
|
|
});
|
|
|
|
// forces a presence rotation
|
|
exports.createGlobalCommand(prefix, gcmdTempl.utils.rotate, () => {
|
|
try {
|
|
bot.client.clearInterval(this.rotator);
|
|
bot.rotatePresence();
|
|
bot.rotator = this.client.setInterval(() => this.rotatePresence(), config.presence_duration);
|
|
} catch (error) {
|
|
logger.warn(error.message);
|
|
}
|
|
});
|
|
|
|
exports.createGlobalCommand(prefix, gcmdTempl.utils.createUser, (msg, argv) => {
|
|
return new Promise((resolve, reject) => {
|
|
if (msg.guild) {
|
|
resolve("It's not save here! Try again via PM.");
|
|
} else if (argv.username && argv.scope) {
|
|
logger.debug(`Creating user entry ${argv.username}, scope: ${argv.scope}`);
|
|
|
|
bot.webServer.createUser(argv.username, argv.password, argv.scope, false).then((token) => {
|
|
resolve(`Created entry
|
|
username: ${argv.username},
|
|
scope: ${argv.scope},
|
|
token: ${token}
|
|
`);
|
|
}).catch((err) => reject(err.message));
|
|
}
|
|
});
|
|
});
|
|
|
|
exports.createGlobalCommand(prefix, gcmdTempl.utils.bugreport, () => {
|
|
return new Discord.RichEmbed()
|
|
.setTitle('Where to report a bug?')
|
|
.setDescription(gcmdTempl.utils.bugreport.response.bug_report);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Registers the bot's info commands
|
|
* @param prefix {String}
|
|
* @param bot {Object}
|
|
*/
|
|
exports.registerInfoCommands = function(prefix, bot) {
|
|
// ping command that returns the ping attribute of the client
|
|
exports.createGlobalCommand(prefix, gcmdTempl.info.ping, () => {
|
|
return `Current average ping: \`${bot.client.ping} ms\``;
|
|
});
|
|
|
|
// returns the time the bot is running
|
|
exports.createGlobalCommand(prefix, gcmdTempl.info.uptime, () => {
|
|
let uptime = utils.getSplitDuration(bot.client.uptime);
|
|
return new Discord.RichEmbed().setDescription(`
|
|
**${uptime.days}** days
|
|
**${uptime.hours}** hours
|
|
**${uptime.minutes}** minutes
|
|
**${uptime.seconds}** seconds
|
|
**${uptime.milliseconds}** milliseconds
|
|
`).setTitle('Uptime');
|
|
});
|
|
|
|
// returns the number of guilds, the bot has joined
|
|
exports.createGlobalCommand(prefix, gcmdTempl.info.guilds, () => {
|
|
return `Number of guilds: \`${bot.client.guilds.size}\``;
|
|
});
|
|
|
|
// returns information about the bot
|
|
exports.createGlobalCommand(prefix, gcmdTempl.info.about, () => {
|
|
return new Discord.RichEmbed()
|
|
.setTitle('About')
|
|
.setDescription(gcmdTempl.info.about.response.about_creator)
|
|
.addField('Icon', gcmdTempl.info.about.response.about_icon);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Registers all commands that use the anilist api.
|
|
* @param prefix {String}
|
|
*/
|
|
exports.registerAnilistApiCommands = function(prefix) {
|
|
const anilistApi = require('./anilistApiLib');
|
|
|
|
// returns the anime found for the name
|
|
exports.createGlobalCommand(prefix, gcmdTempl.api.AniList.animeSearch, async (msg, kwargs, argv) => {
|
|
try {
|
|
let animeData = await anilistApi.searchAnimeByName(argv.join(' '));
|
|
if (animeData) {
|
|
let response = new Discord.RichEmbed()
|
|
.setTitle(animeData.title.romaji)
|
|
.setDescription(animeData.description.replace(/<\/?.*?>/g, ''))
|
|
.setThumbnail(animeData.coverImage.large)
|
|
.setURL(animeData.siteUrl)
|
|
.setColor(animeData.coverImage.color)
|
|
.addField('Genres', animeData.genres.join(', '))
|
|
.setTimestamp();
|
|
if (animeData.studios.studioList.length > 0)
|
|
response.addField(animeData.studios.studioList.length === 1? 'Studio' : 'Studios', animeData.studios.studioList.map(x => `[${x.name}](${x.siteUrl})`));
|
|
response.addField('Scoring', `**Average Score:** ${animeData.averageScore}
|
|
**Favourites:** ${animeData.favourites}`);
|
|
|
|
if (animeData.episodes)
|
|
response.addField('Episodes', animeData.episodes);
|
|
response.addField('Season', animeData.season);
|
|
|
|
if (animeData.startDate.day)
|
|
response.addField('Start Date', `
|
|
${animeData.startDate.day}.${animeData.startDate.month}.${animeData.startDate.year}`);
|
|
|
|
if (animeData.nextAiringEpisode)
|
|
response.addField('Next Episode', `**Episode** ${animeData.nextAiringEpisode.episode}
|
|
**Airing at:** ${new Date(animeData.nextAiringEpisode.airingAt*1000).toUTCString()}`);
|
|
|
|
if (animeData.endDate.day)
|
|
response.addField('End Date', `
|
|
${animeData.endDate.day}.${animeData.endDate.month}.${animeData.endDate.year}`);
|
|
return response;
|
|
} else {
|
|
return gcmdTempl.api.AniList.animeSearch.response.not_found;
|
|
}
|
|
} catch (err) {
|
|
if (err.message) {
|
|
logger.warn(err.message);
|
|
logger.debug(err.stack);
|
|
} else {
|
|
logger.debug(JSON.stringify(err));
|
|
}
|
|
return gcmdTempl.api.AniList.animeSearch.response.not_found;
|
|
}
|
|
});
|
|
};
|